sqlite_loadable/
ext.rs

1//! Unsafe wrappers around low-level sqlite3 C API.
2
3#![allow(clippy::missing_safety_doc)]
4#![allow(clippy::too_many_arguments)]
5
6/// WARNING: This file should only carefully be updated. The code here essentially emulates the
7/// SQLITE_EXTENSION_INIT1 and SQLITE_EXTENSION_INIT2 macros that aren't available in Rust,
8/// making an broken unsafe-raw C API into a not-broken unsafe-raw C API.
9/// The functions exposed here (prefixed with "sqlite3ext_" by convention) are still unsafe,
10/// but at least work for both dynamically-loadable and statically built extensions.
11/// One should not need to work with these functions directly - unless you're working internally
12/// on the sqlite_loadable library.
13use std::{
14    mem,
15    os::raw::{c_char, c_int, c_uchar, c_void},
16};
17
18use sqlite3ext_sys::{
19    sqlite3, sqlite3_api_routines, sqlite3_bind_text, sqlite3_column_text, sqlite3_column_value,
20    sqlite3_context, sqlite3_create_function_v2, sqlite3_create_module_v2, sqlite3_declare_vtab,
21    sqlite3_finalize, sqlite3_get_auxdata, sqlite3_index_info, sqlite3_module, sqlite3_prepare_v2,
22    sqlite3_result_blob, sqlite3_result_double, sqlite3_result_error, sqlite3_result_error_code,
23    sqlite3_result_int, sqlite3_result_int64, sqlite3_result_null, sqlite3_result_pointer,
24    sqlite3_result_text, sqlite3_set_auxdata, sqlite3_step, sqlite3_stmt, sqlite3_value,
25    sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_double, sqlite3_value_int,
26    sqlite3_value_int64, sqlite3_value_pointer, sqlite3_value_text, sqlite3_value_type,
27};
28
29/// If creating a dynmically loadable extension, this MUST be redefined to point
30/// to a proper sqlite3_api_rountines module (from a entrypoint function).
31/// The "sqlite_entrypoint" macro will do this for you usually.
32static mut SQLITE3_API: *mut sqlite3_api_routines = std::ptr::null_mut();
33
34/// This function MUST be called in loadable extension before any of the below functions are invoked.
35/// (The sqlite_entrypoint function will do this for you).
36/// This essentially emulates the SQLITE_EXTENSION_INIT2 macro that's not available in rust-land.
37/// Without it, when dynamically loading extensions, calls to SQLite C-API functions in sqlite3ext_sys
38/// like sqlite3_value_text will segfault, because sqlite3ext.h does not include their proper definitions.
39/// Instead, a sqlite3_api_routines object is provided through the entrypoint at runtime, to which
40/// sqlite_loadable will redefine the static SQLITE3_API variable that the functions below requre.
41pub unsafe fn faux_sqlite_extension_init2(api: *mut sqlite3_api_routines) {
42    SQLITE3_API = api;
43}
44
45//definex!("value_text", c_uchar);
46static EXPECT_MESSAGE: &str =
47    "sqlite-loadable error: expected method on SQLITE3_API. Please file an issue";
48
49pub unsafe fn sqlite3ext_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar {
50    if SQLITE3_API.is_null() {
51        return sqlite3_value_text(arg1);
52    }
53    ((*SQLITE3_API).value_text.expect(EXPECT_MESSAGE))(arg1)
54}
55
56pub unsafe fn sqlite3ext_value_type(value: *mut sqlite3_value) -> i32 {
57    if SQLITE3_API.is_null() {
58        return sqlite3_value_type(value);
59    }
60    ((*SQLITE3_API).value_type.expect(EXPECT_MESSAGE))(value)
61}
62
63pub unsafe fn sqlite3ext_value_bytes(arg1: *mut sqlite3_value) -> i32 {
64    if SQLITE3_API.is_null() {
65        return sqlite3_value_bytes(arg1);
66    }
67    ((*SQLITE3_API).value_bytes.expect(EXPECT_MESSAGE))(arg1)
68}
69
70pub unsafe fn sqlite3ext_value_blob(arg1: *mut sqlite3_value) -> *const c_void {
71    if SQLITE3_API.is_null() {
72        return sqlite3_value_blob(arg1);
73    }
74    ((*SQLITE3_API).value_blob.expect(EXPECT_MESSAGE))(arg1)
75}
76
77pub unsafe fn sqlite3ext_bind_pointer(
78    db: *mut sqlite3_stmt,
79    i: i32,
80    p: *mut c_void,
81    t: *const c_char,
82) -> i32 {
83    ((*SQLITE3_API).bind_pointer.expect(EXPECT_MESSAGE))(db, i, p, t, None)
84}
85pub unsafe fn sqlite3ext_step(stmt: *mut sqlite3_stmt) -> c_int {
86    if SQLITE3_API.is_null() {
87        return sqlite3_step(stmt);
88    }
89    ((*SQLITE3_API).step.expect(EXPECT_MESSAGE))(stmt)
90}
91
92pub unsafe fn sqlite3ext_finalize(stmt: *mut sqlite3_stmt) -> c_int {
93    if SQLITE3_API.is_null() {
94        return sqlite3_finalize(stmt);
95    }
96    ((*SQLITE3_API).finalize.expect(EXPECT_MESSAGE))(stmt)
97}
98
99pub unsafe fn sqlite3ext_column_text(stmt: *mut sqlite3_stmt, c: c_int) -> *const c_uchar {
100    if SQLITE3_API.is_null() {
101        return sqlite3_column_text(stmt, c);
102    }
103    ((*SQLITE3_API).column_text.expect(EXPECT_MESSAGE))(stmt, c)
104}
105
106pub unsafe fn sqlite3ext_column_value(stmt: *mut sqlite3_stmt, c: c_int) -> *mut sqlite3_value {
107    if SQLITE3_API.is_null() {
108        return sqlite3_column_value(stmt, c);
109    }
110    ((*SQLITE3_API).column_value.expect(EXPECT_MESSAGE))(stmt, c)
111}
112
113pub unsafe fn sqlite3ext_bind_text(
114    stmt: *mut sqlite3_stmt,
115    c: c_int,
116    s: *const c_char,
117    n: c_int,
118) -> i32 {
119    if SQLITE3_API.is_null() {
120        return sqlite3_bind_text(stmt, c, s, n, None);
121    }
122    ((*SQLITE3_API).bind_text.expect(EXPECT_MESSAGE))(stmt, c, s, n, None)
123}
124
125pub unsafe fn sqlite3ext_prepare_v2(
126    db: *mut sqlite3,
127    sql: *const c_char,
128    n: i32,
129    stmt: *mut *mut sqlite3_stmt,
130    leftover: *mut *const c_char,
131) -> i32 {
132    if SQLITE3_API.is_null() {
133        return sqlite3_prepare_v2(db, sql, n, stmt, leftover);
134    }
135    ((*SQLITE3_API).prepare_v2.expect(EXPECT_MESSAGE))(db, sql, n, stmt, leftover)
136}
137
138pub unsafe fn sqlite3ext_value_int(arg1: *mut sqlite3_value) -> i32 {
139    if SQLITE3_API.is_null() {
140        return sqlite3_value_int(arg1);
141    }
142    ((*SQLITE3_API).value_int.expect(EXPECT_MESSAGE))(arg1)
143}
144
145pub unsafe fn sqlite3ext_value_int64(arg1: *mut sqlite3_value) -> i64 {
146    if SQLITE3_API.is_null() {
147        return sqlite3_value_int64(arg1);
148    }
149    ((*SQLITE3_API).value_int64.expect(EXPECT_MESSAGE))(arg1)
150}
151
152pub unsafe fn sqlite3ext_value_double(arg1: *mut sqlite3_value) -> f64 {
153    if SQLITE3_API.is_null() {
154        return sqlite3_value_double(arg1);
155    }
156    ((*SQLITE3_API).value_double.expect(EXPECT_MESSAGE))(arg1)
157}
158
159pub unsafe fn sqlite3ext_value_pointer(arg1: *mut sqlite3_value, p: *mut c_char) -> *mut c_void {
160    if SQLITE3_API.is_null() {
161        return sqlite3_value_pointer(arg1, p);
162    }
163    ((*SQLITE3_API).value_pointer.expect(EXPECT_MESSAGE))(arg1, p)
164}
165
166pub unsafe fn sqlite3ext_result_int(context: *mut sqlite3_context, v: c_int) {
167    if SQLITE3_API.is_null() {
168        sqlite3_result_int(context, v);
169    } else {
170        ((*SQLITE3_API).result_int.expect(EXPECT_MESSAGE))(context, v);
171    }
172}
173
174pub unsafe fn sqlite3ext_result_blob(context: *mut sqlite3_context, p: *const c_void, n: i32) {
175    if SQLITE3_API.is_null() {
176        sqlite3_result_blob(context, p, n, Some(mem::transmute(-1_isize)));
177    } else {
178        ((*SQLITE3_API).result_blob.expect(EXPECT_MESSAGE))(
179            context,
180            p,
181            n,
182            Some(mem::transmute(-1_isize)),
183        );
184    }
185}
186pub unsafe fn sqlite3ext_result_int64(context: *mut sqlite3_context, v: i64) {
187    if SQLITE3_API.is_null() {
188        sqlite3_result_int64(context, v);
189    } else {
190        ((*SQLITE3_API).result_int64.expect(EXPECT_MESSAGE))(context, v);
191    }
192}
193
194pub unsafe fn sqlite3ext_result_double(context: *mut sqlite3_context, f: f64) {
195    if SQLITE3_API.is_null() {
196        sqlite3_result_double(context, f);
197    } else {
198        ((*SQLITE3_API).result_double.expect(EXPECT_MESSAGE))(context, f);
199    }
200}
201
202pub unsafe fn sqlite3ext_result_null(context: *mut sqlite3_context) {
203    if SQLITE3_API.is_null() {
204        sqlite3_result_null(context);
205    } else {
206        ((*SQLITE3_API).result_null.expect(EXPECT_MESSAGE))(context);
207    }
208}
209pub unsafe fn sqlite3ext_result_pointer(
210    context: *mut sqlite3_context,
211    pointer: *mut c_void,
212    name: *mut c_char,
213    destructor: Option<unsafe extern "C" fn(*mut std::ffi::c_void)>,
214) {
215    if SQLITE3_API.is_null() {
216        sqlite3_result_pointer(context, pointer, name, destructor);
217    } else {
218        ((*SQLITE3_API).result_pointer.expect(EXPECT_MESSAGE))(context, pointer, name, destructor);
219    }
220}
221
222pub unsafe fn sqlite3ext_result_error(context: *mut sqlite3_context, s: *const i8, n: i32) {
223    if SQLITE3_API.is_null() {
224        sqlite3_result_error(context, s, n);
225    } else {
226        ((*SQLITE3_API).result_error.expect(EXPECT_MESSAGE))(context, s, n);
227    }
228}
229
230pub unsafe fn sqlite3ext_result_error_code(context: *mut sqlite3_context, code: i32) {
231    if SQLITE3_API.is_null() {
232        sqlite3_result_error_code(context, code);
233    } else {
234        ((*SQLITE3_API).result_error_code.expect(EXPECT_MESSAGE))(context, code);
235    }
236}
237pub unsafe fn sqlite3ext_result_text(
238    context: *mut sqlite3_context,
239    s: *const i8,
240    n: i32,
241    d: Option<unsafe extern "C" fn(*mut c_void)>,
242) {
243    if SQLITE3_API.is_null() {
244        sqlite3_result_text(context, s, n, d);
245    } else {
246        ((*SQLITE3_API).result_text.expect(EXPECT_MESSAGE))(context, s, n, d);
247    }
248}
249
250pub unsafe fn sqlite3ext_result_subtype(context: *mut sqlite3_context, subtype: u32) {
251    if SQLITE3_API.is_null() {
252        //sqlite3_result_int(context, v);
253    } else {
254        ((*SQLITE3_API).result_subtype.expect(EXPECT_MESSAGE))(context, subtype);
255    }
256}
257
258pub unsafe fn sqlite3ext_set_auxdata(
259    context: *mut sqlite3_context,
260    n: c_int,
261    p: *mut c_void,
262    d: Option<unsafe extern "C" fn(*mut c_void)>,
263) {
264    if SQLITE3_API.is_null() {
265        sqlite3_set_auxdata(context, n, p, d);
266    } else {
267        ((*SQLITE3_API).set_auxdata.expect(EXPECT_MESSAGE))(context, n, p, d);
268    }
269}
270
271pub unsafe fn sqlite3ext_get_auxdata(context: *mut sqlite3_context, n: c_int) -> *mut c_void {
272    if SQLITE3_API.is_null() {
273        return sqlite3_get_auxdata(context, n);
274    }
275    ((*SQLITE3_API).get_auxdata.expect(EXPECT_MESSAGE))(context, n)
276}
277
278pub unsafe fn sqlite3ext_create_function_v2(
279    db: *mut sqlite3,
280    s: *const i8,
281    argc: i32,
282    text_rep: i32,
283    p_app: *mut c_void,
284    x_func: Option<unsafe extern "C" fn(*mut sqlite3_context, i32, *mut *mut sqlite3_value)>,
285    x_step: Option<unsafe extern "C" fn(*mut sqlite3_context, i32, *mut *mut sqlite3_value)>,
286    x_final: Option<unsafe extern "C" fn(*mut sqlite3_context)>,
287    destroy: Option<unsafe extern "C" fn(*mut c_void)>,
288) -> c_int {
289    if SQLITE3_API.is_null() {
290        sqlite3_create_function_v2(
291            db, s, argc, text_rep, p_app, x_func, x_step, x_final, destroy,
292        )
293    } else {
294        ((*SQLITE3_API).create_function_v2.expect(EXPECT_MESSAGE))(
295            db, s, argc, text_rep, p_app, x_func, x_step, x_final, destroy,
296        )
297    }
298}
299
300pub unsafe fn sqlite3ext_create_module_v2(
301    db: *mut sqlite3,
302    s: *const i8,
303    module: *const sqlite3_module,
304    p_app: *mut c_void,
305    destroy: Option<unsafe extern "C" fn(*mut c_void)>,
306) -> i32 {
307    if SQLITE3_API.is_null() {
308        sqlite3_create_module_v2(db, s, module, p_app, destroy)
309    } else {
310        ((*SQLITE3_API).create_module_v2.expect(EXPECT_MESSAGE))(db, s, module, p_app, destroy)
311    }
312}
313
314pub unsafe fn sqlite3ext_vtab_distinct(index_info: *mut sqlite3_index_info) -> i32 {
315    ((*SQLITE3_API).vtab_distinct.expect(EXPECT_MESSAGE))(index_info)
316}
317
318pub unsafe fn sqlitex_declare_vtab(db: *mut sqlite3, s: *const i8) -> i32 {
319    if SQLITE3_API.is_null() {
320        return sqlite3_declare_vtab(db, s);
321    }
322    ((*SQLITE3_API).declare_vtab.expect(EXPECT_MESSAGE))(db, s)
323}
sqlite_loadable/ext.rs

sqlite_loadable/
ext.rs
