chore: decouple error stack from db

Author: codekeyz

Cargo.lock

@@ -17,3 +17,4 @@ reqwest = { version = "0.12.9", features = ["json", "blocking", "gzip"] }
 num_cpus = "1.17.0"
 tokio-tungstenite = { version = "0.27.0", features = ["native-tls"] }
 futures-util = "0.3.31"
+lazy_static = "1.5.0"

Cargo.toml

@@ -63,8 +63,10 @@ impl DbAuthStrategy for EnvVarStrategy {
     ) -> Pin<Box<dyn Future<Output = Result<TursoConfig, Box<dyn std::error::Error>>> + Send + 'a>>
     {
         Box::pin(async move {
-            let url = std::env::var("TURSO_DB_URL")?;
-            let token = std::env::var("TURSO_DB_TOKEN")?;
+            let url = std::env::var("TURSO_DB_URL")
+                .map_err(|_| "TURSO_DB_URL environment variable not set")?;
+            let token = std::env::var("TURSO_DB_TOKEN")
+                .map_err(|_| "TURSO_DB_TOKEN environment variable not set")?;
 
             Ok(TursoConfig {
                 db_url: url,

src/auth.rs

@@ -15,6 +15,7 @@ use sqlite::{
 
 use crate::{
     auth::{DbAuthStrategy, EnvVarStrategy, GlobeStrategy},
+    sqlite::get_latest_error,
     utils::{
         count_parameters, execute_async_task, get_tokio, is_aligned, sql_is_begin_transaction,
         sql_is_commit, sql_is_pragma, sql_is_rollback,
@@ -61,7 +62,10 @@ pub unsafe extern "C" fn sqlite3_open_v2(
 
     let db_name = CStr::from_ptr(filename).to_str().unwrap();
     if db_name.contains(":memory") {
-        return SQLITE_CANTOPEN;
+        return push_error((
+            "In-memory databases are not supported".to_string(),
+            SQLITE_CANTOPEN,
+        ));
     }
 
     // Check if running in Globe environment
@@ -77,13 +81,12 @@ pub unsafe extern "C" fn sqlite3_open_v2(
     };
     let connection =
         get_tokio().block_on(transport::DatabaseConnection::open(db_name, auth_strategy));
-    if connection.is_err() {
-        return SQLITE_CANTOPEN;
+    if let Some(error) = connection.as_ref().err() {
+        return push_error((error.to_string(), SQLITE_CANTOPEN));
     }
 
     let mock_db = Box::into_raw(Box::new(SQLite3 {
         connection: connection.unwrap(),
-        error_stack: Mutex::new(vec![]),
         transaction_baton: Mutex::new(None),
         last_insert_rowid: Mutex::new(None),
         transaction_has_began: Mutex::new(false),
@@ -115,21 +118,15 @@ pub unsafe extern "C" fn sqlite3_prepare_v3(
     pp_stmt: *mut *mut SQLite3PreparedStmt, // OUT: Prepared statement handle
     pz_tail: *mut *const c_char,            // OUT: Unprocessed SQL string
 ) -> c_int {
-    if pp_stmt.is_null() {
+    if !is_aligned(_db) {
         return SQLITE_ERROR;
     }
 
-    let db = &mut *_db;
-
     if prep_flag != 0 {
-        push_error(
-            db,
-            (
-                "Persisted prepared statements not supported yet.".to_string(),
-                SQLITE_MISUSE,
-            ),
-        );
-        return SQLITE_MISUSE;
+        return push_error((
+            "Persisted prepared statements not supported yet.".to_string(),
+            SQLITE_MISUSE,
+        ));
     }
 
     let bytes = slice::from_raw_parts(_sql as *const u8, byte_len);
@@ -284,11 +281,11 @@ pub unsafe extern "C" fn sqlite3_step(stmt_ptr: *mut SQLite3PreparedStmt) -> c_i
         let sql = stmt.sql.to_uppercase();
         let sql_result_code = {
             if sql_is_begin_transaction(&sql) {
-                execute_async_task(stmt.db, sqlite::begin_tnx_on_db(stmt.db, &sql))
+                execute_async_task(sqlite::begin_tnx_on_db(stmt.db, &sql))
             } else if sql_is_commit(&sql) {
-                execute_async_task(stmt.db, sqlite::commit_tnx_on_db(stmt.db, &sql))
+                execute_async_task(sqlite::commit_tnx_on_db(stmt.db, &sql))
             } else {
-                execute_async_task(stmt.db, sqlite::execute_stmt(stmt))
+                execute_async_task(sqlite::execute_stmt(stmt))
             }
         };
 
@@ -299,7 +296,7 @@ pub unsafe extern "C" fn sqlite3_step(stmt_ptr: *mut SQLite3PreparedStmt) -> c_i
 
     let sql_result_code = sqlite::iterate_rows(stmt);
     if let Err(error) = sql_result_code {
-        push_error(stmt.db, (error.to_string(), SQLITE_ERROR));
+        push_error((error.to_string(), SQLITE_ERROR));
         return SQLITE_ERROR;
     }
 
@@ -377,37 +374,23 @@ pub unsafe extern "C" fn sqlite3_close_v2(db: *mut SQLite3) -> c_int {
 }
 
 #[no_mangle]
-pub extern "C" fn sqlite3_extended_errcode(db: *mut SQLite3) -> c_int {
-    if !is_aligned(db) {
-        return SQLITE_CANTOPEN;
-    }
-
-    let db = unsafe { &mut *db };
-
-    let error_stack = db.error_stack.lock().unwrap();
-    if !error_stack.is_empty() {
-        return error_stack[0].1;
+pub unsafe extern "C" fn sqlite3_extended_errcode(_: *mut SQLite3) -> c_int {
+    let error_stack = get_latest_error();
+    if let Some((_, code)) = error_stack {
+        return code;
     }
 
     SQLITE_OK
 }
 
 #[no_mangle]
-pub extern "C" fn sqlite3_errmsg(db: *mut SQLite3) -> *const c_char {
-    if !is_aligned(db) {
-        return b"Invalid Database pointer\0".as_ptr() as *const c_char;
-    }
-
-    let db = unsafe { &mut *db };
-
-    if let Some(error_entry) = sqlite::get_latest_error(db) {
-        match CString::new(error_entry.0) {
-            Ok(c_string) => c_string.into_raw(),
-            Err(_) => std::ptr::null(),
+pub unsafe extern "C" fn sqlite3_errmsg(_: *mut SQLite3) -> *const c_char {
+    if let Some(error_entry) = sqlite::get_latest_error() {
+        if let Ok(c_string) = CString::new(error_entry.0) {
+            return c_string.into_raw();
         }
-    } else {
-        b"No error\0".as_ptr() as *const c_char
     }
+    std::ptr::null()
 }
 
 #[no_mangle]
@@ -612,7 +595,7 @@ pub extern "C" fn sqlite3_errstr(errcode: c_int) -> *const c_char {
 pub unsafe extern "C" fn sqlite3_exec(
     db: *mut SQLite3,
     sql: *const c_char,
-    callback: SQLite3ExecCallback, // Callback function
+    callback: SQLite3ExecCallback,
     arg: *mut c_void,
     errmsg: *mut *mut c_char,
 ) -> c_int {
@@ -627,14 +610,14 @@ pub unsafe extern "C" fn sqlite3_exec(
     if sql_is_pragma(&sql) {
         return SQLITE_OK;
     } else if sql_is_begin_transaction(&sql) {
-        return execute_async_task(db, sqlite::begin_tnx_on_db(db, &sql));
+        return execute_async_task(sqlite::begin_tnx_on_db(db, &sql));
     } else if sql_is_rollback(&sql) {
         return reset_txn_on_db(db);
     } else if sql_is_commit(&sql) {
-        return execute_async_task(db, sqlite::commit_tnx_on_db(db, &sql));
+        return execute_async_task(sqlite::commit_tnx_on_db(db, &sql));
     }
 
-    execute_async_task(db, sqlite::handle_execute(db, &sql))
+    execute_async_task(sqlite::handle_execute(db, &sql))
 }
 
 #[no_mangle]
@@ -668,15 +651,13 @@ pub extern "C" fn sqlite3_commit_hook(
 #[no_mangle]
 pub extern "C" fn sqlite3_rollback_hook(
     db: *mut SQLite3,
-    x_callback: Option<unsafe extern "C" fn(*mut c_void) -> c_int>, // int (*xCallback)(void*)
-    p_arg: *mut c_void,                                             // void *pArg
+    x_callback: Option<unsafe extern "C" fn(*mut c_void) -> c_int>,
+    p_arg: *mut c_void,
 ) -> c_int {
     if !is_aligned(db) {
         return SQLITE_CANTOPEN;
     }
 
-    let db = unsafe { &mut *db }; // Safely dereference the raw pointer
-
     SQLITE_OK
 }
 

src/lib.rs

@@ -11,6 +11,8 @@ use crate::{
     utils::{convert_params_to_json, get_execution_result},
 };
 
+use lazy_static::lazy_static;
+
 pub const SQLITE_OK: c_int = 0;
 pub const SQLITE_ERROR: c_int = 1;
 pub const SQLITE_MISUSE: c_int = 21;
@@ -76,11 +78,14 @@ impl fmt::Display for SqliteError {
     }
 }
 
+lazy_static! {
+    pub static ref ERROR_STACK: Mutex<Vec<(String, c_int)>> = Mutex::new(Vec::new());
+}
+
 #[repr(C)]
 pub struct SQLite3 {
     pub connection: transport::DatabaseConnection, // Connection to the database
     pub last_insert_rowid: Mutex<Option<i64>>,     // Last inserted row ID
-    pub error_stack: Mutex<Vec<(String, c_int)>>,  // Stack to store error messages
     pub transaction_baton: Mutex<Option<String>>,  // Baton for transaction management
     pub transaction_has_began: Mutex<bool>,        // Flag to check if a transaction has started
     pub update_hook: Mutex<Option<(SqliteHook, *mut c_void)>>, // Update hook callback
@@ -184,8 +189,15 @@ pub type SQLite3ExecCallback = Option<
     ) -> c_int,
 >;
 
-pub fn get_latest_error(db: &SQLite3) -> Option<(String, c_int)> {
-    if let Ok(stack) = db.error_stack.lock() {
+pub unsafe fn push_error(error: (String, c_int)) -> c_int {
+    let mut stack = ERROR_STACK.lock().unwrap();
+    let code = error.1;
+    stack.push(error);
+    code
+}
+
+pub unsafe fn get_latest_error() -> Option<(String, c_int)> {
+    if let Ok(stack) = ERROR_STACK.lock() {
         stack.last().cloned()
     } else {
         None
@@ -205,14 +217,6 @@ pub fn reset_txn_on_db(db: *mut SQLite3) -> c_int {
     SQLITE_OK
 }
 
-pub fn push_error(db: *mut SQLite3, error: (String, c_int)) {
-    let db = unsafe { &mut *db };
-
-    if let Ok(mut stack) = db.error_stack.lock() {
-        stack.push(error);
-    }
-}
-
 pub fn iterate_rows(stmt: &mut SQLite3PreparedStmt) -> Result<c_int, Box<dyn Error>> {
     let result_rows = stmt.result_rows.lock().unwrap();
     let mut current_row = stmt.current_row.lock().unwrap();

src/sqlite.rs

@@ -38,7 +38,7 @@ pub fn count_parameters(sql: &str) -> c_int {
     re.find_iter(&sql).count() as c_int
 }
 
-pub fn execute_async_task<F, R>(db: *mut SQLite3, task: F) -> c_int
+pub fn execute_async_task<F, R>(task: F) -> c_int
 where
     F: std::future::Future<Output = Result<R, SqliteError>>,
     R: Into<c_int>,
@@ -48,7 +48,7 @@ where
     match runtime.block_on(task) {
         Ok(result) => result.into(),
         Err(err) => {
-            push_error(db, (format!("{}", err), err.code));
+            unsafe { push_error((format!("{}", err), err.code)) };
             SQLITE_ERROR
         }
     }