gqlite 1.2.3 → 1.3.0

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/value/compare.rs

@@ -43,11 +43,7 @@ fn compare_map(lhs: &value::ValueMap, rhs: &value::ValueMap) -> Ordering
           o => o.into(),
         }
       })
-      .find(|p| match p
-      {
-        Ordering::Equal => false,
-        _ => true,
-      })
+      .find(|p| !matches!(p, Ordering::Equal))
       .unwrap_or(Ordering::Equal)
   }
   else if lhs.len() < rhs.len()
@@ -74,7 +70,7 @@ fn compare_f64(lhs: &f64, rhs: &f64) -> Ordering
 
 fn compare_node(lhs: &graph::Node, rhs: &graph::Node) -> Ordering
 {
-  lhs.key.uuid.cmp(&rhs.key.uuid).into()
+  lhs.key().uuid().cmp(&rhs.key().uuid()).into()
 }
 
 pub(crate) fn compare(lhs: &value::Value, rhs: &value::Value) -> Ordering
@@ -83,6 +79,12 @@ pub(crate) fn compare(lhs: &value::Value, rhs: &value::Value) -> Ordering
   match lhs
   {
     Value::Null => Ordering::ComparedNull,
+    Value::Key(kl) => match rhs
+    {
+      Value::Key(kr) => kl.uuid().cmp(&kr.uuid()).into(),
+      Value::Null => Ordering::ComparedNull,
+      _ => Ordering::Null,
+    },
     Value::Boolean(bl) => match rhs
     {
       Value::Boolean(br) => bl.cmp(br).into(),
@@ -175,30 +177,21 @@ pub(crate) fn compare(lhs: &value::Value, rhs: &value::Value) -> Ordering
     },
     Value::Edge(lhs) => match rhs
     {
-      Value::Edge(rhs) =>
-      {
-        lhs.key.uuid.cmp(&rhs.key.uuid).into()
-        // let labels_cmp = lhs.labels.cmp(&rhs.labels);
-        // match labels_cmp
-        // {
-        //   std::cmp::Ordering::Equal => compare_map(&lhs.properties, &rhs.properties),
-        //   o => o.into(),
-        // }
-      }
+      Value::Edge(rhs) => lhs.key().uuid().cmp(&rhs.key().uuid()).into(),
       _ => Ordering::Null,
     },
     Value::Path(lhs) => match rhs
     {
       Value::Path(rhs) =>
       {
-        let labels_cmp = lhs.labels.cmp(&rhs.labels);
+        let labels_cmp = lhs.labels().cmp(rhs.labels());
         match labels_cmp
         {
-          std::cmp::Ordering::Equal => match compare_map(&lhs.properties, &rhs.properties)
+          std::cmp::Ordering::Equal => match compare_map(lhs.properties(), rhs.properties())
           {
-            Ordering::Equal => match compare_node(&lhs.source, &rhs.source)
+            Ordering::Equal => match compare_node(lhs.source(), rhs.source())
             {
-              Ordering::Equal => compare_node(&lhs.destination, &rhs.destination),
+              Ordering::Equal => compare_node(lhs.destination(), rhs.destination()),
               o => o,
             },
             o => o,

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/value/contains.rs

@@ -8,7 +8,7 @@ pub(crate) enum ContainResult
 }
 
 /// Compute contains, according to OpenCypher specification, specifically handling the comparison with null.
-pub(crate) fn contains(container: &Vec<value::Value>, value: &value::Value) -> ContainResult
+pub(crate) fn contains(container: &[value::Value], value: &value::Value) -> ContainResult
 {
   if value.is_null()
   {
@@ -27,7 +27,7 @@ pub(crate) fn contains(container: &Vec<value::Value>, value: &value::Value) -> C
     for v_c in container.iter()
     {
       use value::ContainResult;
-      match value::compare(v_c, &value)
+      match value::compare(v_c, value)
       {
         value::Ordering::Equal => return ContainResult::True,
         value::Ordering::ComparedNull => has_compared_to_null = true,

data/ext/gqlitedb/src/value.rs

@@ -0,0 +1,225 @@
+mod compare;
+mod contains;
+
+pub(crate) use compare::{compare, Ordering};
+pub(crate) use contains::{contains, ContainResult};
+
+pub use graphcore::{array, value_map, Value, ValueMap, ValueTryIntoRef};
+
+pub(crate) trait ValueExt
+{
+  fn access<'a>(&self, path: impl Iterator<Item = &'a String>) -> Value;
+  fn compare(&self, rhs: &Value) -> crate::value::Ordering;
+
+  /// Compute the order between self and rhs, for OrderBy, according to the OpenCypher specification.
+  /// This order is total.
+  fn orderability(&self, rhs: &Value) -> std::cmp::Ordering;
+}
+
+fn orderability_map(lhs: &ValueMap, rhs: &ValueMap) -> std::cmp::Ordering
+{
+  let o = lhs.len().cmp(&rhs.len());
+  match o
+  {
+    std::cmp::Ordering::Equal => lhs
+      .iter()
+      .map(|(key, value)| value.orderability(rhs.get(key).unwrap_or(&Value::Null)))
+      .find(|p| *p != std::cmp::Ordering::Equal)
+      .unwrap_or(std::cmp::Ordering::Equal),
+    o => o,
+  }
+}
+fn orderability_float(lhs: &f64, rhs: &f64) -> std::cmp::Ordering
+{
+  if lhs.is_nan()
+  {
+    if rhs.is_nan()
+    {
+      std::cmp::Ordering::Equal
+    }
+    else
+    {
+      std::cmp::Ordering::Greater
+    }
+  }
+  else if rhs.is_nan()
+  {
+    std::cmp::Ordering::Less
+  }
+  else
+  {
+    lhs.total_cmp(rhs)
+  }
+}
+impl ValueExt for Value
+{
+  fn access<'a>(&self, mut path: impl Iterator<Item = &'a String>) -> Value
+  {
+    match path.next()
+    {
+      Some(name) => match self
+      {
+        Value::Node(node) => match node.properties().get(name)
+        {
+          Some(val) => val.access(path),
+          None => Value::Null,
+        },
+        Value::Edge(edge) => match edge.properties().get(name)
+        {
+          Some(val) => val.access(path),
+          None => Value::Null,
+        },
+        Value::Map(obj) => match obj.get(name)
+        {
+          Some(val) => val.access(path),
+          None => Value::Null,
+        },
+        _ => Value::Null,
+      },
+      None => self.to_owned(),
+    }
+  }
+  fn compare(&self, rhs: &Value) -> crate::value::Ordering
+  {
+    crate::value::compare(self, rhs)
+  }
+
+  /// Compute the order between self and rhs, for OrderBy, according to the OpenCypher specification.
+  /// This order is total.
+  fn orderability(&self, rhs: &Value) -> std::cmp::Ordering
+  {
+    match self
+    {
+      Value::Null => match rhs
+      {
+        Value::Null => std::cmp::Ordering::Equal,
+        _ => std::cmp::Ordering::Greater,
+      },
+      Value::Key(lhs) => match rhs
+      {
+        Value::Null => std::cmp::Ordering::Less,
+        Value::Key(rhs) => lhs.uuid().cmp(&rhs.uuid()),
+        _ => std::cmp::Ordering::Greater,
+      },
+      Value::Integer(lhs) => match rhs
+      {
+        Value::Null | Value::Key(..) => std::cmp::Ordering::Less,
+        Value::Integer(rhs) => lhs.cmp(rhs),
+        Value::Float(rhs) => orderability_float(&(*lhs as f64), rhs),
+        _ => std::cmp::Ordering::Greater,
+      },
+      Value::Float(lhs) => match rhs
+      {
+        Value::Null | Value::Key(..) => std::cmp::Ordering::Less,
+        Value::Integer(rhs) => orderability_float(lhs, &(*rhs as f64)),
+        Value::Float(rhs) => orderability_float(lhs, rhs),
+        _ => std::cmp::Ordering::Greater,
+      },
+      Value::Boolean(lhs) => match rhs
+      {
+        Value::Null | Value::Key(..) | Value::Integer(..) | Value::Float(..) =>
+        {
+          std::cmp::Ordering::Less
+        }
+        Value::Boolean(rhs) => lhs.cmp(rhs),
+        _ => std::cmp::Ordering::Greater,
+      },
+      Value::String(lhs) => match rhs
+      {
+        Value::Null
+        | Value::Key(..)
+        | Value::Integer(..)
+        | Value::Float(..)
+        | Value::Boolean(..) => std::cmp::Ordering::Less,
+        Value::String(rhs) => lhs.cmp(rhs),
+        _ => std::cmp::Ordering::Greater,
+      },
+      Value::Path(lhs) => match rhs
+      {
+        Value::Null
+        | Value::Key(..)
+        | Value::Integer(..)
+        | Value::Float(..)
+        | Value::Boolean(..)
+        | Value::String(..) => std::cmp::Ordering::Less,
+        Value::Path(rhs) =>
+        {
+          match orderability_map(lhs.source().properties(), rhs.source().properties())
+          {
+            std::cmp::Ordering::Equal =>
+            {
+              match orderability_map(lhs.properties(), rhs.properties())
+              {
+                std::cmp::Ordering::Equal => orderability_map(
+                  lhs.destination().properties(),
+                  rhs.destination().properties(),
+                ),
+                o => o,
+              }
+            }
+            o => o,
+          }
+        }
+        _ => std::cmp::Ordering::Greater,
+      },
+      Value::Array(lhs) => match rhs
+      {
+        Value::Null
+        | Value::Key(..)
+        | Value::Integer(..)
+        | Value::Float(..)
+        | Value::Boolean(..)
+        | Value::String(..)
+        | Value::Path(..) => std::cmp::Ordering::Less,
+        Value::Array(rhs) => lhs
+          .iter()
+          .zip(rhs.iter())
+          .map(|(lhs, rhs)| Self::orderability(lhs, rhs))
+          .find(|p| *p != std::cmp::Ordering::Equal)
+          .unwrap_or(lhs.len().cmp(&rhs.len())),
+        _ => std::cmp::Ordering::Greater,
+      },
+      Value::Edge(lhs) => match rhs
+      {
+        Value::Null
+        | Value::Key(..)
+        | Value::Integer(..)
+        | Value::Float(..)
+        | Value::Boolean(..)
+        | Value::String(..)
+        | Value::Path(..)
+        | Value::Array(..) => std::cmp::Ordering::Less,
+        Value::Edge(rhs) => orderability_map(lhs.properties(), rhs.properties()),
+        _ => std::cmp::Ordering::Greater,
+      },
+      Value::Node(lhs) => match rhs
+      {
+        Value::Null
+        | Value::Key(..)
+        | Value::Integer(..)
+        | Value::Float(..)
+        | Value::Boolean(..)
+        | Value::String(..)
+        | Value::Path(..)
+        | Value::Array(..)
+        | Value::Edge(..) => std::cmp::Ordering::Less,
+        Value::Node(rhs) => orderability_map(lhs.properties(), rhs.properties()),
+        _ => std::cmp::Ordering::Greater,
+      },
+      Value::Map(lhs) => match rhs
+      {
+        Value::Null
+        | Value::Key(..)
+        | Value::Integer(..)
+        | Value::Float(..)
+        | Value::Boolean(..)
+        | Value::String(..)
+        | Value::Path(..)
+        | Value::Array(..)
+        | Value::Edge(..)
+        | Value::Node(..) => std::cmp::Ordering::Less,
+        Value::Map(rhs) => orderability_map(lhs, rhs),
+      },
+    }
+  }
+}

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

@@ -53,7 +53,7 @@ impl Row
     {
       Err(
         InternalError::InvalidIndex {
-          index: index,
+          index,
           length: self.values.len(),
         }
         .into(),
@@ -138,11 +138,11 @@ impl MutableRowInterface for Row
   }
 }
 
-impl Into<value::Value> for Row
+impl From<Row> for value::Value
 {
-  fn into(self) -> value::Value
+  fn from(v: Row) -> Self
   {
-    value::Value::Array(self.values)
+    value::Value::Array(v.values)
   }
 }
 
@@ -154,6 +154,16 @@ impl FromIterator<value::Value> for Row
   }
 }
 
+impl IntoIterator for Row
+{
+  type Item = value::Value;
+  type IntoIter = <Vec<Self::Item> as IntoIterator>::IntoIter;
+  fn into_iter(self) -> Self::IntoIter
+  {
+    self.values.into_iter()
+  }
+}
+
 pub(crate) trait Header
 {
   fn columns(&self) -> usize;
@@ -443,7 +453,7 @@ impl Iterator for IntoRowIter
     else
     {
       let v: Vec<_> = self.data.by_ref().take(self.columns).collect();
-      if v.len() == 0
+      if v.is_empty()
       {
         None
       }

data/ext/gqliterb/Cargo.toml

@@ -1,44 +1,21 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
 [package]
-edition = "2021"
 name = "gqliterb"
-version = "0.5.3"
-build = false
-autolib = false
-autobins = false
-autoexamples = false
-autotests = false
-autobenches = false
 description = "Crate with the Ruby bindings for GQLite."
-homepage = "https://gqlite.org"
-readme = false
-license = "MIT"
-repository = "https://gitlab.com/gqlite/gqlite"
-
-[package.metadata.release]
-release = false
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+homepage.workspace = true
+repository.workspace = true
 
 [lib]
-name = "gqliterb"
 crate-type = ["cdylib"]
-path = "src/lib.rs"
 
-[dependencies.gqlitedb]
-version = "0.5.3"
-features = []
+[dependencies]
+gqlitedb = { workspace = true }
+magnus = "0.8"
 
-[dependencies.magnus]
-version = "0.7"
+[build-dependencies]
+rb-sys-env = "0.2"
 
-[build-dependencies.rb-sys-env]
-version = "0.2"
+[package.metadata.release]
+release = false

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,7 +206,7 @@ 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(),
@@ -213,7 +218,9 @@ impl Connection
         .path(filename)
         .create(),
     )?;
-    Ok(Self { dbhandle })
+    Ok(Self {
+      dbhandle: std::sync::RwLock::new(Some(dbhandle)),
+    })
   }
   fn execute_oc_query(
     ruby: &Ruby,
@@ -221,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;
   }
 }
 
@@ -262,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,
+}