gqlite 1.2.2 → 1.3.0

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/tests/templates/programs.rs

@@ -243,7 +243,7 @@ pub(crate) fn unwind() -> Program
 pub(crate) fn match_loop() -> Program
 {
   vec![
-    Block::BlockMatch {
+    Block::Match {
       blocks: vec![BlockMatch::MatchEdge {
         instructions: vec![
           Instruction::Push {
@@ -297,7 +297,7 @@ pub(crate) fn match_loop() -> Program
 pub(crate) fn optional_match() -> Program
 {
   vec![
-    Block::BlockMatch {
+    Block::Match {
       blocks: vec![BlockMatch::MatchNode {
         instructions: vec![
           Instruction::Push {
@@ -336,7 +336,7 @@ pub(crate) fn optional_match() -> Program
 pub(crate) fn match_count(function_manager: &functions::Manager) -> Program
 {
   vec![
-    Block::BlockMatch {
+    Block::Match {
       blocks: vec![BlockMatch::MatchNode {
         instructions: vec![
           Instruction::Push {
@@ -387,7 +387,7 @@ pub(crate) fn match_count(function_manager: &functions::Manager) -> Program
 pub(crate) fn aggregation(function_manager: &functions::Manager) -> Program
 {
   vec![
-    Block::BlockMatch {
+    Block::Match {
       blocks: vec![BlockMatch::MatchNode {
         instructions: vec![
           Instruction::Push {

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

@@ -11,6 +11,7 @@ pub(crate) trait RowInterface: Debug
   {
     Ok(self.get(index)?.to_owned())
   }
+  #[cfg(test)]
   fn len(&self) -> usize;
 }
 
@@ -52,7 +53,7 @@ impl Row
     {
       Err(
         InternalError::InvalidIndex {
-          index: index,
+          index,
           length: self.values.len(),
         }
         .into(),
@@ -97,6 +98,7 @@ impl RowInterface for Row
       .into()
     })
   }
+  #[cfg(test)]
   fn len(&self) -> usize
   {
     self.values.len()
@@ -136,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)
   }
 }
 
@@ -152,10 +154,19 @@ 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;
-  fn titles(&self) -> Option<Vec<String>>;
 }
 
 impl Header for usize
@@ -164,10 +175,6 @@ impl Header for usize
   {
     *self
   }
-  fn titles(&self) -> Option<Vec<String>>
-  {
-    None
-  }
 }
 
 impl Header for Vec<String>
@@ -176,10 +183,6 @@ impl Header for Vec<String>
   {
     self.len()
   }
-  fn titles(&self) -> Option<Vec<String>>
-  {
-    Some(self.clone())
-  }
 }
 
 #[derive(Debug)]
@@ -256,12 +259,14 @@ where
     Ok(())
   }
 
+  #[allow(dead_code)]
   pub fn row_count(&self) -> usize
   {
     self.row_count
   }
 
   /// Create a RowView into a specific row
+  #[allow(dead_code)]
   pub fn row_view(&self, row_index: usize) -> Option<RowView<'_>>
   {
     if self.header.columns() == 0 && row_index >= self.row_count
@@ -302,10 +307,6 @@ where
       index: 0,
     }
   }
-  pub(crate) fn first_row(&self) -> Option<RowView>
-  {
-    self.row_view(0)
-  }
   pub(crate) fn remove_first_rows(&mut self, n: usize)
   {
     let n = n * self.header.columns();
@@ -334,6 +335,7 @@ pub(crate) struct RowView<'a>
 
 impl<'a> RowView<'a>
 {
+  #[allow(dead_code)]
   /// Create an owned Row by cloning the values in this row view
   pub fn to_row(&self) -> Row
   {
@@ -341,6 +343,7 @@ impl<'a> RowView<'a>
       values: self.row.to_vec(),
     }
   }
+  #[allow(dead_code)]
   /// Create an owned Row by cloning the values in this row view, and extend it to the given size
   pub fn to_extended_row(&self, length: usize) -> Result<Row>
   {
@@ -363,6 +366,7 @@ impl<'a> RowInterface for RowView<'a>
       .into()
     })
   }
+  #[cfg(test)]
   fn len(&self) -> usize
   {
     self.row.len()
@@ -449,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,43 +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.2"
-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.2"
+[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