gqlite 1.2.2 → 1.3.0

data/ext/gqliterb/src/lib.rs

@@ -1,5 +1,7 @@
 #![deny(warnings)]
 
+use std::fmt::Display;
+
 use magnus::{
   function, method,
   prelude::*,
@@ -113,7 +115,7 @@ fn node_to_rhash(ruby: &Ruby, node: gqlitedb::Node) -> Result<magnus::Value, Err
   r_hash.aset("key", integer_from_u128(ruby, key.into())?)?;
   r_hash.aset("labels", labels)?;
   r_hash.aset("properties", to_rhash(ruby, properties)?)?;
-  Ok(r_hash.into_value())
+  Ok(r_hash.into_value_with(ruby))
 }
 
 fn edge_to_rhash(ruby: &Ruby, edge: gqlitedb::Edge) -> Result<magnus::Value, Error>
@@ -124,7 +126,7 @@ fn edge_to_rhash(ruby: &Ruby, edge: gqlitedb::Edge) -> Result<magnus::Value, Err
   r_hash.aset("key", integer_from_u128(ruby, key.into())?)?;
   r_hash.aset("labels", labels)?;
   r_hash.aset("properties", to_rhash(ruby, properties)?)?;
-  Ok(r_hash.into_value())
+  Ok(r_hash.into_value_with(ruby))
 }
 
 fn path_to_rhash(ruby: &Ruby, path: gqlitedb::Path) -> Result<magnus::Value, Error>
@@ -137,20 +139,21 @@ fn path_to_rhash(ruby: &Ruby, path: gqlitedb::Path) -> Result<magnus::Value, Err
   r_hash.aset("properties", to_rhash(ruby, properties)?)?;
   r_hash.aset("source", node_to_rhash(ruby, source)?)?;
   r_hash.aset("destination", node_to_rhash(ruby, destination)?)?;
