diff --git a/Cargo.toml b/Cargo.toml index 1680d5d..0b0a5d5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -15,12 +15,14 @@ sqlite-loadable-macros={version="0.0.3", path="./sqlite-loadable-macros"} serde = {version="1.0.147", features = ["derive"]} serde_json = "1.0.87" bitflags = "1.3.2" +libsqlite3-sys = {version="0.26.0", default-features = false, optional=true, features=["bundled"]} [dev-dependencies] rusqlite = "0.29.0" libsqlite3-sys = {version="0.26.0", default-features = false, features=["bundled"]} [features] +static = ["libsqlite3-sys"] exec = [] [lib] diff --git a/Makefile b/Makefile index 7644c60..388ea3e 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,6 @@ test: cargo test cargo test --features=exec + cargo test --features=static + cargo build --examples --features= python3 examples/test-examples.py diff --git a/NOTES b/NOTES index 41eef6a..78c3533 100644 --- a/NOTES +++ b/NOTES @@ -35,13 +35,6 @@ Solution: the `ext.rs` functions need to export different functions (either `pAp Though there's no `crate_type="cdylib"` macro we can use, so gotta introduce a new feature flag. Also means builds will be weird. -```toml -[dependencies] -libsqlite3-sys = {version="0.26.0", default-features = false, optional=true, features=["bundled"]} - -[features] -static = ["libsqlite3-sys"] -``` ```rs #[cfg(feature = "static")] diff --git a/src/api.rs b/src/api.rs index cd07142..11e444f 100644 --- a/src/api.rs +++ b/src/api.rs @@ -7,20 +7,17 @@ use crate::constants::SQLITE_OKAY; use crate::ext::{ - sqlite3ext_context_db_handle, sqlite3ext_get_auxdata, sqlite3ext_mprintf, - sqlite3ext_overload_function, sqlite3ext_result_blob, sqlite3ext_result_double, - sqlite3ext_result_error, sqlite3ext_result_error_code, sqlite3ext_result_int, - sqlite3ext_result_int64, sqlite3ext_result_null, sqlite3ext_result_pointer, - sqlite3ext_result_subtype, sqlite3ext_result_text, sqlite3ext_set_auxdata, - sqlite3ext_value_blob, sqlite3ext_value_bytes, sqlite3ext_value_double, sqlite3ext_value_int, - sqlite3ext_value_int64, sqlite3ext_value_pointer, sqlite3ext_value_subtype, - sqlite3ext_value_text, sqlite3ext_value_type, + sqlite3, sqlite3_context, sqlite3_value, sqlite3ext_context_db_handle, sqlite3ext_get_auxdata, + sqlite3ext_mprintf, sqlite3ext_overload_function, sqlite3ext_result_blob, + sqlite3ext_result_double, sqlite3ext_result_error, sqlite3ext_result_error_code, + sqlite3ext_result_int, sqlite3ext_result_int64, sqlite3ext_result_null, + sqlite3ext_result_pointer, sqlite3ext_result_subtype, sqlite3ext_result_text, + sqlite3ext_set_auxdata, sqlite3ext_value_blob, sqlite3ext_value_bytes, sqlite3ext_value_double, + sqlite3ext_value_int, sqlite3ext_value_int64, sqlite3ext_value_pointer, + sqlite3ext_value_subtype, sqlite3ext_value_text, sqlite3ext_value_type, }; use crate::Error; -use sqlite3ext_sys::{ - sqlite3, sqlite3_context, sqlite3_value, SQLITE_BLOB, SQLITE_FLOAT, SQLITE_INTEGER, - SQLITE_NULL, SQLITE_TEXT, -}; +use sqlite3ext_sys::{SQLITE_BLOB, SQLITE_FLOAT, SQLITE_INTEGER, SQLITE_NULL, SQLITE_TEXT}; use std::os::raw::c_int; use std::slice::from_raw_parts; use std::str::Utf8Error; diff --git a/src/collation.rs b/src/collation.rs index 77bc543..b234b0c 100644 --- a/src/collation.rs +++ b/src/collation.rs @@ -4,9 +4,8 @@ use crate::{ constants::SQLITE_OKAY, errors::{Error, ErrorKind, Result}, - ext::sqlite3ext_collation_v2, + ext::{sqlite3, sqlite3ext_collation_v2}, }; -use sqlite3ext_sys::sqlite3; use std::{ffi::CString, os::raw::c_void}; use sqlite3ext_sys::SQLITE_UTF8; diff --git a/src/entrypoints.rs b/src/entrypoints.rs index d34c22c..1301e41 100644 --- a/src/entrypoints.rs +++ b/src/entrypoints.rs @@ -1,8 +1,11 @@ //! Utilities for working with SQLite's "sqlite3_extension_init"-style //! entrypoints. -use crate::{errors::Result, ext::faux_sqlite_extension_init2}; +use crate::{ + errors::Result, + ext::{faux_sqlite_extension_init2, sqlite3, sqlite3_api_routines}, +}; -use sqlite3ext_sys::{sqlite3, sqlite3_api_routines, SQLITE_OK}; +use sqlite3ext_sys::SQLITE_OK; use std::os::raw::{c_char, c_uint}; diff --git a/src/ext.rs b/src/ext.rs index 88210ae..5d2b460 100644 --- a/src/ext.rs +++ b/src/ext.rs @@ -15,9 +15,21 @@ use std::{ os::raw::{c_char, c_int, c_uchar, c_void}, }; -use sqlite3ext_sys::{ - sqlite3, sqlite3_api_routines, sqlite3_context, sqlite3_index_info, sqlite3_module, - sqlite3_stmt, sqlite3_value, +#[cfg(feature = "static")] +pub use libsqlite3_sys::{ + sqlite3, sqlite3_api_routines, sqlite3_context, + sqlite3_index_constraint as sqlite3_index_info_sqlite3_index_constraint, + sqlite3_index_constraint_usage as sqlite3_index_info_sqlite3_index_constraint_usage, + sqlite3_index_info, sqlite3_index_orderby as sqlite3_index_info_sqlite3_index_orderby, + sqlite3_module, sqlite3_stmt, sqlite3_value, sqlite3_vtab, sqlite3_vtab_cursor, +}; + +#[cfg(not(feature = "static"))] +pub use sqlite3ext_sys::{ + sqlite3, sqlite3_api_routines, sqlite3_context, sqlite3_index_info, + sqlite3_index_info_sqlite3_index_constraint, sqlite3_index_info_sqlite3_index_constraint_usage, + sqlite3_index_info_sqlite3_index_orderby, sqlite3_module, sqlite3_stmt, sqlite3_value, + sqlite3_vtab, sqlite3_vtab_cursor, }; /// If creating a dynmically loadable extension, this MUST be redefined to point @@ -42,25 +54,60 @@ pub unsafe fn faux_sqlite_extension_init2(api: *mut sqlite3_api_routines) { static EXPECT_MESSAGE: &str = "sqlite-loadable error: expected method on SQLITE3_API. Please file an issue"; +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + libsqlite3_sys::sqlite3_value_text(arg1) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { ((*SQLITE3_API).value_text.expect(EXPECT_MESSAGE))(arg1) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_value_type(value: *mut sqlite3_value) -> i32 { + libsqlite3_sys::sqlite3_value_type(value) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_value_type(value: *mut sqlite3_value) -> i32 { ((*SQLITE3_API).value_type.expect(EXPECT_MESSAGE))(value) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_value_subtype(value: *mut sqlite3_value) -> u32 { + libsqlite3_sys::sqlite3_value_subtype(value) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_value_subtype(value: *mut sqlite3_value) -> u32 { ((*SQLITE3_API).value_subtype.expect(EXPECT_MESSAGE))(value) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_value_bytes(arg1: *mut sqlite3_value) -> i32 { + libsqlite3_sys::sqlite3_value_bytes(arg1) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_value_bytes(arg1: *mut sqlite3_value) -> i32 { ((*SQLITE3_API).value_bytes.expect(EXPECT_MESSAGE))(arg1) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_value_blob(arg1: *mut sqlite3_value) -> *const c_void { + libsqlite3_sys::sqlite3_value_blob(arg1) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_value_blob(arg1: *mut sqlite3_value) -> *const c_void { ((*SQLITE3_API).value_blob.expect(EXPECT_MESSAGE))(arg1) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_bind_pointer( + db: *mut sqlite3_stmt, + i: i32, + p: *mut c_void, + t: *const c_char, +) -> i32 { + libsqlite3_sys::sqlite3_bind_pointer(db, i, p, t, None) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_bind_pointer( db: *mut sqlite3_stmt, i: i32, @@ -69,28 +116,70 @@ pub unsafe fn sqlite3ext_bind_pointer( ) -> i32 { ((*SQLITE3_API).bind_pointer.expect(EXPECT_MESSAGE))(db, i, p, t, None) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_step(stmt: *mut sqlite3_stmt) -> c_int { + libsqlite3_sys::sqlite3_step(stmt) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_step(stmt: *mut sqlite3_stmt) -> c_int { ((*SQLITE3_API).step.expect(EXPECT_MESSAGE))(stmt) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_finalize(stmt: *mut sqlite3_stmt) -> c_int { + libsqlite3_sys::sqlite3_finalize(stmt) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_finalize(stmt: *mut sqlite3_stmt) -> c_int { ((*SQLITE3_API).finalize.expect(EXPECT_MESSAGE))(stmt) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_column_text(stmt: *mut sqlite3_stmt, c: c_int) -> *const c_uchar { + libsqlite3_sys::sqlite3_column_text(stmt, c) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_column_text(stmt: *mut sqlite3_stmt, c: c_int) -> *const c_uchar { ((*SQLITE3_API).column_text.expect(EXPECT_MESSAGE))(stmt, c) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_column_int64(stmt: *mut sqlite3_stmt, c: c_int) -> i64 { + libsqlite3_sys::sqlite3_column_int64(stmt, c) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_column_int64(stmt: *mut sqlite3_stmt, c: c_int) -> i64 { ((*SQLITE3_API).column_int64.expect(EXPECT_MESSAGE))(stmt, c) } + +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_column_bytes(stmt: *mut sqlite3_stmt, c: c_int) -> i32 { + libsqlite3_sys::sqlite3_column_bytes(stmt, c) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_column_bytes(stmt: *mut sqlite3_stmt, c: c_int) -> i32 { ((*SQLITE3_API).column_bytes.expect(EXPECT_MESSAGE))(stmt, c) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_column_value(stmt: *mut sqlite3_stmt, c: c_int) -> *mut sqlite3_value { + libsqlite3_sys::sqlite3_column_value(stmt, c) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_column_value(stmt: *mut sqlite3_stmt, c: c_int) -> *mut sqlite3_value { ((*SQLITE3_API).column_value.expect(EXPECT_MESSAGE))(stmt, c) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_bind_text( + stmt: *mut sqlite3_stmt, + c: c_int, + s: *const c_char, + n: c_int, + destructor: Option, +) -> i32 { + libsqlite3_sys::sqlite3_bind_text(stmt, c, s, n, destructor) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_bind_text( stmt: *mut sqlite3_stmt, c: c_int, @@ -100,13 +189,34 @@ pub unsafe fn sqlite3ext_bind_text( ) -> i32 { ((*SQLITE3_API).bind_text.expect(EXPECT_MESSAGE))(stmt, c, s, n, destructor) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_bind_int(stmt: *mut sqlite3_stmt, c: c_int, v: c_int) -> i32 { + libsqlite3_sys::sqlite3_bind_int(stmt, c, v) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_bind_int(stmt: *mut sqlite3_stmt, c: c_int, v: c_int) -> i32 { ((*SQLITE3_API).bind_int.expect(EXPECT_MESSAGE))(stmt, c, v) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_bind_int64(stmt: *mut sqlite3_stmt, c: c_int, v: i64) -> i32 { + libsqlite3_sys::sqlite3_bind_int64(stmt, c, v) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_bind_int64(stmt: *mut sqlite3_stmt, c: c_int, v: i64) -> i32 { ((*SQLITE3_API).bind_int64.expect(EXPECT_MESSAGE))(stmt, c, v) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_prepare_v2( + db: *mut sqlite3, + sql: *const c_char, + n: i32, + stmt: *mut *mut sqlite3_stmt, + leftover: *mut *const c_char, +) -> i32 { + libsqlite3_sys::sqlite3_prepare_v2(db, sql, n, stmt, leftover) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_prepare_v2( db: *mut sqlite3, sql: *const c_char, @@ -117,22 +227,47 @@ pub unsafe fn sqlite3ext_prepare_v2( ((*SQLITE3_API).prepare_v2.expect(EXPECT_MESSAGE))(db, sql, n, stmt, leftover) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_value_int(arg1: *mut sqlite3_value) -> i32 { + libsqlite3_sys::sqlite3_value_int(arg1) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_value_int(arg1: *mut sqlite3_value) -> i32 { ((*SQLITE3_API).value_int.expect(EXPECT_MESSAGE))(arg1) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_value_int64(arg1: *mut sqlite3_value) -> i64 { + libsqlite3_sys::sqlite3_value_int64(arg1) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_value_int64(arg1: *mut sqlite3_value) -> i64 { ((*SQLITE3_API).value_int64.expect(EXPECT_MESSAGE))(arg1) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_value_double(arg1: *mut sqlite3_value) -> f64 { + libsqlite3_sys::sqlite3_value_double(arg1) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_value_double(arg1: *mut sqlite3_value) -> f64 { ((*SQLITE3_API).value_double.expect(EXPECT_MESSAGE))(arg1) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_value_pointer(arg1: *mut sqlite3_value, p: *mut c_char) -> *mut c_void { + libsqlite3_sys::sqlite3_value_pointer(arg1, p) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_value_pointer(arg1: *mut sqlite3_value, p: *mut c_char) -> *mut c_void { ((*SQLITE3_API).value_pointer.expect(EXPECT_MESSAGE))(arg1, p) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_result_int(context: *mut sqlite3_context, v: c_int) { + libsqlite3_sys::sqlite3_result_int(context, v) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_result_int(context: *mut sqlite3_context, v: c_int) { if false { } else { @@ -147,6 +282,11 @@ pub unsafe fn sqlite3ext_result_int(context: *mut sqlite3_context, v: c_int) { // also maybe pass in a box/T and do the box stuff ourself? // or serde?? // or slice?? +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_result_blob(context: *mut sqlite3_context, p: *const c_void, n: i32) { + libsqlite3_sys::sqlite3_result_blob(context, p, n, Some(mem::transmute(-1_isize))); +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_result_blob(context: *mut sqlite3_context, p: *const c_void, n: i32) { ((*SQLITE3_API).result_blob.expect(EXPECT_MESSAGE))( context, @@ -155,17 +295,42 @@ pub unsafe fn sqlite3ext_result_blob(context: *mut sqlite3_context, p: *const c_ Some(mem::transmute(-1_isize)), ); } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_result_int64(context: *mut sqlite3_context, v: i64) { + libsqlite3_sys::sqlite3_result_int64(context, v); +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_result_int64(context: *mut sqlite3_context, v: i64) { ((*SQLITE3_API).result_int64.expect(EXPECT_MESSAGE))(context, v); } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_result_double(context: *mut sqlite3_context, f: f64) { + libsqlite3_sys::sqlite3_result_double(context, f) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_result_double(context: *mut sqlite3_context, f: f64) { ((*SQLITE3_API).result_double.expect(EXPECT_MESSAGE))(context, f); } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_result_null(context: *mut sqlite3_context) { + libsqlite3_sys::sqlite3_result_null(context); +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_result_null(context: *mut sqlite3_context) { ((*SQLITE3_API).result_null.expect(EXPECT_MESSAGE))(context); } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_result_pointer( + context: *mut sqlite3_context, + pointer: *mut c_void, + name: *mut c_char, + destructor: Option, +) { + libsqlite3_sys::sqlite3_result_pointer(context, pointer, name, destructor) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_result_pointer( context: *mut sqlite3_context, pointer: *mut c_void, @@ -175,13 +340,33 @@ pub unsafe fn sqlite3ext_result_pointer( ((*SQLITE3_API).result_pointer.expect(EXPECT_MESSAGE))(context, pointer, name, destructor); } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_result_error(context: *mut sqlite3_context, s: *const c_char, n: i32) { + libsqlite3_sys::sqlite3_result_error(context, s, n); +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_result_error(context: *mut sqlite3_context, s: *const c_char, n: i32) { ((*SQLITE3_API).result_error.expect(EXPECT_MESSAGE))(context, s, n); } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_result_error_code(context: *mut sqlite3_context, code: i32) { + libsqlite3_sys::sqlite3_result_error_code(context, code); +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_result_error_code(context: *mut sqlite3_context, code: i32) { ((*SQLITE3_API).result_error_code.expect(EXPECT_MESSAGE))(context, code); } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_result_text( + context: *mut sqlite3_context, + s: *const c_char, + n: i32, + d: Option, +) { + libsqlite3_sys::sqlite3_result_text(context, s, n, d); +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_result_text( context: *mut sqlite3_context, s: *const c_char, @@ -191,10 +376,25 @@ pub unsafe fn sqlite3ext_result_text( ((*SQLITE3_API).result_text.expect(EXPECT_MESSAGE))(context, s, n, d); } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_result_subtype(context: *mut sqlite3_context, subtype: u32) { + libsqlite3_sys::sqlite3_result_subtype(context, subtype) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_result_subtype(context: *mut sqlite3_context, subtype: u32) { ((*SQLITE3_API).result_subtype.expect(EXPECT_MESSAGE))(context, subtype); } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_set_auxdata( + context: *mut sqlite3_context, + n: c_int, + p: *mut c_void, + d: Option, +) { + libsqlite3_sys::sqlite3_set_auxdata(context, n, p, d); +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_set_auxdata( context: *mut sqlite3_context, n: c_int, @@ -204,10 +404,32 @@ pub unsafe fn sqlite3ext_set_auxdata( ((*SQLITE3_API).set_auxdata.expect(EXPECT_MESSAGE))(context, n, p, d); } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_get_auxdata(context: *mut sqlite3_context, n: c_int) -> *mut c_void { + libsqlite3_sys::sqlite3_get_auxdata(context, n) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_get_auxdata(context: *mut sqlite3_context, n: c_int) -> *mut c_void { ((*SQLITE3_API).get_auxdata.expect(EXPECT_MESSAGE))(context, n) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_create_function_v2( + db: *mut sqlite3, + s: *const c_char, + argc: i32, + text_rep: i32, + p_app: *mut c_void, + x_func: Option, + x_step: Option, + x_final: Option, + destroy: Option, +) -> c_int { + libsqlite3_sys::sqlite3_create_function_v2( + db, s, argc, text_rep, p_app, x_func, x_step, x_final, destroy, + ) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_create_function_v2( db: *mut sqlite3, s: *const c_char, @@ -223,6 +445,26 @@ pub unsafe fn sqlite3ext_create_function_v2( db, s, argc, text_rep, p_app, x_func, x_step, x_final, destroy, ) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_collation_v2( + db: *mut sqlite3, + s: *const c_char, + text_rep: i32, + p_app: *mut c_void, + x_compare: Option< + unsafe extern "C" fn( + *mut ::std::os::raw::c_void, + ::std::os::raw::c_int, + *const ::std::os::raw::c_void, + ::std::os::raw::c_int, + *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + destroy: Option, +) -> c_int { + libsqlite3_sys::sqlite3_create_collation_v2(db, s, text_rep, p_app, x_compare, destroy) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_collation_v2( db: *mut sqlite3, s: *const c_char, @@ -244,6 +486,17 @@ pub unsafe fn sqlite3ext_collation_v2( ) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_create_module_v2( + db: *mut sqlite3, + s: *const c_char, + module: *const sqlite3_module, + p_app: *mut c_void, + destroy: Option, +) -> i32 { + libsqlite3_sys::sqlite3_create_module_v2(db, s, module, p_app, destroy) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_create_module_v2( db: *mut sqlite3, s: *const c_char, @@ -254,10 +507,24 @@ pub unsafe fn sqlite3ext_create_module_v2( ((*SQLITE3_API).create_module_v2.expect(EXPECT_MESSAGE))(db, s, module, p_app, destroy) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_vtab_distinct(index_info: *mut sqlite3_index_info) -> i32 { + libsqlite3_sys::sqlite3_vtab_distinct(index_info) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_vtab_distinct(index_info: *mut sqlite3_index_info) -> i32 { ((*SQLITE3_API).vtab_distinct.expect(EXPECT_MESSAGE))(index_info) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_vtab_in( + index_info: *mut sqlite3_index_info, + constraint_idx: i32, + handle: i32, +) -> i32 { + libsqlite3_sys::sqlite3_vtab_in(index_info, constraint_idx, handle) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_vtab_in( index_info: *mut sqlite3_index_info, constraint_idx: i32, @@ -265,12 +532,30 @@ pub unsafe fn sqlite3ext_vtab_in( ) -> i32 { ((*SQLITE3_API).vtab_in.expect(EXPECT_MESSAGE))(index_info, constraint_idx, handle) } + +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_vtab_in_first( + value_list: *mut sqlite3_value, + value_out: *mut *mut sqlite3_value, +) -> i32 { + libsqlite3_sys::sqlite3_vtab_in_first(value_list, value_out) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_vtab_in_first( value_list: *mut sqlite3_value, value_out: *mut *mut sqlite3_value, ) -> i32 { ((*SQLITE3_API).vtab_in_first.expect(EXPECT_MESSAGE))(value_list, value_out) } + +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_vtab_in_next( + value_list: *mut sqlite3_value, + value_out: *mut *mut sqlite3_value, +) -> i32 { + libsqlite3_sys::sqlite3_vtab_in_next(value_list, value_out) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_vtab_in_next( value_list: *mut sqlite3_value, value_out: *mut *mut sqlite3_value, @@ -278,18 +563,47 @@ pub unsafe fn sqlite3ext_vtab_in_next( ((*SQLITE3_API).vtab_in_next.expect(EXPECT_MESSAGE))(value_list, value_out) } -pub unsafe fn sqlitex_declare_vtab(db: *mut sqlite3, s: *const c_char) -> i32 { +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_declare_vtab(db: *mut sqlite3, s: *const c_char) -> i32 { + libsqlite3_sys::sqlite3_declare_vtab(db, s) +} +#[cfg(not(feature = "static"))] +pub unsafe fn sqlite3ext_declare_vtab(db: *mut sqlite3, s: *const c_char) -> i32 { + #[cfg(not(feature = "static"))] ((*SQLITE3_API).declare_vtab.expect(EXPECT_MESSAGE))(db, s) } + +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_overload_function(db: *mut sqlite3, s: *const c_char, n: i32) -> i32 { + libsqlite3_sys::sqlite3_overload_function(db, s, n) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_overload_function(db: *mut sqlite3, s: *const c_char, n: i32) -> i32 { ((*SQLITE3_API).overload_function.expect(EXPECT_MESSAGE))(db, s, n) } + +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_context_db_handle(context: *mut sqlite3_context) -> *mut sqlite3 { + libsqlite3_sys::sqlite3_context_db_handle(context) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_context_db_handle(context: *mut sqlite3_context) -> *mut sqlite3 { ((*SQLITE3_API).context_db_handle.expect(EXPECT_MESSAGE))(context) } + +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_user_data(context: *mut sqlite3_context) -> *mut c_void { + libsqlite3_sys::sqlite3_user_data(context) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_user_data(context: *mut sqlite3_context) -> *mut c_void { ((*SQLITE3_API).user_data.expect(EXPECT_MESSAGE))(context) } +#[cfg(feature = "static")] +pub unsafe fn sqlite3ext_mprintf(s: *const c_char) -> *mut c_char { + libsqlite3_sys::sqlite3_mprintf(s) +} +#[cfg(not(feature = "static"))] pub unsafe fn sqlite3ext_mprintf(s: *const c_char) -> *mut c_char { ((*SQLITE3_API).mprintf.expect(EXPECT_MESSAGE))(s) } diff --git a/src/prelude.rs b/src/prelude.rs index f1e5e6f..0d216a1 100644 --- a/src/prelude.rs +++ b/src/prelude.rs @@ -5,7 +5,7 @@ pub use crate::entrypoints::register_entrypoint; #[doc(inline)] pub use crate::entrypoints::register_entrypoint_load_permanently; #[doc(inline)] -pub use sqlite3ext_sys::{ +pub use crate::ext::{ sqlite3, sqlite3_api_routines, sqlite3_context, sqlite3_value, sqlite3_vtab, sqlite3_vtab_cursor, }; diff --git a/src/scalar.rs b/src/scalar.rs index c85cb93..db2982e 100644 --- a/src/scalar.rs +++ b/src/scalar.rs @@ -11,9 +11,11 @@ use crate::{ api, constants::{SQLITE_INTERNAL, SQLITE_OKAY}, errors::{Error, ErrorKind, Result}, - ext::{sqlite3ext_create_function_v2, sqlite3ext_user_data}, + ext::{ + sqlite3, sqlite3_context, sqlite3_value, sqlite3ext_create_function_v2, + sqlite3ext_user_data, + }, }; -use sqlite3ext_sys::{sqlite3, sqlite3_context, sqlite3_value}; use bitflags::bitflags; diff --git a/src/table.rs b/src/table.rs index b6d238b..9a88d87 100644 --- a/src/table.rs +++ b/src/table.rs @@ -2,13 +2,6 @@ // ![allow(clippy::not_unsafe_ptr_arg_deref)] -use sqlite3ext_sys::sqlite3_index_info_sqlite3_index_constraint_usage; -use sqlite3ext_sys::{ - sqlite3, sqlite3_context, sqlite3_index_info, sqlite3_index_info_sqlite3_index_constraint, - sqlite3_index_info_sqlite3_index_orderby, sqlite3_module, sqlite3_value, sqlite3_vtab, - sqlite3_vtab_cursor, -}; - use crate::constants::*; use std::ffi::CString; use std::marker::PhantomData; @@ -21,10 +14,12 @@ use std::str::Utf8Error; use crate::api::{mprintf, value_type, MprintfError, ValueType}; use crate::errors::{Error, ErrorKind, Result}; use crate::ext::{ - sqlite3ext_create_module_v2, sqlite3ext_vtab_distinct, sqlite3ext_vtab_in_first, - sqlite3ext_vtab_in_next, + sqlite3, sqlite3_context, sqlite3_index_info, sqlite3_index_info_sqlite3_index_constraint, + sqlite3_index_info_sqlite3_index_constraint_usage, sqlite3_index_info_sqlite3_index_orderby, + sqlite3_module, sqlite3_value, sqlite3_vtab, sqlite3_vtab_cursor, sqlite3ext_create_module_v2, + sqlite3ext_declare_vtab, sqlite3ext_vtab_distinct, sqlite3ext_vtab_in, + sqlite3ext_vtab_in_first, sqlite3ext_vtab_in_next, }; -use crate::ext::{sqlite3ext_vtab_in, sqlitex_declare_vtab}; use serde::{Deserialize, Serialize}; /// Possible operators for a given constraint, found and used in xBestIndex and xFilter. @@ -885,7 +880,7 @@ where match T::create(db, aux.as_ref(), args) { Ok((sql, vtab)) => match CString::new(sql) { Ok(c_sql) => { - let rc = sqlitex_declare_vtab(db, c_sql.as_ptr()); + let rc = sqlite3ext_declare_vtab(db, c_sql.as_ptr()); if rc == SQLITE_OKAY { let boxed_vtab: *mut T = Box::into_raw(Box::new(vtab)); *pp_vtab = boxed_vtab.cast::(); @@ -928,7 +923,7 @@ where match T::connect(db, aux.as_ref(), args) { Ok((sql, vtab)) => match CString::new(sql) { Ok(c_sql) => { - let rc = sqlitex_declare_vtab(db, c_sql.as_ptr()); + let rc = sqlite3ext_declare_vtab(db, c_sql.as_ptr()); if rc == SQLITE_OKAY { let boxed_vtab: *mut T = Box::into_raw(Box::new(vtab)); *pp_vtab = boxed_vtab.cast::(); diff --git a/tests/test_manual_load.rs b/tests/test_manual_load.rs index ae18998..910cb8f 100644 --- a/tests/test_manual_load.rs +++ b/tests/test_manual_load.rs @@ -14,13 +14,13 @@ pub fn sqlite3_manual_init(db: *mut sqlite3) -> Result<()> { Ok(()) } +#[cfg(feature = "static")] #[cfg(test)] mod tests { use super::*; use rusqlite::Connection; - #[ignore] #[test] fn test_manual_load() { let db = Connection::open_in_memory().unwrap();