diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 5e406f93d..ac694b3ec 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -134,6 +134,22 @@ jobs: - run: cargo build --features sqlcipher --workspace --all-targets --verbose - run: cargo test --features sqlcipher --workspace --all-targets --verbose + 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: ./example-extension/integration-test.sh + + 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: ./example-embedded-extension/integration-test.sh + sanitizer: name: Address Sanitizer runs-on: ubuntu-latest @@ -170,6 +186,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 example-extension && cargo clippy --all-targets -- -D warnings) # Ensure patch is formatted. fmt: 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 ef5e4c84a..a63c29a13 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -40,7 +40,8 @@ backup = ["libsqlite3-sys/min_sqlite_version_3_6_23"] 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_7"] +# 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_6_23"] # sqlite3_db_release_memory: 3.7.10 (2012-01-16) @@ -49,6 +50,8 @@ bundled = ["libsqlite3-sys/bundled", "modern_sqlite"] bundled-sqlcipher = ["libsqlite3-sys/bundled-sqlcipher", "bundled"] bundled-sqlcipher-vendored-openssl = ["libsqlite3-sys/bundled-sqlcipher-vendored-openssl", "bundled-sqlcipher"] buildtime_bindgen = ["libsqlite3-sys/buildtime_bindgen"] +loadable_extension = ["libsqlite3-sys/loadable_extension"] +loadable_extension_embedded = ["loadable_extension", "libsqlite3-sys/loadable_extension_embedded"] limits = [] hooks = [] i128_blob = [] @@ -58,11 +61,11 @@ unlock_notify = ["libsqlite3-sys/unlock_notify"] vtab = ["libsqlite3-sys/min_sqlite_version_3_7_7"] 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 35c5f5327..338c6e6f7 100644 --- a/README.md +++ b/README.md @@ -193,6 +193,7 @@ 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 any of the `bundled` features, you will get pregenerated bindings for the bundled version of SQLite/SQLCipher. If you need other specific pregenerated binding 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/example-embedded-extension/Cargo.toml b/example-embedded-extension/Cargo.toml new file mode 100644 index 000000000..ee3fcaa1a --- /dev/null +++ b/example-embedded-extension/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "example-embedded-extension" +version = "0.0.1" +authors = ["The rusqlite developers"] +edition = "2018" +repository = "https://github.com/rusqlite/rusqlite" +description = "Example 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"] + +[build-dependencies] +cbindgen = "0.18.0" + +[workspace] +members = [] diff --git a/example-embedded-extension/build.rs b/example-embedded-extension/build.rs new file mode 100644 index 000000000..86450f0ff --- /dev/null +++ b/example-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("example-embedded-extension.h"); +} diff --git a/example-embedded-extension/example-c-host-extension/example_c_host_extension.c b/example-embedded-extension/example-c-host-extension/example_c_host_extension.c new file mode 100644 index 000000000..740a0444e --- /dev/null +++ b/example-embedded-extension/example-c-host-extension/example_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 "example-embedded-extension.h" + +// the extension entry point +int sqlite3_examplechostextension_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 = example_embedded_extension_init(db, pzErrMsg); + + return rc; +} diff --git a/example-embedded-extension/integration-test.sh b/example-embedded-extension/integration-test.sh new file mode 100755 index 000000000..092e0c37d --- /dev/null +++ b/example-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 +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 +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="example_embedded_test_value" + +# expected output from function query +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}/../libsqlite3-sys/sqlite3} + +>&2 echo "checking for sqlite3 shell" +sqlite3_cmd=$(which sqlite3) +>&2 echo "sqlite3 found: ${sqlite3_cmd}" + +# 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 example-embedded-extension crate" + +# build the C-based 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 ${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 ${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) + +>&2 echo "All tests passed." +exit 0 diff --git a/example-embedded-extension/src/lib.rs b/example-embedded-extension/src/lib.rs new file mode 100644 index 000000000..aceac63bd --- /dev/null +++ b/example-embedded-extension/src/lib.rs @@ -0,0 +1,135 @@ +use crate::ffi::loadable_extension_embedded_init; // required feature `loadable_extension_embedded` +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}; + +/// 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 `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 +/// 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. +/// +/// # 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, + 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 to_sqlite_error(&err, pz_err_msg); + } + + ffi::SQLITE_OK +} + +#[repr(C)] +struct ExampleEmbeddedTab { + /// Base class. Must be first + base: sqlite3_vtab, +} + +unsafe impl<'vtab> VTab<'vtab> for ExampleEmbeddedTab { + type Aux = (); + type Cursor = ExampleEmbeddedTabCursor<'vtab>; + + fn connect( + _: &mut VTabConnection, + _aux: Option<&()>, + _args: &[&[u8]], + ) -> Result<(String, ExampleEmbeddedTab)> { + let vtab = ExampleEmbeddedTab { + 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(ExampleEmbeddedTabCursor::default()) + } +} + +#[derive(Default)] +#[repr(C)] +struct ExampleEmbeddedTabCursor<'vtab> { + /// Base class. Must be first + base: sqlite3_vtab_cursor, + /// The rowid + row_id: i64, + phantom: PhantomData<&'vtab ExampleEmbeddedTab>, +} + +unsafe impl VTabCursor for ExampleEmbeddedTabCursor<'_> { + 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(&"example_embedded_test_value".to_string()) + } + + fn rowid(&self) -> Result { + Ok(self.row_id) + } +} + +fn example_embedded_init(db: *mut ffi::sqlite3) -> Result<()> { + let conn = unsafe { Connection::from_handle(db)? }; + eprintln!("inited example embedded extension module {:?}", db); + conn.create_scalar_function( + "example_embedded_test_function", + 0, + FunctionFlags::SQLITE_DETERMINISTIC, + |_ctx| { + Ok(ToSqlOutput::Owned(Value::Text( + "Example embedded extension loaded correctly!".to_string(), + ))) + }, + )?; + conn.create_module::("example_embedded", eponymous_only_module::(), None) +} diff --git a/example-extension/.gitignore b/example-extension/.gitignore new file mode 100644 index 000000000..5f0a3e16d --- /dev/null +++ b/example-extension/.gitignore @@ -0,0 +1,3 @@ +/target/ +/doc/ +Cargo.lock diff --git a/example-extension/Cargo.toml b/example-extension/Cargo.toml new file mode 100644 index 000000000..7be7b9aa1 --- /dev/null +++ b/example-extension/Cargo.toml @@ -0,0 +1,22 @@ +[package] +name = "example-extension" +version = "0.0.1" +authors = ["The rusqlite developers"] +edition = "2018" +repository = "https://github.com/rusqlite/rusqlite" +description = "Example extension to demonstrate and test rusqlite feature loadable_extension" +license = "MIT" +keywords = ["sqlite", "extension"] + +[lib] +crate-type = ["cdylib"] + +[dependencies] + +[dependencies.rusqlite] +path = ".." +default-features = false +features = ["loadable_extension", "vtab", "functions", "bundled"] + +[workspace] +members = [] diff --git a/example-extension/integration-test.sh b/example-extension/integration-test.sh new file mode 100755 index 000000000..6bb924e7c --- /dev/null +++ b/example-extension/integration-test.sh @@ -0,0 +1,37 @@ +#!/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 extension within the target dir +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="Example extension loaded correctly!" + +>&2 echo "checking for sqlite3 shell" +sqlite3_cmd=$(which sqlite3) +>&2 echo "sqlite3 found: ${sqlite3_cmd}" + +# 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 example-extension crate" + +>&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 ${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) + +>&2 echo "All tests passed." +exit 0 diff --git a/example-extension/src/lib.rs b/example-extension/src/lib.rs new file mode 100644 index 000000000..2f1b30d3f --- /dev/null +++ b/example-extension/src/lib.rs @@ -0,0 +1,126 @@ +use crate::ffi::loadable_extension_init; +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}; + +#[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, + p_api: *mut ffi::sqlite3_api_routines, +) -> c_int { + // SQLITE_EXTENSION_INIT2 equivalent + loadable_extension_init(p_api); + + // initialize example virtual table + let res = example_init(db); + if let Err(err) = res { + return to_sqlite_error(&err, pz_err_msg); + } + + ffi::SQLITE_OK +} + +#[repr(C)] +struct ExampleTab { + /// Base class. Must be first + base: sqlite3_vtab, +} + +unsafe impl<'vtab> VTab<'vtab> for ExampleTab { + type Aux = (); + type Cursor = ExampleTabCursor<'vtab>; + + fn connect( + _: &mut VTabConnection, + _aux: Option<&()>, + _args: &[&[u8]], + ) -> Result<(String, ExampleTab)> { + let vtab = ExampleTab { + 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(&'vtab self) -> Result> { + Ok(ExampleTabCursor::default()) + } +} + +#[derive(Default)] +#[repr(C)] +struct ExampleTabCursor<'vtab> { + /// Base class. Must be first + base: sqlite3_vtab_cursor, + /// The rowid + row_id: i64, + phantom: PhantomData<&'vtab ExampleTab>, +} + +unsafe impl VTabCursor for ExampleTabCursor<'_> { + 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 example_init(db: *mut ffi::sqlite3) -> Result<()> { + let conn = unsafe { Connection::from_handle(db)? }; + eprintln!("inited example module {:?}", db); + conn.create_scalar_function( + "example_test_function", + 0, + FunctionFlags::SQLITE_DETERMINISTIC, + |_ctx| { + Ok(ToSqlOutput::Owned(Value::Text( + "Example extension loaded correctly!".to_string(), + ))) + }, + )?; + conn.create_module::("example", eponymous_only_module::(), None) +} diff --git a/libsqlite3-sys/Cargo.toml b/libsqlite3-sys/Cargo.toml index c507e6fb3..ed82f7877 100644 --- a/libsqlite3-sys/Cargo.toml +++ b/libsqlite3-sys/Cargo.toml @@ -18,6 +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 = ["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"] @@ -44,10 +46,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"] } -pkg-config = { version = "0.3.19", optional = true } 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/README.md b/libsqlite3-sys/bindgen-bindings/README.md new file mode 100644 index 000000000..2f64726a4 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/README.md @@ -0,0 +1,23 @@ +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. + +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..6c29a0c65 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs @@ -0,0 +1,6972 @@ +/* automatically generated by rust-bindgen 0.59.2 */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &[u8; 7usize] = b"3.6.23\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3006023; +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; +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) + ) + ); +} + +// 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 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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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() { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 index 673b11ddb..f10cdfa80 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 */ +/* 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\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,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" { @@ -226,19 +225,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 +247,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 +531,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 +822,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 +968,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 +1038,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 +1473,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 +1581,555 @@ 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" { 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 +2143,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 +2152,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 +2612,489 @@ 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.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs new file mode 100644 index 000000000..d7c0fb544 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs @@ -0,0 +1,6950 @@ +/* automatically generated by rust-bindgen 0.59.2 */ + +pub const __GNUC_VA_LIST: i32 = 1; +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; +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" { + 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_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) + ) + ); +} + +// 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 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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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() { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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.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 new file mode 100644 index 000000000..23ef550c0 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs @@ -0,0 +1,9125 @@ +/* automatically generated by rust-bindgen 0.59.2 */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &[u8; 7usize] = b"3.7.16\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3007016; +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; +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" { + 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; +} +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, + >, +} +#[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) + ) + ); +} + +// 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 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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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() { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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, +) -> ::std::os::raw::c_int { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_api).wal_checkpoint_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} 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..aab45af9c --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs @@ -0,0 +1,8206 @@ +/* automatically generated by rust-bindgen 0.59.2 */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &[u8; 6usize] = b"3.7.7\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3007007; +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; +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) + ) + ); +} + +// 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 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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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() { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 index 37bebe388..549d9a9a3 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 */ +/* 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\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,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" { @@ -271,19 +270,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 +292,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 +641,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 +997,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 +1143,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 +1221,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 +1690,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 +1798,186 @@ 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" { - 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 +1986,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 +2411,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 +2420,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 +2886,621 @@ 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/build.rs b/libsqlite3-sys/build.rs index 33c47726d..ed012f717 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -48,7 +48,9 @@ fn main() { or 'bundled-sqlcipher-vendored-openssl' to also bundle OpenSSL crypto." ); } - build_linked::main(&out_dir, &out_path); + build_linked::main(&out_dir, &out_path) + } else if cfg!(feature = "loadable_extension") { + build_loadable_extension::main(&out_dir, &out_path) } else if cfg!(feature = "bundled") || (win_target() && cfg!(feature = "bundled-windows")) || cfg!(feature = "bundled-sqlcipher") @@ -91,15 +93,18 @@ mod build_bundled { #[cfg(feature = "buildtime_bindgen")] { - use super::{bindings, HeaderLocation}; - let header = HeaderLocation::FromPath(format!("{}/sqlite3.h", lib_name)); + use super::{bindings, header_file, HeaderLocation}; + let header_path = format!("{}/{}", lib_name, header_file()); + let header = HeaderLocation::FromPath(header_path.clone()); 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(format!("{}/bindgen_bundled_version.rs", lib_name), 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=sqlcipher/sqlite3.c"); @@ -313,6 +318,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" + } +} + fn lib_name() -> &'static str { if cfg!(any(feature = "sqlcipher", feature = "bundled-sqlcipher")) { "sqlcipher" @@ -340,10 +361,11 @@ impl From for String { prefix, prefix ) }); - header.push_str("/sqlite3.h"); + header.push('/'); + header.push_str(header_file()); header } - HeaderLocation::Wrapper => "wrapper.h".into(), + HeaderLocation::Wrapper => wrapper_file().into(), HeaderLocation::FromPath(path) => path, } } @@ -353,7 +375,9 @@ mod build_linked { #[cfg(feature = "vcpkg")] extern crate vcpkg; - use super::{bindings, env_prefix, 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; @@ -454,7 +478,7 @@ mod build_linked { // See if vcpkg can find it. if let Ok(mut lib) = vcpkg::Config::new().probe(lib_name()) { 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())); } } @@ -465,6 +489,76 @@ mod build_linked { } } +mod build_loadable_extension { + 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!(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); + } + + // 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!(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 { + let link_lib = "sqlite3"; + // 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 { #![allow(dead_code)] @@ -474,18 +568,41 @@ mod bindings { use std::path::Path; static PREBUILT_BINDGEN_PATHS: &[&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(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) { - 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).unwrap_or_else(|_| { + panic!( + "Could not copy bindings to output directory from {}", + in_path + ) + }); + } + + fn prebuilt_bindgen_ext() -> &'static str { + if cfg!(feature = "loadable_extension") { + "-ext" + } else { + "" + } } } @@ -528,23 +645,59 @@ 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() .trust_clang_mangling(false) .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 @@ -575,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 @@ -590,39 +775,274 @@ 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 blocklist_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. if generating_bundled_bindings() || is_cross_compiling { - // Get rid of va_list, as it's not + // get rid of blocklisted functions that use va_list + for fn_name in blocklist_va_list_functions { + 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 - .blocklist_function("sqlite3_vmprintf") - .blocklist_function("sqlite3_vsnprintf") - .blocklist_function("sqlite3_str_vappendf") .blocklist_type("va_list") .blocklist_type("__builtin_va_list") .blocklist_type("__gnuc_va_list") - .blocklist_type("__va_list_tag") .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 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")] + { + 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)) .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?!"); - // 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"); + #[allow(unused_mut)] + let mut output_string = String::from_utf8(output).expect("bindgen output was not UTF-8?!"); + + #[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_with_comments_string, &api_routines_struct_name) { + Some(s) => s, + None => { + panic!( + "Failed to find struct {} in early bindgen output", + &api_routines_struct_name + ); + } + }; + + output_string.push_str( + r#" + +// 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 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 { + Some(ident) => ident, + None => { + panic!("Unexpected anonymous field in sqlite"); + } + }; + 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); + + if (generating_bundled_bindings() || is_cross_compiling) + && blocklist_va_list_functions + .iter() + .any(|fn_name| *fn_name == api_fn_name) + { + // skip this function as it is blocklisted when generating bundled bindings or cross compiling + continue; + } + + // 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, + ); + output_string.push_str(&wrapper); + } + + output_string.push('\n'); } + #[allow(unused_mut)] let mut file = OpenOptions::new() .write(true) .truncate(true) @@ -630,7 +1050,298 @@ mod bindings { .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")] + 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()); + } + } + } + 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_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, + syn_type: &syn::Type, + api_fn_name: &str, + require_sqlite3_version: Option<&str>, + ) -> String { + use quote::quote; + use std::collections::BTreeMap; + + let field_name = field_ident.to_string(); + + // 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; + + // a map of wrapper function names to function inputs vectors + let mut wrapper_fn_inputs_map: BTreeMap< + String, + syn::punctuated::Punctuated, + > = BTreeMap::new(); + + // 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. + match api_fn_name { + "sqlite3_db_config" => { + // 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 + } + "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 + } + _ => {} + }; + } + + 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 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 { + let p_api = loadable_extension_sqlite3_api(); + #api_version_check_tokens + 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),* + ) + } + }; + 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 new file mode 100644 index 000000000..c7e598056 --- /dev/null +++ b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs @@ -0,0 +1,12633 @@ +/* automatically generated by rust-bindgen 0.59.2 */ + +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; +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_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; +pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; +pub const SQLITE_BUSY_TIMEOUT: i32 = 773; +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_CORRUPT_INDEX: i32 = 779; +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_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; +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_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_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; +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_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; +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_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; +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_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; +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_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; +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_SEEK_COUNT: 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; +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; +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(Debug, 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, + >, + pub create_filename: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + arg5: *mut *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char, + >, + pub free_filename: + ::std::option::Option, + 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, + >, + 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::(), + 2048usize, + 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) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_filename as *const _ as usize + }, + 1992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_filename) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).free_filename as *const _ as usize + }, + 2000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_filename) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).database_file_object as *const _ + as usize + }, + 2008usize, + concat!( + "Offset of field: ", + stringify!(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) + ) + ); + 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( + db: *mut sqlite3, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + pThunk: *const sqlite3_api_routines, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[repr(align(8))] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub _bindgen_opaque_blob: [u64; 3usize], +} +#[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)) + ); +} + +// 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 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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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, +) -> *mut ::std::os::raw::c_char { + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).xsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xsnprintf", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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() { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_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 { + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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, +) -> ::std::os::raw::c_int { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_api).uri_parameter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_parameter", + " function" + )))(arg1, arg2) +} + +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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_api).realloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset_auto_extension() { + 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 + ); + } + ((*p_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, +) { + 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 + ); + } + ((*p_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, +) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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, +) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_api).str_appendf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_appendf", + " function" + )))(arg1, zFormat) +} + +pub unsafe fn sqlite3_str_append( + arg1: *mut sqlite3_str, + zIn: *const ::std::os::raw::c_char, + N: ::std::os::raw::c_int, +) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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, +) { + 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 + ); + } + ((*p_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) { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_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 { + 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 + ); + } + ((*p_api).filename_wal.expect(stringify!( + "sqlite3_api contains null pointer for ", + "filename_wal", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_filename( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + arg5: *mut *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + 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 + ); + } + ((*p_api).create_filename.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_filename", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_free_filename(arg1: *mut ::std::os::raw::c_char) { + 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 + ); + } + ((*p_api).free_filename.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_filename", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_database_file_object( + arg1: *const ::std::os::raw::c_char, +) -> *mut sqlite3_file { + 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 + ); + } + ((*p_api).database_file_object.expect(stringify!( + "sqlite3_api contains null pointer for ", + "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 { + 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 + ); + } + ((*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 5141df391..77736ee53 100644 --- a/libsqlite3-sys/src/lib.rs +++ b/libsqlite3-sys/src/lib.rs @@ -25,6 +25,24 @@ pub fn SQLITE_TRANSIENT() -> sqlite3_destructor_type { Some(unsafe { mem::transmute(-1_isize) }) } +#[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") +))] +pub use loadable_extension::loadable_extension_init; + #[allow(clippy::all)] mod bindings { include!(concat!(env!("OUT_DIR"), "/bindgen.rs")); diff --git a/libsqlite3-sys/src/loadable_extension.rs b/libsqlite3-sys/src/loadable_extension.rs new file mode 100644 index 000000000..1cb65bfdb --- /dev/null +++ b/libsqlite3-sys/src/loadable_extension.rs @@ -0,0 +1,158 @@ +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 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 +/// libsqlite3_sys::loadable_extension_init(p_api); +/// +/// libsqlite3_sys::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 d0f63ca84..c67e1308f 100755 --- a/libsqlite3-sys/upgrade.sh +++ b/libsqlite3-sys/upgrade.sh @@ -1,5 +1,6 @@ #!/bin/sh -e +TARGET_DIR="$SCRIPT_DIR/../target" # ensure target dir is deterministic SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd) echo "$SCRIPT_DIR" cd "$SCRIPT_DIR" || { echo "fatal error" >&2; exit 1; } @@ -19,10 +20,23 @@ rm -f "$SQLITE.zip" # Regenerate bindgen file for sqlite3 rm -f "$SQLITE3_LIB_DIR/bindgen_bundled_version.rs" 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 {} \; -env LIBSQLITE3_SYS_BUNDLING=1 cargo build --features "buildtime_bindgen session" --no-default-features -find "$SCRIPT_DIR/../target" -type f -name bindgen.rs -exec mv {} "$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 "$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 mv {} "$target_file" \; + # rerun rustfmt after (possibly) adding wrappers + rustfmt "$target_file" +} + +# Regenerate bindgen files +generate_bindgen_binding "buildtime_bindgen session" "$SQLITE3_LIB_DIR/bindgen_bundled_version.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; } 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/config.rs b/src/config.rs index b295d9776..e43524749 100644 --- a/src/config.rs +++ b/src/config.rs @@ -83,12 +83,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) } } @@ -112,12 +120,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 7401b7aa2..66d4ef187 100644 --- a/src/error.rs +++ b/src/error.rs @@ -443,3 +443,24 @@ pub fn check(code: c_int) -> Result<()> { Ok(()) } } + +/// Transform Rust error to SQLite error (message and code). +/// # Safety +/// This function is unsafe because it uses raw pointer +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 = crate::util::SqliteMallocString::from_str(s).into_raw(); + } + err.extended_code + } + err => { + *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 a5dea1ab1..7d0496f7d 100644 --- a/src/inner_connection.rs +++ b/src/inner_connection.rs @@ -4,7 +4,7 @@ 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::atomic::AtomicBool; use std::sync::{Arc, Mutex}; use super::ffi; @@ -13,7 +13,6 @@ use super::{Connection, InterruptHandle, OpenFlags, Result}; use crate::error::{error_from_handle, error_from_sqlite_code, error_with_offset, Error}; use crate::raw_statement::RawStatement; use crate::statement::Statement; -use crate::version::version_number; pub struct InnerConnection { pub db: *mut ffi::sqlite3, @@ -386,20 +385,28 @@ impl Drop for InnerConnection { } } -#[cfg(not(any(target_arch = "wasm32")))] +#[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); // threading mode checks are not necessary (and do not work) on target // platforms that do not have threading (such as webassembly) -#[cfg(any(target_arch = "wasm32"))] +// +// 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")))] +#[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; + // Ensure SQLite was compiled in thredsafe mode. if unsafe { ffi::sqlite3_threadsafe() == 0 } { return Err(Error::SqliteSingleThreadedMode); diff --git a/src/lib.rs b/src/lib.rs index bb998fae7..658e9f63e 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -76,6 +76,7 @@ use crate::types::ValueRef; pub use crate::cache::CachedStatement; pub use crate::column::Column; +pub use crate::error::to_sqlite_error; pub use crate::error::Error; pub use crate::ffi::ErrorCode; #[cfg(feature = "load_extension")] @@ -1172,7 +1173,11 @@ impl InterruptHandle { pub fn interrupt(&self) { let db_handle = self.db_lock.lock().unwrap(); if !db_handle.is_null() { - unsafe { ffi::sqlite3_interrupt(*db_handle) } + #[cfg(not(feature = "loadable_extension"))] + // no sqlite3_interrupt in a loadable extension + unsafe { + ffi::sqlite3_interrupt(*db_handle) + } } } } diff --git a/src/trace.rs b/src/trace.rs index 7fc90902c..b694f2a38 100644 --- a/src/trace.rs +++ b/src/trace.rs @@ -1,15 +1,16 @@ //! 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}; +#[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; 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 +26,9 @@ 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(feature = "loadable_extension"))] +pub unsafe fn config_log(callback: Option) -> crate::Result<()> { + use crate::error::error_from_sqlite_code; 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) }; @@ -55,8 +58,10 @@ pub unsafe fn config_log(callback: Option) -> Result<()> { /// Write a message into the error log established by /// `config_log`. #[inline] +#[cfg(not(feature = "loadable_extension"))] pub fn log(err_code: c_int, msg: &str) { - let msg = CString::new(msg).expect("SQLite log messages cannot contain embedded zeroes"); + 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()); } diff --git a/src/util/mod.rs b/src/util/mod.rs index 2b8dcfda1..b57f87cd4 100644 --- a/src/util/mod.rs +++ b/src/util/mod.rs @@ -4,8 +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 = "modern_sqlite", feature = "vtab"))] mod sqlite_string; -#[cfg(any(feature = "modern_sqlite", feature = "vtab"))] pub(crate) use sqlite_string::SqliteMallocString; diff --git a/src/util/sqlite_string.rs b/src/util/sqlite_string.rs index da261ba3b..06a703f80 100644 --- a/src/util/sqlite_string.rs +++ b/src/util/sqlite_string.rs @@ -1,10 +1,3 @@ -// 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 = "modern-sqlite")), - allow(dead_code) -)] use crate::ffi; use std::marker::PhantomData; use std::os::raw::{c_char, c_int}; diff --git a/tests/config_log.rs b/tests/config_log.rs index 0c28bdf1d..0875ba3f0 100644 --- a/tests/config_log.rs +++ b/tests/config_log.rs @@ -2,7 +2,7 @@ //! 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(feature = "loadable_extension")))] fn main() { use lazy_static::lazy_static; use std::os::raw::c_int; @@ -30,5 +30,5 @@ fn main() { assert_eq!(logs_received[0].1, "First message from rusqlite"); } -#[cfg(not(feature = "trace"))] +#[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 adfc8e55c..917281003 100644 --- a/tests/deny_single_threaded_sqlite_config.rs +++ b/tests/deny_single_threaded_sqlite_config.rs @@ -1,11 +1,12 @@ //! 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(feature = "loadable_extension"))] #[test] fn test_error_when_singlethread_mode() { + use rusqlite::ffi; + use rusqlite::Connection; + // put SQLite into single-threaded mode unsafe { // Note: macOS system SQLite seems to return an error if you attempt to