-  Ok(r_hash.into_value())
+  Ok(r_hash.into_value_with(ruby))
 }
 
 fn to_rvalue(ruby: &Ruby, val: gqlitedb::Value) -> Result<magnus::Value, Error>
 {
   match val
   {
-    gqlitedb::Value::Array(arr) => Ok(to_rarray(ruby, arr)?.into_value()),
-    gqlitedb::Value::Boolean(b) => Ok(b.into_value()),
-    gqlitedb::Value::Integer(i) => Ok(i.into_value()),
-    gqlitedb::Value::Float(f) => Ok(f.into_value()),
-    gqlitedb::Value::String(s) => Ok(s.into_value()),
-    gqlitedb::Value::Map(m) => Ok(to_rhash(ruby, m)?.into_value()),
-    gqlitedb::Value::Null => Ok(ruby.qnil().into_value()),
+    gqlitedb::Value::Array(arr) => Ok(to_rarray(ruby, arr)?.into_value_with(ruby)),
+    gqlitedb::Value::Boolean(b) => Ok(b.into_value_with(ruby)),
+    gqlitedb::Value::Key(k) => Ok(integer_from_u128(ruby, k.into())?.into_value_with(ruby)),
+    gqlitedb::Value::Integer(i) => Ok(i.into_value_with(ruby)),
+    gqlitedb::Value::Float(f) => Ok(f.into_value_with(ruby)),
+    gqlitedb::Value::String(s) => Ok(s.into_value_with(ruby)),
+    gqlitedb::Value::Map(m) => Ok(to_rhash(ruby, m)?.into_value_with(ruby)),
+    gqlitedb::Value::Null => Ok(ruby.qnil().into_value_with(ruby)),
     gqlitedb::Value::Edge(e) => Ok(edge_to_rhash(ruby, e)?),
     gqlitedb::Value::Node(n) => Ok(node_to_rhash(ruby, n)?),
     gqlitedb::Value::Path(p) => Ok(path_to_rhash(ruby, p)?),
@@ -169,7 +172,7 @@ fn to_rhash(ruby: &Ruby, map: gqlitedb::ValueMap) -> Result<r_hash::RHash, Error
 
 fn to_rarray(ruby: &Ruby, arr: Vec<gqlitedb::Value>) -> Result<r_array::RArray, Error>
 {
-  let r_arr = r_array::RArray::with_capacity(arr.len());
+  let r_arr = ruby.ary_new_capa(arr.len());
 
   for value in arr.into_iter()
   {
@@ -179,7 +182,9 @@ fn to_rarray(ruby: &Ruby, arr: Vec<gqlitedb::Value>) -> Result<r_array::RArray,
   Ok(r_arr)
 }
 
-fn map_err<T>(ruby: &Ruby, result: gqlitedb::Result<T>) -> Result<T, Error>
+fn map_err<T, E>(ruby: &Ruby, result: Result<T, E>) -> Result<T, Error>
+where
+  E: Display,
 {
   result.map_err(|e| Error::new(ruby.get_inner(&ERROR), format!("{}", e)))
 }
@@ -187,7 +192,7 @@ fn map_err<T>(ruby: &Ruby, result: gqlitedb::Result<T>) -> Result<T, Error>
 #[magnus::wrap(class = "GQLite::Connection")]
 struct Connection
 {
-  dbhandle: gqlitedb::Connection,
+  dbhandle: std::sync::RwLock<Option<gqlitedb::Connection>>,
 }
 
 impl Connection
@@ -201,13 +206,21 @@ impl Connection
     let filename: String = map_err(
       ruby,
       options
-        .get("filename".into())
+        .get("filename")
         .ok_or_else(|| Error::new(ruby.get_inner(&ERROR), "Missing filename."))?
         .to_owned()
         .try_into(),
     )?;
-    let dbhandle = map_err(ruby, gqlitedb::Connection::open(filename, options))?;
-    Ok(Self { dbhandle })
+    let dbhandle = map_err(
+      ruby,
+      gqlitedb::Connection::builder()
+        .options(options)
+        .path(filename)
+        .create(),
+    )?;
+    Ok(Self {
+      dbhandle: std::sync::RwLock::new(Some(dbhandle)),
+    })
   }
   fn execute_oc_query(
     ruby: &Ruby,
@@ -215,32 +228,46 @@ impl Connection
     args: &[magnus::Value],
   ) -> Result<magnus::Value, Error>
   {
-    let args = scan_args::scan_args::<_, (), (), (), _, ()>(args)?;
-    let (query,): (String,) = args.required;
+    match &*rb_self.dbhandle.read().unwrap()
+    {
+      Some(connection) =>
+      {
+        let args = scan_args::scan_args::<_, (), (), (), _, ()>(args)?;
+        let (query,): (String,) = args.required;
 
-    let kw = scan_args::get_kwargs::<_, (), (Option<magnus::Value>,), ()>(
-      args.keywords,
-      &[],
-      &["bindings"],
-    )?;
-    let (bindings,) = kw.optional;
+        let kw = scan_args::get_kwargs::<_, (), (Option<magnus::Value>,), ()>(
+          args.keywords,
+          &[],
+          &["bindings"],
+        )?;
+        let (bindings,) = kw.optional;
 
-    let bindings = bindings
-      .map(|bindings| {
-        if bindings.is_nil()
-        {
-          Ok(Default::default())
-        }
-        else
-        {
-          from_rhash(ruby, r_hash::RHash::try_convert(bindings)?)
-        }
-      })
-      .transpose()?
-      .unwrap_or_default();
-    let result = map_err(ruby, rb_self.dbhandle.execute_query(query, bindings))?;
+        let bindings = bindings
+          .map(|bindings| {
+            if bindings.is_nil()
+            {
+              Ok(Default::default())
+            }
+            else
+            {
+              from_rhash(ruby, r_hash::RHash::try_convert(bindings)?)
+            }
+          })
+          .transpose()?
+          .unwrap_or_default();
+        let result = map_err(ruby, connection.execute_oc_query(query, bindings))?;
 
-    to_rvalue(ruby, result)
+        to_rvalue(ruby, result.into_value())
+      }
+      None => Err(Error::new(
+        ruby.get_inner(&ERROR),
+        "Connection is closed.".to_string(),
+      )),
+    }
+  }
+  fn close(&self)
+  {
+    *self.dbhandle.write().unwrap() = None;
   }
 }
 
@@ -256,5 +283,6 @@ fn init(ruby: &Ruby) -> Result<(), Error>
     "execute_oc_query",
     method!(Connection::execute_oc_query, -1),
   )?;
