1#![expect(non_snake_case, non_camel_case_types)]
2#![cfg_attr(not(test), no_std)]
3pub use self::error::*;
4
5use core::mem;
6#[cfg(not(feature = "loadable_extension"))]
7use core::sync::atomic::{AtomicI32, Ordering};
8
9mod error;
10
11#[cfg(feature = "blockcachevfs")]
14extern crate curl_sys as _;
15#[cfg(feature = "blockcachevfs")]
16extern crate libz_sys as _;
17#[cfg(feature = "blockcachevfs")]
18extern crate openssl_sys as _;
19
20#[must_use]
21pub fn SQLITE_STATIC() -> sqlite3_destructor_type {
22 None
23}
24
25#[must_use]
26pub fn SQLITE_TRANSIENT() -> sqlite3_destructor_type {
27 Some(unsafe { mem::transmute::<isize, unsafe extern "C" fn(*mut core::ffi::c_void)>(-1_isize) })
28}
29
30#[allow(dead_code, clippy::all)]
31mod bindings {
32 include!(concat!(env!("OUT_DIR"), "/bindgen.rs"));
33}
34pub use bindings::*;
35
36#[cfg(feature = "blockcachevfs")]
38pub mod blockcachevfs {
39 use core::ffi::{c_char, c_int, c_void};
40
41 use super::{sqlite3, sqlite3_int64};
42
43 #[repr(C)]
45 pub struct sqlite3_bcvfs {
46 _private: [u8; 0],
47 }
48
49 pub type sqlite3_bcvfs_auth_callback = unsafe extern "C" fn(
51 p_ctx: *mut c_void,
52 z_storage: *const c_char,
53 z_account: *const c_char,
54 z_container: *const c_char,
55 pz_auth_token: *mut *mut c_char,
56 ) -> c_int;
57
58 pub type sqlite3_bcvfs_auth_refresh_callback = unsafe extern "C" fn(
60 p_ctx: *mut c_void,
61 z_storage: *const c_char,
62 z_account: *const c_char,
63 z_container: *const c_char,
64 reason: c_int,
65 pz_auth_token: *mut *mut c_char,
66 ) -> c_int;
67
68 pub type sqlite3_bcvfs_upload_progress_callback =
70 unsafe extern "C" fn(*mut c_void, c_int, sqlite3_int64, sqlite3_int64);
71
72 pub type sqlite3_bcvfs_storage_failure_callback =
74 unsafe extern "C" fn(*mut c_void, c_int, c_int, c_int);
75
76 pub type sqlite3_bcvfs_busy_callback = unsafe extern "C" fn(*mut c_void, c_int) -> c_int;
78
79 pub const SQLITE_BCV_CACHESIZE: c_int = 1;
80 pub const SQLITE_BCV_NREQUEST: c_int = 2;
81 pub const SQLITE_BCV_HTTPTIMEOUT: c_int = 3;
82 pub const SQLITE_BCV_CURLVERBOSE: c_int = 4;
83 pub const SQLITE_BCV_HTTPLOG_TIMEOUT: c_int = 5;
84 pub const SQLITE_BCV_HTTPLOG_NENTRY: c_int = 6;
85 pub const SQLITE_BCV_STAGEWATERMARK: c_int = 7;
87 pub const SQLITE_BCV_AUTH_REQUEST: c_int = 0;
88 pub const SQLITE_BCV_AUTH_UNAUTHORIZED: c_int = 1;
89 pub const SQLITE_BCVFS_UPLOAD_PROGRESS_UPLOADED_BLOCK: c_int = 1;
90 pub const SQLITE_BCVFS_UPLOAD_PROGRESS_REUSED_BLOCK: c_int = 2;
91 pub const SQLITE_BCVFS_UPLOAD_PROGRESS_PLAN: c_int = 3;
92 pub const SQLITE_BCVFS_STORAGE_FAILURE_CAUSE_SQLITE: c_int = 0;
93 pub const SQLITE_BCVFS_STORAGE_FAILURE_CAUSE_HTTP: c_int = 1;
94 pub const SQLITE_BCVFS_STORAGE_FAILURE_LOCAL_CACHE: c_int = 1;
95 pub const SQLITE_BCVFS_STORAGE_FAILURE_BLOCK_READ: c_int = 2;
96 pub const SQLITE_BCVFS_STORAGE_FAILURE_STAGE_PUT: c_int = 3;
97 pub const SQLITE_BCVFS_STORAGE_FAILURE_VERIFY_EXISTING: c_int = 4;
98 pub const SQLITE_BCVFS_STORAGE_FAILURE_PROTECT_SESSION: c_int = 5;
99 pub const SQLITE_BCVFS_STORAGE_FAILURE_FINAL_PUT: c_int = 6;
100 pub const SQLITE_BCVFS_STORAGE_FAILURE_SESSION_CHECKPOINT: c_int = 7;
101 pub const SQLITE_BCVFS_STORAGE_FAILURE_SESSION_ACCEPT: c_int = 8;
102 pub const SQLITE_BCVFS_STORAGE_FAILURE_SESSION_PUBLISH: c_int = 9;
103
104 pub const SQLITE_BCV_ATTACH_SECURE: c_int = 0x0001;
105 pub const SQLITE_BCV_ATTACH_IFNOT: c_int = 0x0002;
106 pub const SQLITE_BCVFS_SESSION_HASH_BYTES: usize = 32;
107 pub const SQLITE_BCVFS_SESSION_STATUS_NEW: c_int = 0;
108 pub const SQLITE_BCVFS_SESSION_STATUS_ACCEPTED: c_int = 1;
109 pub const SQLITE_BCVFS_SESSION_STATUS_COMMITTED: c_int = 2;
110 pub const SQLITE_BCVFS_SESSION_STATUS_FAILED: c_int = 3;
111 pub const SQLITE_BCVFS_SESSION_STATUS_CONFLICT: c_int = 4;
112
113 unsafe extern "C" {
114 pub fn sqlite3_bcvfs_create(
115 z_dir: *const c_char,
116 z_name: *const c_char,
117 pp_fs: *mut *mut sqlite3_bcvfs,
118 pz_err: *mut *mut c_char,
119 ) -> c_int;
120 pub fn sqlite3_bcvfs_destroy(fs: *mut sqlite3_bcvfs) -> c_int;
121 pub fn sqlite3_bcvfs_isdaemon(fs: *mut sqlite3_bcvfs) -> c_int;
122 pub fn sqlite3_bcvfs_register_vtab(db: *mut sqlite3) -> c_int;
123 pub fn sqlite3_bcvfs_config(
124 fs: *mut sqlite3_bcvfs,
125 op: c_int,
126 value: sqlite3_int64,
127 ) -> c_int;
128 pub fn sqlite3_bcvfs_auth_callback(
129 fs: *mut sqlite3_bcvfs,
130 auth_ctx: *mut c_void,
131 auth: Option<sqlite3_bcvfs_auth_callback>,
132 ) -> c_int;
133 pub fn sqlite3_bcvfs_auth_refresh_callback(
134 fs: *mut sqlite3_bcvfs,
135 auth_ctx: *mut c_void,
136 auth: Option<sqlite3_bcvfs_auth_refresh_callback>,
137 ) -> c_int;
138 pub fn sqlite3_bcvfs_upload_progress_callback(
139 fs: *mut sqlite3_bcvfs,
140 progress_ctx: *mut c_void,
141 progress: Option<sqlite3_bcvfs_upload_progress_callback>,
142 ) -> c_int;
143 pub fn sqlite3_bcvfs_storage_failure_callback(
144 fs: *mut sqlite3_bcvfs,
145 failure_ctx: *mut c_void,
146 failure: Option<sqlite3_bcvfs_storage_failure_callback>,
147 ) -> c_int;
148 pub fn sqlite3_bcvfs_attach(
149 fs: *mut sqlite3_bcvfs,
150 z_storage: *const c_char,
151 z_account: *const c_char,
152 z_container: *const c_char,
153 z_alias: *const c_char,
154 flags: c_int,
155 pz_err: *mut *mut c_char,
156 ) -> c_int;
157 pub fn sqlite3_bcvfs_attach_session(
158 fs: *mut sqlite3_bcvfs,
159 z_storage: *const c_char,
160 z_account: *const c_char,
161 z_container: *const c_char,
162 z_alias: *const c_char,
163 z_session_id: *const c_char,
164 flags: c_int,
165 pz_err: *mut *mut c_char,
166 ) -> c_int;
167 pub fn sqlite3_bcvfs_attach_session_scoped(
168 fs: *mut sqlite3_bcvfs,
169 z_storage: *const c_char,
170 z_account: *const c_char,
171 z_container: *const c_char,
172 z_alias: *const c_char,
173 z_session_id: *const c_char,
174 z_principal: *const c_char,
175 z_database: *const c_char,
176 z_operations: *const c_char,
177 a_operation_id: *const u8,
178 flags: c_int,
179 pz_err: *mut *mut c_char,
180 ) -> c_int;
181 pub fn sqlite3_bcvfs_detach_session(
182 fs: *mut sqlite3_bcvfs,
183 z_alias: *const c_char,
184 z_session_id: *const c_char,
185 pz_err: *mut *mut c_char,
186 ) -> c_int;
187 pub fn sqlite3_bcvfs_detach(
188 fs: *mut sqlite3_bcvfs,
189 z_alias: *const c_char,
190 pz_err: *mut *mut c_char,
191 ) -> c_int;
192 pub fn sqlite3_bcvfs_poll(
193 fs: *mut sqlite3_bcvfs,
194 z_container: *const c_char,
195 pz_err: *mut *mut c_char,
196 ) -> c_int;
197 pub fn sqlite3_bcvfs_upload(
198 fs: *mut sqlite3_bcvfs,
199 z_container: *const c_char,
200 busy: Option<sqlite3_bcvfs_busy_callback>,
201 busy_ctx: *mut c_void,
202 pz_err: *mut *mut c_char,
203 ) -> c_int;
204 pub fn sqlite3_doltlite_bcvfs_initialize_empty_store(
214 db: *mut sqlite3,
215 z_db: *const c_char,
216 ) -> c_int;
217 pub fn sqlite3_bcvfs_session_checkpoint(
218 fs: *mut sqlite3_bcvfs,
219 z_alias: *const c_char,
220 z_session_id: *const c_char,
221 checkpoint_hash: *mut u8,
222 pz_etag: *mut *mut c_char,
223 pz_err: *mut *mut c_char,
224 ) -> c_int;
225 pub fn sqlite3_bcvfs_session_rehydrate(
226 fs: *mut sqlite3_bcvfs,
227 z_alias: *const c_char,
228 z_session_id: *const c_char,
229 pz_err: *mut *mut c_char,
230 ) -> c_int;
231 pub fn sqlite3_bcvfs_session_upload(
232 fs: *mut sqlite3_bcvfs,
233 z_alias: *const c_char,
234 z_session_id: *const c_char,
235 pz_err: *mut *mut c_char,
236 ) -> c_int;
237 pub fn sqlite3_bcvfs_session_finalize(
238 fs: *mut sqlite3_bcvfs,
239 z_alias: *const c_char,
240 z_session_id: *const c_char,
241 pz_err: *mut *mut c_char,
242 ) -> c_int;
243 pub fn sqlite3_bcvfs_session_accept(
244 fs: *mut sqlite3_bcvfs,
245 z_alias: *const c_char,
246 z_session_id: *const c_char,
247 pz_etag: *mut *mut c_char,
248 pz_err: *mut *mut c_char,
249 ) -> c_int;
250 pub fn sqlite3_bcvfs_session_operation_status(
251 fs: *mut sqlite3_bcvfs,
252 z_alias: *const c_char,
253 z_session_id: *const c_char,
254 p_status: *mut c_int,
255 pz_err: *mut *mut c_char,
256 ) -> c_int;
257 pub fn sqlite3_bcvfs_delete(
258 fs: *mut sqlite3_bcvfs,
259 z_container: *const c_char,
260 z_database: *const c_char,
261 pz_err: *mut *mut c_char,
262 ) -> c_int;
263 pub fn sqlite3_bcvfs_copy(
269 fs: *mut sqlite3_bcvfs,
270 z_container: *const c_char,
271 z_from: *const c_char,
272 z_to: *const c_char,
273 pz_err: *mut *mut c_char,
274 ) -> c_int;
275 }
276}
277
278#[cfg(feature = "blockcachevfs")]
280pub mod bcvutil {
281 use core::ffi::{c_char, c_int};
282
283 #[repr(C)]
285 pub struct sqlite3_bcv {
286 _private: [u8; 0],
287 }
288
289 unsafe extern "C" {
290 pub fn sqlite3_bcv_open(
291 z_module: *const c_char,
292 z_user: *const c_char,
293 z_auth: *const c_char,
294 z_container: *const c_char,
295 pp_out: *mut *mut sqlite3_bcv,
296 ) -> c_int;
297 pub fn sqlite3_bcv_close(handle: *mut sqlite3_bcv);
298 pub fn sqlite3_bcv_errmsg(handle: *mut sqlite3_bcv) -> *const c_char;
299 pub fn sqlite3_bcv_upload(
300 handle: *mut sqlite3_bcv,
301 z_local: *const c_char,
302 z_remote: *const c_char,
303 ) -> c_int;
304 pub fn sqlite3_bcv_cleanup(handle: *mut sqlite3_bcv, n_second: c_int) -> c_int;
305 pub fn sqlite3_bcv_create_if_not_exists(
306 handle: *mut sqlite3_bcv,
307 sz_name: c_int,
308 sz_block: c_int,
309 ) -> c_int;
310 }
311}
312
313#[cfg(all(feature = "remote", not(target_arch = "wasm32")))]
314mod remote {
315 use core::ffi::{c_char, c_int, c_long, c_void};
316
317 use super::{sqlite3, sqlite3_int64};
318
319 pub const DOLTLITE_PUSH_PROGRESS_PLAN: c_int = 1;
320 pub const DOLTLITE_PUSH_PROGRESS_UPLOADED: c_int = 2;
321
322 pub const DOLTLITE_CLONE_PROGRESS_STARTED: c_int = 1;
323 pub const DOLTLITE_CLONE_PROGRESS_PROGRESS: c_int = 2;
324 pub const DOLTLITE_CLONE_PROGRESS_FINALIZING: c_int = 3;
325 pub const DOLTLITE_CLONE_PROGRESS_COMPLETED: c_int = 4;
326
327 pub type sqlite3_doltlite_push_progress_callback =
328 unsafe extern "C" fn(*mut c_void, c_int, sqlite3_int64, sqlite3_int64);
329 pub type sqlite3_doltlite_clone_progress_callback = unsafe extern "C" fn(
330 *mut c_void,
331 c_int,
332 sqlite3_int64,
333 sqlite3_int64,
334 sqlite3_int64,
335 sqlite3_int64,
336 );
337
338 #[repr(C)]
339 pub struct DoltliteServer {
340 _private: [u8; 0],
341 }
342
343 #[repr(C)]
344 pub struct DoltliteServeOpts {
345 pub zDir: *const c_char,
346 pub port: c_int,
347 pub zBindAddr: *const c_char,
348 pub certFile: *const c_char,
349 pub keyFile: *const c_char,
350 pub authKeysDir: *const c_char,
351 pub audience: *const c_char,
352 pub timeoutMs: c_int,
353 pub zVfsName: *const c_char,
354 pub bSessionLoopbackTransfer: c_int,
355 }
356
357 unsafe extern "C" {
358 pub fn sqlite3_doltlite_set_push_progress_callback(
363 db: *mut sqlite3,
364 context: *mut c_void,
365 callback: Option<sqlite3_doltlite_push_progress_callback>,
366 ) -> c_int;
367
368 pub fn sqlite3_doltlite_clear_push_progress_callback(
370 db: *mut sqlite3,
371 context: *mut c_void,
372 ) -> c_int;
373
374 pub fn sqlite3_doltlite_set_clone_progress_callback(
379 db: *mut sqlite3,
380 context: *mut c_void,
381 callback: Option<sqlite3_doltlite_clone_progress_callback>,
382 ) -> c_int;
383
384 pub fn sqlite3_doltlite_clear_clone_progress_callback(
386 db: *mut sqlite3,
387 context: *mut c_void,
388 ) -> c_int;
389
390 pub fn doltliteServe(
391 directory: *const c_char,
392 port: c_int,
393 bind_address: *const c_char,
394 ) -> c_int;
395
396 pub fn doltliteServeAsync(
397 directory: *const c_char,
398 port: c_int,
399 bind_address: *const c_char,
400 ) -> *mut DoltliteServer;
401
402 pub fn doltliteServeOpts(options: *const DoltliteServeOpts) -> c_int;
403
404 pub fn doltliteServeAsyncOpts(options: *const DoltliteServeOpts) -> *mut DoltliteServer;
405
406 pub fn doltliteServerStop(server: *mut DoltliteServer);
407
408 pub fn doltliteServerPort(server: *mut DoltliteServer) -> c_int;
409
410 pub fn doltliteCredsVerifyBearer(
411 authorization: *const c_char,
412 expected_audience: *const c_char,
413 authorized_keys_directory: *const c_char,
414 now: c_long,
415 key_id: *mut *mut c_char,
416 ) -> c_int;
417 }
418}
419
420#[cfg(all(feature = "remote", not(target_arch = "wasm32")))]
421pub use remote::*;
422
423#[cfg(not(feature = "loadable_extension"))]
424unsafe extern "C" {
425 fn doltliteInstallAutoExt() -> core::ffi::c_int;
426}
427
428#[cfg(not(feature = "loadable_extension"))]
429static DOLTLITE_INIT_RESULT: AtomicI32 = AtomicI32::new(i32::MIN);
430
431#[cfg(feature = "loadable_extension")]
432pub fn initialize_doltlite() -> core::ffi::c_int {
433 SQLITE_OK
436}
437
438#[cfg(not(feature = "loadable_extension"))]
439pub fn initialize_doltlite() -> core::ffi::c_int {
440 let existing = DOLTLITE_INIT_RESULT.load(Ordering::Acquire);
441 if existing != i32::MIN {
442 return existing;
443 }
444
445 let result = unsafe { doltliteInstallAutoExt() };
446 match DOLTLITE_INIT_RESULT.compare_exchange(
447 i32::MIN,
448 result,
449 Ordering::AcqRel,
450 Ordering::Acquire,
451 ) {
452 Ok(_) => result,
453 Err(previous) => previous,
454 }
455}
456
457impl Default for sqlite3_vtab {
458 fn default() -> Self {
459 unsafe { mem::zeroed() }
460 }
461}
462
463impl Default for sqlite3_vtab_cursor {
464 fn default() -> Self {
465 unsafe { mem::zeroed() }
466 }
467}