jsql-neo 4.0.2 → 4.1.0

package/nativesrc/jsql-neo-core/src/engine/table.rs

@@ -104,7 +104,7 @@ pub struct Table {
     pub pk_index: FxHashMap<u64, usize>,
 }
 
-fn default_value(ft: &FieldType) -> FieldValue {
+pub fn default_value(ft: &FieldType) -> FieldValue {
     match ft {
         FieldType::Integer => FieldValue::Int(0),
         FieldType::Float => FieldValue::Float(0.0),
@@ -230,32 +230,49 @@ impl Table {
         });
 
         for mut fields in fields_batch {
-            let id = self.next_id;
+            let auto_id = self.next_id;
             self.next_id += 1;
+            let mut id = auto_id;
 
             if let Some(ref pk_key) = pk_auto_key {
                 match fields.get(pk_key) {
-                    Some(v) if v.is_null() || v.as_i64() == Some(0) => {
-                        fields.insert(pk_key.clone(), serde_json::Value::Number(id.into()));
+                    Some(v) if v.is_null() => {
+                        fields.insert(pk_key.clone(), serde_json::Value::Number(auto_id.into()));
                     }
                     Some(v) => {
                         if let Some(n) = v.as_i64() {
-                            if n > 0 { self.next_id = self.next_id.max((n + 1) as u64); }
+                            if n > 0 {
+                                id = n as u64;
+                                self.next_id = self.next_id.max(id + 1);
+                            }
                         }
                     }
                     None => {
-                        fields.insert(pk_key.clone(), serde_json::Value::Number(id.into()));
+                        fields.insert(pk_key.clone(), serde_json::Value::Number(auto_id.into()));
                     }
                 }
             }
 
             let values_start = self.values.len();
             if fields.len() < self.schema.len() {
-                for (name, fs) in &self.schema {
+                for name in &self.field_order {
                     if let Some(v) = fields.remove(name) {
                         self.values.push(FieldValue::from_json(v));
-                    } else {
-                        self.values.push(default_value(&fs.field_type));
+                        continue;
+                    }
+                    match self.schema.get(name).and_then(|fs| fs.default.clone()) {
+                        Some(dv) => self.values.push(FieldValue::from_json(dv)),
+                        None => {
+                            if let Some(fs) = self.schema.get(name) {
+                                if !fs.nullable {
+                                    self.values.push(default_value(&fs.field_type));
+                                } else {
+                                    self.values.push(FieldValue::Null);
+                                }
+                            } else {
+                                self.values.push(FieldValue::Null);
+                            }
+                        }
                     }
                 }
             } else {
@@ -299,17 +316,19 @@ impl Table {
         {
             let pk_idx = pk_auto_key.as_ref().and_then(|pk| self.field_index.get(pk.as_str()).copied());
             for mut row_vals in batch {
-                let id = self.next_id;
+                let auto_id = self.next_id;
                 self.next_id += 1;
+                let mut id = auto_id;
                 if row_vals.len() < self.field_order.len() {
                     row_vals.resize(self.field_order.len(), FieldValue::Null);
                 }
                 if let Some(pi) = pk_idx {
                     if pi < row_vals.len() {
                         match row_vals[pi] {
-                            FieldValue::Null | FieldValue::Int(0) => row_vals[pi] = FieldValue::Int(id as i64),
+                            FieldValue::Null => row_vals[pi] = FieldValue::Int(auto_id as i64),
                             FieldValue::Int(e) if e > 0 => {
-                                self.next_id = self.next_id.max((e + 1) as u64);
+                                id = e as u64;
+                                self.next_id = self.next_id.max(id + 1);
                             }
                             _ => {}
                         }
@@ -331,26 +350,25 @@ impl Table {
             .collect();
         let explicit_pk_si = pk_auto_key.as_ref()
             .and_then(|pk| field_names.iter().position(|n| n == pk));
+        let pk_idx = pk_auto_key.as_ref().and_then(|pk| self.field_index.get(pk.as_str()).copied());
 
         for mut row_vals in batch {
-            let id = self.next_id;
+            let auto_id = self.next_id;
             self.next_id += 1;
+            let mut id = auto_id;
             if let Some(si) = explicit_pk_si {
                 if let Some(FieldValue::Int(e)) = row_vals.get(si) {
-                    if *e > 0 { self.next_id = self.next_id.max((*e + 1) as u64); }
+                    if *e > 0 {
+                        id = *e as u64;
+                        self.next_id = self.next_id.max(id + 1);
+                    }
                 }
             }
             let values_start = self.values.len();
             for (i, remapped_si) in remap.iter().enumerate() {
                 if let Some(si) = *remapped_si {
                     if si < row_vals.len() {
-                        let v = std::mem::take(&mut row_vals[si]);
-                        let is_auto_pk = pk_auto_key.is_some() && self.field_order[i] == *pk_auto_key.as_ref().unwrap();
-                        if is_auto_pk && matches!(v, FieldValue::Null | FieldValue::Int(0)) {
-                            self.values.push(FieldValue::Int(id as i64));
-                        } else {
-                            self.values.push(v);
-                        }
+                        self.values.push(std::mem::take(&mut row_vals[si]));
                         continue;
                     }
                 }
@@ -374,6 +392,14 @@ impl Table {
                     }
                 }
             }
+            // 显式传入 null 的主键：回填自动 id，保证 pk 值与行 id 一致
+            if let Some(pi) = pk_idx {
+                if let Some(v) = self.values.get_mut(values_start + pi) {
+                    if *v == FieldValue::Null {
+                        *v = FieldValue::Int(id as i64);
+                    }
+                }
+            }
             let idx = self.rows.len();
             self.pk_index.insert(id, idx);
             self.rows.push(RowStore { id, values_start, num_values: self.field_order.len(), created_at: now, updated_at: now });
@@ -433,7 +459,7 @@ impl Table {
 
     fn to_row_json_string(&self, rs: &RowStore) -> String {
         let vals = self.get_row_values(rs);
-        let mut out = String::with_capacity(96);
+        let mut out = String::with_capacity(160);
         out.push_str(r#"{"id":"#);
         out.push_str(itoa::Buffer::new().format(rs.id));
         out.push_str(r#","fields":{"#);
@@ -447,7 +473,11 @@ impl Table {
                 out.push_str("null");
             }
         }
-        out.push_str("}}");
+        out.push_str(r#"},"created_at":"#);
+        write_json_string(&mut out, &millis_to_string(rs.created_at));
+        out.push_str(r#","updated_at":"#);
+        write_json_string(&mut out, &millis_to_string(rs.updated_at));
+        out.push_str("}");
         out
     }
 

package/nativesrc/jsql-neo-core/src/storage/mod.rs

@@ -1 +1,2 @@
-pub mod persistent;
+pub mod persistent;
+pub mod wal;

package/nativesrc/jsql-neo-core/src/storage/wal.rs

@@ -1,4 +1,5 @@
 use serde::{Deserialize, Serialize};
+use std::io::{Read, Write};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum WalOp {

package/nativesrc/jsql-neo-native/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    napi_build::setup();
+}

package/nativesrc/jsql-neo-native/src/lib.rs

@@ -9,6 +9,26 @@ thread_local! {
     static ENGINE: RefCell<HybridEngine> = RefCell::new(HybridEngine::new());
 }
 
+fn with_engine_mut<F>(f: F) -> String
+where
+    F: FnOnce(&mut HybridEngine) -> String,
+{
+    ENGINE.with(|cell| match cell.try_borrow_mut() {
+        Ok(mut eng) => f(&mut eng),
+        Err(_) => r#"{"ok":false,"error":"engine busy (reentrant call)"}"#.to_string(),
+    })
+}
+
+fn with_engine_ro<F>(f: F) -> String
+where
+    F: FnOnce(&HybridEngine) -> String,
+{
+    ENGINE.with(|cell| match cell.try_borrow() {
+        Ok(eng) => f(&eng),
+        Err(_) => r#"{"ok":false,"error":"engine busy (reentrant call)"}"#.to_string(),
+    })
+}
+
 fn safe_json_result(result: Result<String, String>) -> String {
     match result {
         Ok(s) => s,
@@ -18,11 +38,11 @@ fn safe_json_result(result: Result<String, String>) -> String {
 
 #[napi]
 pub fn jsql_open(dir: String, mode: String) -> String {
-    ENGINE.with(|eng| {
-        let open_res = eng.borrow_mut().open(&dir, &mode);
+    with_engine_mut(|eng| {
+        let open_res = eng.open(&dir, &mode);
         match open_res {
             Ok(()) => {
-                let names = eng.borrow().list_tables();
+                let names = eng.list_tables();
                 let mut out = serde_json::Map::new();
                 out.insert("ok".into(), serde_json::Value::Bool(true));
                 out.insert("tables".into(), serde_json::Value::Array(
@@ -30,11 +50,7 @@ pub fn jsql_open(dir: String, mode: String) -> String {
                 ));
                 let mut schemas = serde_json::Map::new();
                 for n in &names {
-                    let s = {
-                        let eng_ref = eng.borrow();
-                        eng_ref.table_schema(n)
-                    };
-                    if let Some(s) = s {
+                    if let Some(s) = eng.table_schema(n) {
                         let mut v = serde_json::Map::new();
                         for (k, fs) in &s {
                             if let Ok(fv) = serde_json::to_value(fs) {
@@ -54,8 +70,8 @@ pub fn jsql_open(dir: String, mode: String) -> String {
 
 #[napi]
 pub fn jsql_flush_dirty() -> String {
-    ENGINE.with(|eng| {
-        match eng.borrow().flush_dirty() {
+    with_engine_mut(|eng| {
+        match eng.flush_dirty() {
             Ok(n) => format!(r#"{{"ok":true,"flushed":{}}}"#, n),
             Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e.replace('"', r#"\""#)),
         }
@@ -64,9 +80,9 @@ pub fn jsql_flush_dirty() -> String {
 
 #[napi]
 pub fn jsql_evict() -> String {
-    ENGINE.with(|eng| {
-        match eng.borrow().evict_one() {
-            Some(name) => format!(r#"{{"ok":true,"evicted":"{}","remaining":{}}}"#, name, eng.borrow().mem_count()),
+    with_engine_mut(|eng| {
+        match eng.evict_one() {
+            Some(name) => format!(r#"{{"ok":true,"evicted":"{}","remaining":{}}}"#, name, eng.mem_count()),
             None => r#"{"ok":true,"evicted":null,"remaining":0}"#.to_string(),
         }
     })
@@ -74,8 +90,8 @@ pub fn jsql_evict() -> String {
 
 #[napi]
 pub fn jsql_close() -> String {
-    ENGINE.with(|eng| {
-        eng.borrow_mut().close();
+    with_engine_mut(|eng| {
+        eng.close();
         r#"{"ok":true}"#.to_string()
     })
 }
@@ -89,7 +105,7 @@ pub fn jsql_create_table(name: String, schema_json: String) -> String {
         Err(e) => return format!(r#"{{"ok":false,"error":"invalid schema: {}"}}"#, e),
     };
     let def = TableDefinition { name: name.clone(), schema };
-    ENGINE.with(|eng| match eng.borrow_mut().create_table(def) {
+    with_engine_mut(|eng| match eng.create_table(def) {
         Ok(()) => r#"{"ok":true}"#.to_string(),
         Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
     })
@@ -97,7 +113,7 @@ pub fn jsql_create_table(name: String, schema_json: String) -> String {
 
 #[napi]
 pub fn jsql_drop_table(name: String) -> String {
-    ENGINE.with(|eng| match eng.borrow_mut().drop_table(&name) {
+    with_engine_mut(|eng| match eng.drop_table(&name) {
         Ok(()) => r#"{"ok":true}"#.to_string(),
         Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
     })
@@ -105,77 +121,27 @@ pub fn jsql_drop_table(name: String) -> String {
 
 #[napi]
 pub fn jsql_insert(table: String, data_json: String) -> String {
-    ENGINE.with(|eng| {
+    with_engine_mut(|eng| {
         let data: Vec<HashMap<String, serde_json::Value>> = match serde_json::from_str(&data_json) {
             Ok(d) => d,
             Err(e) => return format!(r#"{{"error":"invalid data: {}"}}"#, e),
         };
-        match eng.borrow_mut().insert(&table, data) {
+        match eng.insert(&table, data) {
             Ok(ids) => serde_json::to_string(&ids).unwrap_or_else(|_| "[]".to_string()),
             Err(e) => format!(r#"{{"error":"{}"}}"#, e),
         }
     })
 }
 
-#[inline(always)]
-unsafe fn parse_field_value_unsafe(data: &[u8], off: &mut usize) -> FieldValue {
-    let tag = *data.get_unchecked(*off); *off += 1;
-    match tag {
-        0 => FieldValue::Null,
-        1 => {
-            let n = i64::from_le_bytes([
-                *data.get_unchecked(*off), *data.get_unchecked(*off+1),
-                *data.get_unchecked(*off+2), *data.get_unchecked(*off+3),
-                *data.get_unchecked(*off+4), *data.get_unchecked(*off+5),
-                *data.get_unchecked(*off+6), *data.get_unchecked(*off+7),
-            ]);
-            *off += 8;
-            FieldValue::Int(n)
-        }
-        2 => {
-            let n = f64::from_le_bytes([
-                *data.get_unchecked(*off), *data.get_unchecked(*off+1),
-                *data.get_unchecked(*off+2), *data.get_unchecked(*off+3),
-                *data.get_unchecked(*off+4), *data.get_unchecked(*off+5),
-                *data.get_unchecked(*off+6), *data.get_unchecked(*off+7),
-            ]);
-            *off += 8;
-            FieldValue::Float(n)
-        }
-        3 => {
-            let len = u32::from_le_bytes([
-                *data.get_unchecked(*off), *data.get_unchecked(*off+1),
-                *data.get_unchecked(*off+2), *data.get_unchecked(*off+3),
-            ]) as usize;
-            *off += 4;
-            let s = std::str::from_utf8_unchecked(std::slice::from_raw_parts(
-                data.as_ptr().add(*off), len
-            ));
-            *off += len;
-            FieldValue::String(s.to_string())
-        }
-        4 => { let b = *data.get_unchecked(*off) != 0; *off += 1; FieldValue::Bool(b) }
-        5 => {
-            let n = i32::from_le_bytes([
-                *data.get_unchecked(*off), *data.get_unchecked(*off+1),
-                *data.get_unchecked(*off+2), *data.get_unchecked(*off+3),
-            ]) as i64;
-            *off += 4;
-            FieldValue::Int(n)
-        }
-        _ => FieldValue::Null,
-    }
-}
-
 #[napi]
 pub fn jsql_insert_buf(table: String, data: JsBuffer) -> String {
     let buf_val = match data.into_value() {
         Ok(v) => v,
         Err(_) => return r#"{"error":"invalid buffer"}"#.to_string(),
     };
-    ENGINE.with(|eng| {
+    with_engine_mut(|eng| {
         let buf: &[u8] = buf_val.as_ref();
-        let res = eng.borrow().insert_buf(&table, buf)
+        let res = eng.insert_buf(&table, buf)
             .map(|ids| serde_json::to_string(&ids).unwrap_or_else(|_| "[]".to_string()));
         safe_json_result(res.map_err(|e| e))
     })
@@ -183,10 +149,10 @@ pub fn jsql_insert_buf(table: String, data: JsBuffer) -> String {
 
 #[napi]
 pub fn jsql_find(table: String, filter_json: String, limit: i32, offset: i32) -> String {
-    ENGINE.with(|eng| {
+    with_engine_ro(|eng| {
         let filter: Option<HashMap<String, serde_json::Value>> =
             if filter_json.is_empty() { None } else { serde_json::from_str(&filter_json).ok() };
-        match eng.borrow().find(&table, &filter, Some(limit as usize), Some(offset as usize), None, &None, &None) {
+        match eng.find(&table, &filter, Some(limit as usize), Some(offset as usize), None, &None, &None) {
             Ok((rows, _, _)) => serde_json::to_string(&rows).unwrap_or_else(|_| "[]".to_string()),
             Err(e) => format!(r#"{{"error":"{}"}}"#, e),
         }
@@ -195,8 +161,8 @@ pub fn jsql_find(table: String, filter_json: String, limit: i32, offset: i32) ->
 
 #[napi]
 pub fn jsql_find_by_id(table: String, id: i64) -> String {
-    ENGINE.with(|eng| {
-        match eng.borrow().find_by_id_json(&table, id as u64) {
+    with_engine_ro(|eng| {
+        match eng.find_by_id_json(&table, id as u64) {
             Ok(Some(s)) => s,
             Ok(None) => "null".to_string(),
             Err(e) => format!(r#"{{"error":"{}"}}"#, e),
@@ -204,11 +170,9 @@ pub fn jsql_find_by_id(table: String, id: i64) -> String {
     })
 }
 
-
-
 #[napi]
 pub fn jsql_count(table: String) -> String {
-    ENGINE.with(|eng| match eng.borrow().count(&table) {
+    with_engine_ro(|eng| match eng.count(&table) {
         Ok(c) => format!("{}", c),
         Err(e) => format!(r#"{{"error":"{}"}}"#, e),
     })
@@ -216,12 +180,12 @@ pub fn jsql_count(table: String) -> String {
 
 #[napi]
 pub fn jsql_update_by_id(table: String, id: i64, data_json: String) -> String {
-    ENGINE.with(|eng| {
+    with_engine_mut(|eng| {
         let data: HashMap<String, serde_json::Value> = match serde_json::from_str(&data_json) {
             Ok(d) => d,
             Err(e) => return format!(r#"{{"ok":false,"error":"invalid data: {}"}}"#, e),
         };
-        match eng.borrow_mut().update_by_id(&table, id as u64, data) {
+        match eng.update_by_id(&table, id as u64, data) {
             Ok(true) => r#"{"ok":true}"#.to_string(),
             Ok(false) => r#"{"ok":false,"error":"not found"}"#.to_string(),
             Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
@@ -231,7 +195,7 @@ pub fn jsql_update_by_id(table: String, id: i64, data_json: String) -> String {
 
 #[napi]
 pub fn jsql_remove_by_id(table: String, id: i64) -> String {
-    ENGINE.with(|eng| match eng.borrow_mut().remove_by_id(&table, id as u64) {
+    with_engine_mut(|eng| match eng.remove_by_id(&table, id as u64) {
         Ok(true) => r#"{"ok":true}"#.to_string(),
         Ok(false) => r#"{"ok":false,"error":"not found"}"#.to_string(),
         Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
@@ -240,12 +204,12 @@ pub fn jsql_remove_by_id(table: String, id: i64) -> String {
 
 #[napi]
 pub fn jsql_remove_by_ids(table: String, ids_json: String) -> String {
-    ENGINE.with(|eng| {
+    with_engine_mut(|eng| {
         let ids: Vec<u64> = match serde_json::from_str(&ids_json) {
             Ok(v) => v,
             Err(e) => return format!(r#"{{"error":"invalid ids: {}"}}"#, e),
         };
-        match eng.borrow_mut().remove_by_ids(&table, &ids) {
+        match eng.remove_by_ids(&table, &ids) {
             Ok(n) => format!(r#"{{"ok":true,"count":{}}}"#, n),
             Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
         }
@@ -254,12 +218,12 @@ pub fn jsql_remove_by_ids(table: String, ids_json: String) -> String {
 
 #[napi]
 pub fn jsql_update_by_ids(table: String, batch_json: String) -> String {
-    ENGINE.with(|eng| {
+    with_engine_mut(|eng| {
         let batch: Vec<(u64, HashMap<String, serde_json::Value>)> = match serde_json::from_str(&batch_json) {
             Ok(v) => v,
             Err(e) => return format!(r#"{{"error":"invalid batch: {}"}}"#, e),
         };
-        match eng.borrow_mut().update_by_ids(&table, batch) {
+        match eng.update_by_ids(&table, batch) {
             Ok(n) => format!(r#"{{"ok":true,"count":{}}}"#, n),
             Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
         }
@@ -268,14 +232,38 @@ pub fn jsql_update_by_ids(table: String, batch_json: String) -> String {
 
 #[napi]
 pub fn jsql_find_by_ids(table: String, ids_json: String) -> String {
-    ENGINE.with(|eng| {
+    with_engine_ro(|eng| {
         let ids: Vec<u64> = match serde_json::from_str(&ids_json) {
             Ok(v) => v,
             Err(e) => return format!(r#"{{"error":"invalid ids: {}"}}"#, e),
         };
-        match eng.borrow().find_by_ids_json(&table, &ids) {
+        match eng.find_by_ids_json(&table, &ids) {
             Ok(s) => s,
             Err(e) => format!(r#"{{"error":"{}"}}"#, e),
         }
     })
 }
+
+#[napi]
+pub fn jsql_begin_tx() -> String {
+    with_engine_mut(|eng| match eng.begin_tx() {
+        Ok(tx_id) => serde_json::json!({ "ok": true, "txId": tx_id }).to_string(),
+        Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
+    })
+}
+
+#[napi]
+pub fn jsql_commit_tx(tx_id: String) -> String {
+    with_engine_mut(|eng| match eng.commit_tx(&tx_id) {
+        Ok(()) => r#"{"ok":true}"#.to_string(),
+        Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
+    })
+}
+
+#[napi]
+pub fn jsql_rollback_tx(tx_id: String) -> String {
+    with_engine_mut(|eng| match eng.rollback_tx(&tx_id) {
+        Ok(()) => r#"{"ok":true}"#.to_string(),
+        Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
+    })
+}