+  class.define_method("close", method!(Connection::close, 0))?;
   Ok(())
 }

data/ext/graphcore/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "graphcore"
+description = "Base data structure to represent and manipulate property graph."
+# version.workspace = true
+version = "0.2.0"
+readme = "README.MD"
+edition.workspace = true
+license.workspace = true
+homepage.workspace = true
+repository.workspace = true
+
+[dependencies]
+itertools = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+thiserror = { workspace = true }
+uuid = { workspace = true }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+uuid = { version = "1", features = ["js"] }

data/ext/graphcore/README.MD

@@ -0,0 +1,4 @@
+![GQLite logo](https://gqlite.org/assets/images/logo-88x88.png) graphcore
+=========================================================================
+
+`GraphCore` is part of the [GQLite project](https://gqlite.org) project, it provides base type for representing values, nodes and edges in a property graph.

data/ext/graphcore/release.toml

@@ -0,0 +1 @@
+tag = false

data/ext/graphcore/src/error.rs

@@ -0,0 +1,28 @@
+/// Represent errors.
+#[derive(thiserror::Error, Debug)]
+#[allow(missing_docs)]
+#[non_exhaustive]
+pub enum Error
+{
+  #[error("InvalidBinaryOperands: operands for binary operation are not compatible.")]
+  InvalidBinaryOperands,
+  #[error("InvalidNegationOperands: operands for negation operation are not compatible.")]
+  InvalidNegationOperands,
+  #[error("Invalid value cast, cannot cast {value} to {typename}.")]
+  InvalidValueCast
+  {
+    value: Box<crate::Value>,
+    typename: &'static str,
+  },
+  #[error("Key {key} cannot be found in a path in a ValueMap.")]
+  MissingKeyInPath
+  {
+    key: String
+  },
+  #[error("Path cannot have null key.")]
+  MissingKey,
+  #[error("Invalid table dimensions.")]
+  InvalidTableDimensions,
+  #[error("Out of range access.")]
+  InvalidRange,
+}

data/ext/{gqliterb/vendor/gqlitedb → graphcore}/src/graph.rs

@@ -3,19 +3,27 @@ use std::borrow::Borrow;
 
 use crate::prelude::*;
 
-#[derive(Debug, Clone, Copy)]
-pub(crate) enum EdgeDirectivity
-{
-  Undirected,
-  Directed,
-}
-
+/// Uuid of a graph element (node, edge...).
 #[derive(Debug, Eq, PartialEq, Clone, Copy, Hash)]
 pub struct Key
 {
   pub(crate) uuid: u128,
 }
 
+impl Key
+{
+  /// New key from a given uuid
+  pub fn new(uuid: u128) -> Self
+  {
+    Self { uuid }
+  }
+  /// Return the 128bits uuid value.
+  pub fn uuid(&self) -> u128
+  {
+    self.uuid
+  }
+}
+
 impl Serialize for Key
 {
   fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -79,6 +87,15 @@ pub struct Node
 
 impl Node
 {
+  /// Create a new node object
+  pub fn new(key: Key, labels: Vec<String>, properties: value::ValueMap) -> Node
+  {
+    Self {
+      key,
+      labels,
+      properties,
+    }
+  }
   /// uuid for the Node.
   pub fn key(&self) -> Key
   {
@@ -89,16 +106,43 @@ impl Node
   {
     &self.labels
   }
+  /// Mutable labels
+  pub fn labels_mut(&mut self) -> &mut Vec<String>
+  {
+    &mut self.labels
+  }
+  /// Edit labels
+  pub fn labels_edit(&mut self, editor: impl FnOnce(Vec<String>) -> Vec<String>)
+  {
+    let mut tmp = Default::default();
+    std::mem::swap(&mut self.labels, &mut tmp);
+    self.labels = editor(tmp);
+  }
   /// Properties.
   pub fn properties(&self) -> &value::ValueMap
   {
     &self.properties
   }
+  /// Properties.
+  pub fn take_properties(self) -> value::ValueMap
+  {
+    self.properties
+  }
+  /// Properties.
+  pub fn properties_mut(&mut self) -> &mut value::ValueMap
+  {
+    &mut self.properties
+  }
   /// Unpack Node in key, labels and properties.
   pub fn unpack(self) -> (Key, Vec<String>, value::ValueMap)
   {
     (self.key, self.labels, self.properties)
   }
+  /// Convert into value map representation
+  pub fn into_value_map(self) -> value::ValueMap
+  {
+    crate::value_map!("key" => self.key, "labels" => self.labels, "properties" => self.properties, "type" => "node")
+  }
 }
 
 impl std::fmt::Display for Node
@@ -125,12 +169,6 @@ pub struct Edge
 {
   /// uuid for the Edge.
   pub(crate) key: Key,
-  #[serde(skip_serializing)]
-  /// source node for the Edge, this property is used internally by the engine, but is not exported in query results, and not part of the public API.
-  pub(crate) source: Node,
-  /// destination node for the Edge, this property is used internally by the engine, but is not exported in query results, and not part of the public API.
-  #[serde(skip_serializing)]
-  pub(crate) destination: Node,
   /// Labels for the Edge.
   pub(crate) labels: Vec<String>,
   /// Properties for the Edge.
@@ -139,6 +177,16 @@ pub struct Edge
 
 impl Edge
 {
+  /// Create a new node object
+  pub fn new(key: Key, labels: Vec<String>, properties: value::ValueMap) -> Edge
+  {
+    Self {
+      key,
+      labels,
+      properties,
+    }
+  }
+
   /// uuid for the Node.
   pub fn key(&self) -> Key
   {
@@ -149,16 +197,43 @@ impl Edge
   {
     &self.labels
   }
+  /// Mutable labels
+  pub fn labels_mut(&mut self) -> &mut Vec<String>
+  {
+    &mut self.labels
+  }
+  /// Edit labels
+  pub fn labels_edit(&mut self, editor: impl FnOnce(Vec<String>) -> Vec<String>)
+  {
+    let mut tmp = Default::default();
+    std::mem::swap(&mut self.labels, &mut tmp);
+    self.labels = editor(tmp);
+  }
   /// Properties.
   pub fn properties(&self) -> &value::ValueMap
   {
     &self.properties
   }
+  /// Properties.
+  pub fn properties_mut(&mut self) -> &mut value::ValueMap
+  {
+    &mut self.properties
+  }
+  /// Properties.
+  pub fn take_properties(self) -> value::ValueMap
+  {
+    self.properties
+  }
   /// Unpack Edge in key, labels and properties.
   pub fn unpack(self) -> (Key, Vec<String>, value::ValueMap)
   {
     (self.key, self.labels, self.properties)
   }
+  /// Convert into value map representation
+  pub fn into_value_map(self) -> value::ValueMap
+  {
+    crate::value_map!("key" => self.key,  "labels" => self.labels, "properties" => self.properties, "type" => "edge")
+  }
 }
 
 impl std::fmt::Display for Edge
@@ -171,24 +246,10 @@ impl std::fmt::Display for Edge
   }
 }
 
-impl Into<Path> for Edge
-{
-  fn into(self) -> Path
-  {
-    Path {
-      key: self.key,
-      source: self.source,
-      destination: self.destination,
-      labels: self.labels,
-      properties: self.properties,
-    }
-  }
-}
-
-/// Path in the graph.
+/// SinglePath in the graph. A SinglePath contains an edge, source and destination.
 #[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone, Hash)]
 #[serde(tag = "type", rename = "path")]
-pub struct Path
+pub struct SinglePath
 {
   /// uuid for the path.
   pub(crate) key: Key,
@@ -202,8 +263,25 @@ pub struct Path
   pub(crate) properties: value::ValueMap,
 }
 
-impl Path
+impl SinglePath
 {
+  /// Create new single path
+  pub fn new(
+    key: Key,
+    source: Node,
+    labels: Vec<String>,
+    properties: value::ValueMap,
+    destination: Node,
+  ) -> SinglePath
+  {
+    SinglePath {
+      key,
+      source,
+      destination,
+      labels,
+      properties,
+    }
+  }
   /// uuid for the Node.
   pub fn key(&self) -> Key
   {
@@ -240,9 +318,32 @@ impl Path
       self.destination,
     )
   }
+  /// Convert into an Edge
+  pub fn to_edge(&self) -> Edge
+  {
+    Edge {
+      key: self.key,
+      labels: self.labels.clone(),
+      properties: self.properties.clone(),
+    }
+  }
+  /// Convert into an Edge
+  pub fn into_edge(self) -> Edge
+  {
+    Edge {
+      key: self.key,
+      labels: self.labels,
+      properties: self.properties,
+    }
+  }
+  /// Convert into value map representation
+  pub fn into_value_map(self) -> value::ValueMap
+  {
+    crate::value_map!("key" => self.key, "source" => self.source, "labels" => self.labels, "properties" => self.properties, "destination" => self.destination, "type" => "path")
+  }
 }
 
-impl std::fmt::Display for Path
+impl std::fmt::Display for SinglePath
 {
   fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
   {
@@ -252,7 +353,20 @@ impl std::fmt::Display for Path
   }
 }
 
-#[cfg(test)]
+impl From<SinglePath> for Edge
+{
+  fn from(val: SinglePath) -> Self
+  {
+    Edge {
+      key: val.key,
+      labels: val.labels,
+      properties: val.properties,
+    }
+  }
+}
+
+/// Convenient macro to create a vector of label, from &str.
+#[macro_export]
 macro_rules! labels {
   // match a list of expressions separated by comma:
   ($($str:expr),*) => (
@@ -263,6 +377,3 @@ macro_rules! labels {
     }
   );
 }
-
-#[cfg(test)]
-pub(crate) use labels;

data/ext/graphcore/src/lib.rs

@@ -0,0 +1,16 @@
+#![doc = include_str!("../README.MD")]
+#![warn(missing_docs)]
+#![deny(warnings)]
+#![allow(clippy::result_large_err)]
+
+mod error;
+mod graph;
+mod prelude;
+mod serialize_with;
+mod table;
+mod value;
+
+pub use error::Error;
+pub use graph::{Edge, Key, Node, SinglePath};
+pub use table::Table;
+pub use value::{Value, ValueMap, ValueTryIntoRef};

data/ext/graphcore/src/prelude.rs

@@ -0,0 +1,4 @@
+pub(crate) use crate::{error, graph, serialize_with, value};
+pub(crate) use error::Error;
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;

data/ext/{gqliterb/vendor/gqlitedb → graphcore}/src/serialize_with.rs

@@ -2,7 +2,7 @@ use serde::de::{self, Visitor};
 use serde::{Deserializer, Serializer};
 use std::fmt;
 
-const NAN: f64 = std::f64::NAN;
+const NAN: f64 = f64::NAN;
 
 pub fn serialize_float<S>(x: &f64, serializer: S) -> Result<S::Ok, S::Error>
 where
@@ -68,7 +68,7 @@ impl<'de> Visitor<'de> for FloatDeserializeVisitor
   where
     E: de::Error,
   {
-    Ok(v as f64)
+    Ok(v)
   }
 
   fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>