jsql-neo 5.4.2 → 5.5.0

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

@@ -1,3 +1,3 @@
-pub mod engine;
-pub mod storage;
+pub mod engine;
+pub mod storage;
 pub mod types;

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

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

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

@@ -1,2 +1,2 @@
-// Persistent storage engine - WIP, not used by native addon
+// Persistent storage engine - WIP, not used by native addon
 // The native addon uses MemoryEngine only

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

@@ -1,86 +1,86 @@
-use serde::{Deserialize, Serialize};
-use std::io::{Read, Write};
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum WalOp {
-    CreateTable,
-    DropTable,
-    Insert,
-    Update,
-    Remove,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct WalEntry {
-    pub tx_id: u64,
-    pub op: WalOp,
-    pub data: Vec<u8>,
-}
-
-pub struct WalWriter {
-    path: String,
-    file: Option<std::fs::File>,
-    next_tx: u64,
-}
-
-impl WalWriter {
-    pub fn open(path: &str) -> std::io::Result<Self> {
-        let file = std::fs::OpenOptions::new()
-            .create(true)
-            .append(true)
-            .open(path)?;
-        Ok(Self { path: path.to_string(), file: Some(file), next_tx: 1 })
-    }
-
-    #[allow(dead_code)]
-    pub fn append(&mut self, op: WalOp, data: Vec<u8>) -> std::io::Result<u64> {
-        let tx_id = self.next_tx;
-        self.next_tx += 1;
-        let entry = WalEntry { tx_id, op, data };
-        let buf = bincode::serialize(&entry).map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
-        if let Some(ref mut file) = self.file {
-            let len = buf.len() as u64;
-            file.write_all(&len.to_le_bytes())?;
-            file.write_all(&buf)?;
-            file.flush()?;
-        }
-        Ok(tx_id)
-    }
-
-    pub fn flush(&mut self) -> std::io::Result<()> {
-        if let Some(ref mut file) = self.file {
-            file.flush()?;
-        }
-        Ok(())
-    }
-}
-
-pub struct WalReader {
-    path: String,
-}
-
-impl WalReader {
-    pub fn open(path: &str) -> Self {
-        Self { path: path.to_string() }
-    }
-
-    pub fn replay_after(&self, _after_tx: u64) -> std::io::Result<Vec<WalEntry>> {
-        let file = match std::fs::File::open(&self.path) {
-            Ok(f) => f,
-            Err(_) => return Ok(Vec::new()),
-        };
-        let mut reader = std::io::BufReader::new(file);
-        let mut entries = Vec::new();
-        loop {
-            let mut len_buf = [0u8; 8];
-            if reader.read_exact(&mut len_buf).is_err() { break; }
-            let len = u64::from_le_bytes(len_buf) as usize;
-            let mut buf = vec![0u8; len];
-            if reader.read_exact(&mut buf).is_err() { break; }
-            if let Ok(entry) = bincode::deserialize::<WalEntry>(&buf) {
-                entries.push(entry);
-            }
-        }
-        Ok(entries)
-    }
+use serde::{Deserialize, Serialize};
+use std::io::{Read, Write};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum WalOp {
+    CreateTable,
+    DropTable,
+    Insert,
+    Update,
+    Remove,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WalEntry {
+    pub tx_id: u64,
+    pub op: WalOp,
+    pub data: Vec<u8>,
+}
+
+pub struct WalWriter {
+    path: String,
+    file: Option<std::fs::File>,
+    next_tx: u64,
+}
+
+impl WalWriter {
+    pub fn open(path: &str) -> std::io::Result<Self> {
+        let file = std::fs::OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(path)?;
+        Ok(Self { path: path.to_string(), file: Some(file), next_tx: 1 })
+    }
+
+    #[allow(dead_code)]
+    pub fn append(&mut self, op: WalOp, data: Vec<u8>) -> std::io::Result<u64> {
+        let tx_id = self.next_tx;
+        self.next_tx += 1;
+        let entry = WalEntry { tx_id, op, data };
+        let buf = bincode::serialize(&entry).map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
+        if let Some(ref mut file) = self.file {
+            let len = buf.len() as u64;
+            file.write_all(&len.to_le_bytes())?;
+            file.write_all(&buf)?;
+            file.flush()?;
+        }
+        Ok(tx_id)
+    }
+
+    pub fn flush(&mut self) -> std::io::Result<()> {
+        if let Some(ref mut file) = self.file {
+            file.flush()?;
+        }
+        Ok(())
+    }
+}
+
+pub struct WalReader {
+    path: String,
+}
+
+impl WalReader {
+    pub fn open(path: &str) -> Self {
+        Self { path: path.to_string() }
+    }
+
+    pub fn replay_after(&self, _after_tx: u64) -> std::io::Result<Vec<WalEntry>> {
+        let file = match std::fs::File::open(&self.path) {
+            Ok(f) => f,
+            Err(_) => return Ok(Vec::new()),
+        };
+        let mut reader = std::io::BufReader::new(file);
+        let mut entries = Vec::new();
+        loop {
+            let mut len_buf = [0u8; 8];
+            if reader.read_exact(&mut len_buf).is_err() { break; }
+            let len = u64::from_le_bytes(len_buf) as usize;
+            let mut buf = vec![0u8; len];
+            if reader.read_exact(&mut buf).is_err() { break; }
+            if let Ok(entry) = bincode::deserialize::<WalEntry>(&buf) {
+                entries.push(entry);
+            }
+        }
+        Ok(entries)
+    }
 }

package/nativesrc/jsql-neo-core/src/types.rs

@@ -1,94 +1,94 @@
-use std::collections::HashMap;
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Row {
-    pub id: u64,
-    pub fields: HashMap<String, serde_json::Value>,
-    pub created_at: Option<String>,
-    pub updated_at: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TableDefinition {
-    pub name: String,
-    #[serde(with = "schema_order_preserving")]
-    pub schema: Vec<(String, FieldSchema)>,
-}
-
-/// 保序的对象序列化：JSON 对象 ↔ Vec<(String, FieldSchema)>
-pub mod schema_order_preserving {
-    use serde::{Deserialize, Deserializer, Serializer};
-    use super::FieldSchema;
-
-    pub fn serialize<S>(v: &[(String, FieldSchema)], s: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use serde::ser::SerializeMap;
-        let mut m = s.serialize_map(Some(v.len()))?;
-        for (k, f) in v {
-            m.serialize_entry(k, f)?;
-        }
-        m.end()
-    }
-
-    pub fn deserialize<'de, D>(d: D) -> Result<Vec<(String, FieldSchema)>, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct V<'a>(&'a mut Vec<(String, FieldSchema)>);
-        impl<'de, 'a> serde::de::Visitor<'de> for V<'a> {
-            type Value = ();
-            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-                f.write_str("a schema object")
-            }
-            fn visit_map<A>(self, mut a: A) -> Result<(), A::Error>
-            where
-                A: serde::de::MapAccess<'de>,
-            {
-                while let Some((k, f)) = a.next_entry::<String, FieldSchema>()? {
-                    self.0.push((k, f));
-                }
-                Ok(())
-            }
-        }
-        let mut out = Vec::new();
-        d.deserialize_map(V(&mut out))?;
-        Ok(out)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct FieldSchema {
-    #[serde(rename = "type")]
-    pub field_type: FieldType,
-    #[serde(default)]
-    pub primary_key: bool,
-    #[serde(default)]
-    pub auto_increment: bool,
-    #[serde(default)]
-    pub nullable: bool,
-    #[serde(default)]
-    pub unique: bool,
-    #[serde(default)]
-    pub length: Option<usize>,
-    #[serde(default)]
-    pub default: Option<serde_json::Value>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum FieldType {
-    Integer,
-    Float,
-    String,
-    Boolean,
-}
-
-impl Default for FieldType {
-    fn default() -> Self {
-        FieldType::String
-    }
+use std::collections::HashMap;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Row {
+    pub id: u64,
+    pub fields: HashMap<String, serde_json::Value>,
+    pub created_at: Option<String>,
+    pub updated_at: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TableDefinition {
+    pub name: String,
+    #[serde(with = "schema_order_preserving")]
+    pub schema: Vec<(String, FieldSchema)>,
+}
+
+/// 保序的对象序列化：JSON 对象 ↔ Vec<(String, FieldSchema)>
+pub mod schema_order_preserving {
+    use serde::{Deserialize, Deserializer, Serializer};
+    use super::FieldSchema;
+
+    pub fn serialize<S>(v: &[(String, FieldSchema)], s: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        use serde::ser::SerializeMap;
+        let mut m = s.serialize_map(Some(v.len()))?;
+        for (k, f) in v {
+            m.serialize_entry(k, f)?;
+        }
+        m.end()
+    }
+
+    pub fn deserialize<'de, D>(d: D) -> Result<Vec<(String, FieldSchema)>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct V<'a>(&'a mut Vec<(String, FieldSchema)>);
+        impl<'de, 'a> serde::de::Visitor<'de> for V<'a> {
+            type Value = ();
+            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+                f.write_str("a schema object")
+            }
+            fn visit_map<A>(self, mut a: A) -> Result<(), A::Error>
+            where
+                A: serde::de::MapAccess<'de>,
+            {
+                while let Some((k, f)) = a.next_entry::<String, FieldSchema>()? {
+                    self.0.push((k, f));
+                }
+                Ok(())
+            }
+        }
+        let mut out = Vec::new();
+        d.deserialize_map(V(&mut out))?;
+        Ok(out)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FieldSchema {
+    #[serde(rename = "type")]
+    pub field_type: FieldType,
+    #[serde(default)]
+    pub primary_key: bool,
+    #[serde(default)]
+    pub auto_increment: bool,
+    #[serde(default)]
+    pub nullable: bool,
+    #[serde(default)]
+    pub unique: bool,
+    #[serde(default)]
+    pub length: Option<usize>,
+    #[serde(default)]
+    pub default: Option<serde_json::Value>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum FieldType {
+    Integer,
+    Float,
+    String,
+    Boolean,
+}
+
+impl Default for FieldType {
+    fn default() -> Self {
+        FieldType::String
+    }
 }