more fixes

Author: codekeyz

src/lib.rs

@@ -236,6 +236,22 @@ pub unsafe extern "C" fn sqlite3_bind_int64(
     SQLITE_OK
 }
 
+#[no_mangle]
+pub extern "C" fn sqlite3_bind_null(stmt_ptr: *mut SQLite3PreparedStmt, index: c_int) -> c_int {
+    if stmt_ptr.is_null() {
+        return SQLITE_MISUSE;
+    }
+
+    let stmt = unsafe { &mut *stmt_ptr };
+
+    if index <= 0 || index > stmt.param_count {
+        return SQLITE_RANGE;
+    }
+
+    stmt.params.insert(index, Value::Null);
+    SQLITE_OK
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn sqlite3_step(stmt_ptr: *mut SQLite3PreparedStmt) -> c_int {
     if stmt_ptr.is_null() {
@@ -246,7 +262,7 @@ pub unsafe extern "C" fn sqlite3_step(stmt_ptr: *mut SQLite3PreparedStmt) -> c_i
 
     let mut exec_state = match stmt.execution_state.lock() {
         Ok(guard) => guard,
-        Err(_) => return SQLITE_ERROR, // Lock poisoned
+        Err(_) => return SQLITE_ERROR,
     };
 
     match *exec_state {
@@ -261,17 +277,15 @@ pub unsafe extern "C" fn sqlite3_step(stmt_ptr: *mut SQLite3PreparedStmt) -> c_i
     drop(exec_state);
 
     let sql = stmt.sql.to_uppercase();
-    if sql.starts_with("INSERT") {
-        return execute_async_task(stmt.db, sqlite::handle_insert(stmt));
-    } else if sql.starts_with("SELECT") {
+    if sql.starts_with("SELECT") {
         return execute_async_task(stmt.db, sqlite::handle_select(stmt));
     } else if sql_is_begin_transaction(&sql) {
         return execute_async_task(stmt.db, sqlite::begin_tnx_on_db(stmt.db));
     } else if sql_is_commit(&sql) {
         return execute_async_task(stmt.db, sqlite::commit_tnx_on_db(stmt.db));
     }
 
-    SQLITE_ERROR
+    execute_async_task(stmt.db, sqlite::execute_statement(stmt))
 }
 
 #[no_mangle]
@@ -363,18 +377,18 @@ pub extern "C" fn sqlite3_extended_errcode(db: *mut SQLite3) -> c_int {
 #[no_mangle]
 pub extern "C" fn sqlite3_errmsg(db: *mut SQLite3) -> *const c_char {
     if db.is_null() {
-        return std::ptr::null();
+        return b"Invalid DB 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(),
+            Ok(c_string) => c_string.as_ptr(),
             Err(_) => std::ptr::null(),
         }
     } else {
-        std::ptr::null()
+        b"No error\0".as_ptr() as *const c_char
     }
 }
 
@@ -594,14 +608,14 @@ pub unsafe extern "C" fn sqlite3_exec(
     if sql_is_pragma(&sql) {
         return SQLITE_OK;
     } else if sql_is_begin_transaction(&sql) {
-        execute_async_task(db, sqlite::begin_tnx_on_db(db))
+        return execute_async_task(db, sqlite::begin_tnx_on_db(db));
     } else if sql_is_rollback(&sql) {
-        reset_txn_on_db(db)
+        return reset_txn_on_db(db);
     } else if sql_is_commit(&sql) {
-        execute_async_task(db, sqlite::commit_tnx_on_db(db))
-    } else {
-        execute_async_task(db, sqlite::handle_execute(db, &sql))
+        return execute_async_task(db, sqlite::commit_tnx_on_db(db));
     }
+
+    execute_async_task(db, sqlite::handle_execute(db, &sql))
 }
 
 #[no_mangle]

src/proxy.rs

@@ -111,8 +111,13 @@ async fn send_sql_request(
     config: &TursoConfig,
     request: serde_json::Value,
 ) -> Result<RemoteSqliteResponse, Box<dyn Error>> {
+    if cfg!(debug_assertions) {
+        println!("Sending SQL Request: {}", request);
+    }
+
     let response: serde_json::Value =
         send_remote_request(client, config, "v2/pipeline", request).await?;
+
     let parsed: RemoteSqliteResponse = serde_json::from_value(response)?;
     Ok(parsed)
 }
@@ -132,14 +137,27 @@ async fn send_remote_request(
         .await?;
 
     let status = response.status();
-    let response_text: String = response.text().await?;
+    let response_text = response.text().await?;
 
-    let parsed_response = serde_json::from_str::<serde_json::Value>(&response_text);
-    if parsed_response.is_err() && !status.is_success() {
+    if cfg!(debug_assertions) {
+        println!("Received Response: {}\n", &response_text);
+    }
+
+    if !status.is_success() {
+        if let Ok(error_body) = serde_json::from_str::<serde_json::Value>(&response_text) {
+            if let Some(error_message) = error_body.get("error").and_then(|e| e.as_str()) {
+                return Err(error_message.into());
+            }
+        }
+        return Err(format!("LibSqlite3_Turso Error: {}", response_text).into());
+    }
+
+    let parsed_response = serde_json::from_str(&response_text);
+    if parsed_response.is_err() {
         return Err(format!("Failed to parse response: {}", parsed_response.unwrap_err()).into());
     }
 
-    let parsed_response = parsed_response.unwrap();
+    let parsed_response: serde_json::Value = parsed_response.unwrap();
     if let Some(results) = parsed_response.get("results").and_then(|r| r.as_array()) {
         for result in results {
             if let Some(error) = result
@@ -152,21 +170,6 @@ async fn send_remote_request(
         }
     }
 
-    // Check if the status code indicates success
-    if !status.is_success() {
-        if let Ok(error_body) = serde_json::from_str::<serde_json::Value>(&response_text) {
-            if let Some(error_message) = error_body.get("error").and_then(|e| e.as_str()) {
-                return Err(error_message.into());
-            }
-        }
-
-        return Err(format!("LibSqlite3_Turso Error: {}", response_text).into());
-    }
-
-    if cfg!(debug_assertions) {
-        println!("SQL Request: {}\nResponse: {}\n", request, parsed_response);
-    }
-
     Ok(parsed_response)
 }
 
@@ -181,12 +184,12 @@ pub fn convert_params_to_json(params: &HashMap<i32, Value>) -> Vec<serde_json::V
         .map(|(_, value)| match value {
             Value::Integer(i) => serde_json::json!({
                 "type": "integer",
-                "value": *i
+                "value": *i.to_string()
             }),
 
             Value::Real(f) => serde_json::json!({
                 "type": "float",
-                "value": *f
+                "value": *f.to_string()
             }),
             Value::Text(s) => serde_json::json!({
                 "type": "text",