gqlite 1.5.0 → 1.7.0

data/ext/gqlitedb/src/value.rs

@@ -1,10 +1,10 @@
 mod compare;
 mod contains;
 
-pub(crate) use compare::{compare, Ordering};
-pub(crate) use contains::{contains, ContainResult};
+pub(crate) use compare::{Ordering, compare};
+pub(crate) use contains::{ContainResult, contains};
 
-pub use graphcore::{array, value_map, TimeStamp, Value, ValueMap, ValueTryIntoRef};
+pub use graphcore::{DType, Tensor, TimeStamp, Value, ValueMap, ValueTryIntoRef, array, value_map};
 
 pub(crate) trait ValueExt
 {
@@ -115,6 +115,36 @@ impl ValueExt for Value
         Value::Float(rhs) => orderability_float(lhs, rhs),
         _ => std::cmp::Ordering::Greater,
       },
+      Value::Tensor(lhs) => match rhs
+      {
+        Value::Null | Value::Key(..) => std::cmp::Ordering::Less,
+        Value::Tensor(rhs) =>
+        {
+          let dc = (lhs.dtype() as u8).cmp(&(rhs.dtype() as u8));
+          if dc != std::cmp::Ordering::Equal
+          {
+            return dc;
+          }
+          let sc = lhs.shape().cmp(rhs.shape());
+          if sc != std::cmp::Ordering::Equal
+          {
+            return sc;
+          }
+          lhs.as_bytes().cmp(rhs.as_bytes())
+        }
+        Value::Array(rhs) =>
+        {
+          let left_arr = Value::Array(
+            lhs
+              .to_f32_vec()
+              .into_iter()
+              .map(|f| Value::Float(f as f64))
+              .collect(),
+          );
+          left_arr.orderability(&Value::Array(rhs.clone()))
+        }
+        _ => std::cmp::Ordering::Greater,
+      },
       Value::Boolean(lhs) => match rhs
       {
         Value::Null | Value::Key(..) | Value::Integer(..) | Value::Float(..) =>
@@ -145,7 +175,7 @@ impl ValueExt for Value
         Value::TimeStamp(rhs) => lhs.cmp(rhs),
         _ => std::cmp::Ordering::Greater,
       },
-      Value::Path(lhs) => match rhs
+      Value::SinglePath(lhs) => match rhs
       {
         Value::Null
         | Value::Key(..)
@@ -154,7 +184,7 @@ impl ValueExt for Value
         | Value::Boolean(..)
         | Value::String(..)
         | Value::TimeStamp(..) => std::cmp::Ordering::Less,
-        Value::Path(rhs) =>
+        Value::SinglePath(rhs) =>
         {
           match orderability_map(lhs.source().properties(), rhs.source().properties())
           {
@@ -172,6 +202,97 @@ impl ValueExt for Value
             o => o,
           }
         }
+        Value::Path(rhs) =>
+        {
+          if rhs.elements_count() == 1
+          {
+            match orderability_map(lhs.source().properties(), rhs.source().properties())
+            {
+              std::cmp::Ordering::Equal =>
+              {
+                match orderability_map(lhs.properties(), rhs.elements()[0].0.properties())
+                {
+                  std::cmp::Ordering::Equal => orderability_map(
+                    lhs.destination().properties(),
+                    rhs.elements()[0].1.properties(),
+                  ),
+                  o => o,
+                }
+              }
+              o => o,
+            }
+          }
+          else
+          {
+            // rhs has more elements
+            std::cmp::Ordering::Less
+          }
+        }
+        _ => std::cmp::Ordering::Greater,
+      },
+      Value::Path(lhs) => match rhs
+      {
+        Value::Null
+        | Value::Key(..)
+        | Value::Integer(..)
+        | Value::Float(..)
+        | Value::Boolean(..)
+        | Value::String(..)
+        | Value::TimeStamp(..) => std::cmp::Ordering::Less,
+        Value::SinglePath(rhs) =>
+        {
+          if lhs.elements_count() == 1
+          {
+            match orderability_map(lhs.source().properties(), rhs.source().properties())
+            {
+              std::cmp::Ordering::Equal =>
+              {
+                match orderability_map(lhs.elements()[0].0.properties(), rhs.properties())
+                {
+                  std::cmp::Ordering::Equal => orderability_map(
+                    lhs.elements()[0].1.properties(),
+                    rhs.destination().properties(),
+                  ),
+                  o => o,
+                }
+              }
+              o => o,
+            }
+          }
+          else
+          {
+            // lhs has more elements
+            std::cmp::Ordering::Greater
+          }
+        }
+        Value::Path(rhs) =>
+        {
+          match orderability_map(lhs.source().properties(), rhs.source().properties())
+          {
+            std::cmp::Ordering::Equal =>
+            {
+              for ((lhs_edge, lhs_destination), (rhs_edge, rhs_destination)) in
+                lhs.elements().iter().zip(rhs.elements().iter())
+              {
+                match orderability_map(lhs_edge.properties(), rhs_edge.properties())
+                {
+                  std::cmp::Ordering::Equal => match orderability_map(
+                    lhs_destination.properties(),
+                    rhs_destination.properties(),
+                  )
+                  {
+                    std::cmp::Ordering::Equal =>
+                    {}
+                    o => return o,
+                  },
+                  o => return o,
+                }
+              }
+              std::cmp::Ordering::Equal
+            }
+            o => o,
+          }
+        }
         _ => std::cmp::Ordering::Greater,
       },
       Value::Array(lhs) => match rhs
@@ -183,7 +304,9 @@ impl ValueExt for Value
         | Value::Boolean(..)
         | Value::String(..)
         | Value::TimeStamp(..)
-        | Value::Path(..) => std::cmp::Ordering::Less,
+        | Value::SinglePath(..)
+        | Value::Path(..)
+        | Value::Tensor(..) => std::cmp::Ordering::Less,
         Value::Array(rhs) => lhs
           .iter()
           .zip(rhs.iter())
@@ -201,8 +324,10 @@ impl ValueExt for Value
         | Value::Boolean(..)
         | Value::String(..)
         | Value::TimeStamp(..)
+        | Value::SinglePath(..)
         | Value::Path(..)
-        | Value::Array(..) => std::cmp::Ordering::Less,
+        | Value::Array(..)
+        | Value::Tensor(..) => std::cmp::Ordering::Less,
         Value::Edge(rhs) => orderability_map(lhs.properties(), rhs.properties()),
         _ => std::cmp::Ordering::Greater,
       },
@@ -215,8 +340,10 @@ impl ValueExt for Value
         | Value::Boolean(..)
         | Value::String(..)
         | Value::TimeStamp(..)
+        | Value::SinglePath(..)
         | Value::Path(..)
         | Value::Array(..)
+        | Value::Tensor(..)
         | Value::Edge(..) => std::cmp::Ordering::Less,
         Value::Node(rhs) => orderability_map(lhs.properties(), rhs.properties()),
         _ => std::cmp::Ordering::Greater,
@@ -230,8 +357,10 @@ impl ValueExt for Value
         | Value::Boolean(..)
         | Value::String(..)
         | Value::TimeStamp(..)
+        | Value::SinglePath(..)
         | Value::Path(..)
         | Value::Array(..)
+        | Value::Tensor(..)
         | Value::Edge(..)
         | Value::Node(..) => std::cmp::Ordering::Less,
         Value::Map(rhs) => orderability_map(lhs, rhs),

data/ext/gqlitedb/templates/sql/postgres/metadata_delete.sql

@@ -0,0 +1 @@
+DELETE FROM gqlite_metadata WHERE name = $1

data/ext/gqlitedb/templates/sql/postgres/node_select.sql

@@ -4,7 +4,7 @@ WHERE
     -- Filter by key list (if not empty)
     {% if let Some(keys_var) = keys_var %}
     (
-        nodes.node_key = ANY( ${{ keys_var }}::uuid[] )
+        node_key = ANY(${{ keys_var }})
     )
     {% else %}
     TRUE

data/ext/gqlitedb/templates/sql/sqlite/metadata_delete.sql

@@ -0,0 +1 @@
+DELETE FROM gqlite_metadata WHERE name = ?

data/ext/gqliterb/src/lib.rs

@@ -2,13 +2,12 @@ use std::fmt::Display;
 
 use gqlitedb::TimeStamp;
 use magnus::{
-  function, method,
+  Error, ExceptionClass, Integer, IntoValue, RModule, Ruby, Symbol, function, method,
   prelude::*,
   r_array,
   r_hash::{self, ForEach},
   scan_args,
   value::Lazy,
-  Error, ExceptionClass, Integer, IntoValue, RModule, Ruby, Symbol,
 };
 
 static MODULE: Lazy<RModule> = Lazy::new(|ruby| ruby.define_module("GQLite").unwrap());
@@ -125,8 +124,12 @@ fn integer_from_u128(ruby: &Ruby, i: u128) -> Result<Integer, Error>
 fn node_to_rhash(ruby: &Ruby, node: gqlitedb::Node) -> Result<magnus::Value, Error>
 {
   let r_hash = ruby.hash_new();
-  let (key, labels, properties) = node.unpack();
+  let (graph_name, key, labels, properties) = node.unpack();
   r_hash.aset("type", "node")?;
+  if let Some(graph_name) = graph_name
+  {
+    r_hash.aset("graph_name", graph_name)?;
+  }
   r_hash.aset("key", integer_from_u128(ruby, key.into())?)?;
   r_hash.aset("labels", labels)?;
   r_hash.aset("properties", to_rhash(ruby, properties)?)?;
@@ -136,19 +139,28 @@ fn node_to_rhash(ruby: &Ruby, node: gqlitedb::Node) -> Result<magnus::Value, Err
 fn edge_to_rhash(ruby: &Ruby, edge: gqlitedb::Edge) -> Result<magnus::Value, Error>
 {
   let r_hash = ruby.hash_new();
-  let (key, labels, properties) = edge.unpack();
+  let (graph_name, key, labels, properties) = edge.unpack();
   r_hash.aset("type", "edge")?;
+  if let Some(graph_name) = graph_name
+  {
+    r_hash.aset("graph_name", graph_name)?;
+  }
   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_with(ruby))
 }
 
-fn path_to_rhash(ruby: &Ruby, path: gqlitedb::Path) -> Result<magnus::Value, Error>
+fn single_path_to_rhash(ruby: &Ruby, path: gqlitedb::SinglePath) -> Result<magnus::Value, Error>
 {
   let r_hash = ruby.hash_new();
-  let (key, source, labels, properties, destination) = path.unpack();
-  r_hash.aset("type", "path")?;
+  let (source, edge, destination) = path.unpack();
+  r_hash.aset("type", "single_path")?;
+  let (graph_name, key, labels, properties) = edge.unpack();
+  if let Some(graph_name) = graph_name
+  {
+    r_hash.aset("graph_name", graph_name)?;
+  }
   r_hash.aset("key", integer_from_u128(ruby, key.into())?)?;
   r_hash.aset("labels", labels)?;
   r_hash.aset("properties", to_rhash(ruby, properties)?)?;
@@ -157,6 +169,29 @@ fn path_to_rhash(ruby: &Ruby, path: gqlitedb::Path) -> Result<magnus::Value, Err
   Ok(r_hash.into_value_with(ruby))
 }
 
+fn path_to_rhash(ruby: &Ruby, path: gqlitedb::Path) -> Result<magnus::Value, Error>
+{
+  let r_hash = ruby.hash_new();
+  let (source, elements) = path.unpack();
+  r_hash.aset("type", "path")?;
+  r_hash.aset("source", node_to_rhash(ruby, source)?)?;
+
+  let r_elements = ruby.ary_new();
+
+  for el in elements.into_iter().map(|(edge, destination)| {
+    let r_hash_element = ruby.hash_new();
+    r_hash_element.aset("edge", edge_to_rhash(ruby, edge)?)?;
+    r_hash_element.aset("destination", node_to_rhash(ruby, destination)?)?;
+    Ok::<_, Error>(r_hash_element)
+  })
+  {
+    r_elements.push(el?)?;
+  }
+
+  r_hash.aset("elements", r_elements)?;
+  Ok(r_hash.into_value_with(ruby))
+}
+
 fn to_rvalue(ruby: &Ruby, val: gqlitedb::Value) -> Result<magnus::Value, Error>
 {
   match val
@@ -172,7 +207,17 @@ fn to_rvalue(ruby: &Ruby, val: gqlitedb::Value) -> Result<magnus::Value, Error>
     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)?),
+    gqlitedb::Value::SinglePath(p) => Ok(single_path_to_rhash(ruby, *p)?),
+    gqlitedb::Value::Path(p) => Ok(path_to_rhash(ruby, *p)?),
+    gqlitedb::Value::Tensor(t) =>
+    {
+      // Represent tensor as an array of floats in Ruby
+      let arr = t
+        .into_iter()
+        .map(|f| gqlitedb::Value::Float(f as f64))
+        .collect();
+      Ok(to_rarray(ruby, arr)?.into_value_with(ruby))
+    }
   }
 }
 

data/ext/gqlparser/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "gqlparser"
+description = "GQL Parsing library, including GQLS."
+readme = "README.MD"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+homepage.workspace = true
+repository.workspace = true
+
+[dependencies]
+ccutils = { workspace = true, features = ["static_asserts"] }
+graphcore = { workspace = true }
+indexmap = { workspace = true }
+logos = "0.16"
+nom = "8"
+nom-language = "0.1"
+thiserror = { workspace = true }
+
+[dev-dependencies]
+divan.workspace = true
+
+[[bench]]
+name = "pokec_divan"
+harness = false

data/ext/gqlparser/README.MD

@@ -0,0 +1,9 @@
+gqlparser
+=========
+
+Home of the future GQL parser for [GQLite](http://gqlite.org). Currently only supporter GQL-Schemas, a GQLite extension to GQL for expressing Graph constraints.
+
+GQL-Schemas
+-----------
+
+`Schema Validation and Evolution for Graph Databases`, Bonifati et al, International Conference on Conceptual Modeling, 2019 [arxiv](https://arxiv.org/pdf/1902.06427).

data/ext/gqlparser/benches/pokec_divan.rs

@@ -0,0 +1,34 @@
+fn main()
+{
+  if std::fs::exists("gqlite_bench_data").unwrap()
+  {
+    std::process::Command::new("git")
+      .arg("pull")
+      .spawn()
+      .unwrap()
+      .wait()
+      .unwrap();
+  }
+  else
+  {
+    std::process::Command::new("git")
+      .arg("clone")
+      .arg("https://gitlab.com/auksys/data/gqlite_bench.git")
+      .arg("gqlite_bench_data")
+      .spawn()
+      .unwrap()
+      .wait()
+      .unwrap();
+  }
+  // Run registered benchmarks.
+  divan::main();
+}
+
+// Parse the small `pokec` dataset.
+#[divan::bench()]
+fn parse_small_pokec()
+{
+  let filename = "gqlite_bench_data/pokec_small_import.cypher";
+  let import_query = std::fs::read_to_string(filename).unwrap();
+  let _ = gqlparser::oc::parse_oc_query(&import_query);
+}

data/ext/gqlparser/src/common.rs

@@ -0,0 +1,69 @@
+use nom::{
+  AsChar, Emit, IResult, Input, Mode as _, OutputM, OutputMode, PResult, Parser,
+  character::complete::multispace0,
+  error::{FromExternalError, ParseError},
+  sequence::preceded,
+};
+use nom_language::error::VerboseError;
+
+pub(crate) type VResult<I, O> = IResult<I, O, VerboseError<I>>;
+
+pub(crate) fn ws0<I, E: ParseError<I>, F>(
+  f: F,
+) -> impl Parser<I, Output = <F as Parser<I>>::Output, Error = E>
+where
+  F: Parser<I, Error = E>,
+  I: Input,
+  <I as Input>::Item: AsChar,
+{
+  preceded(multispace0, f)
+}
+
+pub fn map_res_failure<I: Clone, O, E: ParseError<I> + FromExternalError<I, E2>, E2, F, G>(
+  parser: F,
+  g: G,
+) -> impl Parser<I, Output = O, Error = E>
+where
+  F: Parser<I, Error = E>,
+  G: FnMut(<F as Parser<I>>::Output) -> Result<O, E2>,
+{
+  MapResFailure { f: parser, g }
+}
+
+/// Implementation of `Parser::map_res`
+pub struct MapResFailure<F, G>
+{
+  f: F,
+  g: G,
+}
+
+impl<I, O2, E2, F, G> Parser<I> for MapResFailure<F, G>
+where
+  I: Clone,
+  <F as Parser<I>>::Error: FromExternalError<I, E2>,
+  F: Parser<I>,
+  G: FnMut(<F as Parser<I>>::Output) -> Result<O2, E2>,
+{
+  type Output = O2;
+  type Error = <F as Parser<I>>::Error;
+
+  fn process<OM: OutputMode>(&mut self, i: I) -> PResult<OM, I, Self::Output, Self::Error>
+  {
+    let (input, o1) = self
+      .f
+      .process::<OutputM<Emit, OM::Error, OM::Incomplete>>(i.clone())?;
+
+    match (self.g)(o1)
+    {
+      Ok(o2) => Ok((input, OM::Output::bind(|| o2))),
+      Err(e) => Err(nom::Err::Failure(
+        <F as Parser<I>>::Error::from_external_error(i, nom::error::ErrorKind::MapRes, e),
+      )),
+    }
+  }
+}
+
+pub(crate) fn fixed_digit<const N: usize>(input: &str) -> VResult<&str, &str>
+{
+  nom::bytes::complete::take_while_m_n(N, N, |c: char| c.is_ascii_digit())(input)
+}

data/ext/gqlparser/src/gqls/ast.rs

@@ -0,0 +1,69 @@
+//! AST module
+
+use indexmap::IndexMap;
+
+use crate::gqls::prelude::*;
+
+/// Abstract Syntax Tree of the schema
+#[derive(Debug)]
+pub struct Ast
+{
+  /// List of elements
+  pub elements: IndexMap<String, PropertiesDefinition>,
+  /// List of nodes
+  pub nodes: Vec<Node>,
+  /// List of edges
+  pub edges: Vec<Edge>,
+  /// List of named constrained type definitions
+  pub constrained_types: IndexMap<String, ConstrainedTypeDef>,
+}
+
+/// Represent an element
+#[derive(Debug)]
+pub struct PropertiesDefinition
+{
+  /// List of parament element
+  pub parents: Vec<String>,
+  /// Properties of the element
+  pub properties: IndexMap<String, Property>,
+}
+
+/// Represent a node
+#[derive(Debug)]
+pub struct Node
+{
+  /// Main label of the node, used as identifer
+  pub label: String,
+}
+
+/// Represent an edge
+#[derive(Debug)]
+pub struct Edge
+{
+  /// Identifier of the source
+  pub source: String,
+  /// Main label of the edge, used as identifer
+  pub label: String,
+  /// Identifier of the destination
+  pub destination: String,
+}
+
+/// Either a base scalar type, or a reference to another named constrained type.
+#[derive(Debug, Clone, PartialEq)]
+pub enum TypeRef
+{
+  /// A base scalar type
+  Base(LiteralBaseType),
+  /// A reference to another named constrained type
+  Named(String),
+}
+
+/// A `type Name = TypeRef: Constraint?;` declaration, pre-resolution.
+#[derive(Debug, Clone)]
+pub struct ConstrainedTypeDef
+{
+  /// Base type or reference to another named type
+  pub base: TypeRef,
+  /// Optional constraint on this type
+  pub constraint: Option<Constraint>,
+}

data/ext/gqlparser/src/gqls/constraint.rs

@@ -0,0 +1,79 @@
+//! Constraint data model: literal values and the constraints that can be
+//! placed on them.
+use graphcore::Value;
+
+use super::{Error, Result, properties::LiteralBaseType};
+
+/// The base type this value belongs to.
+pub fn base_type(value: &Value) -> Result<LiteralBaseType>
+{
+  match value
+  {
+    Value::Boolean(_) => Ok(LiteralBaseType::Boolean),
+    Value::Integer(_) => Ok(LiteralBaseType::Integer),
+    Value::Float(_) => Ok(LiteralBaseType::Float),
+    Value::String(_) => Ok(LiteralBaseType::String),
+    Value::TimeStamp(_) => Ok(LiteralBaseType::TimeStamp),
+    _ => Err(Error::InvalidValue),
+  }
+}
+
+/// A constraint tree, restricting the set of values a property may take.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Constraint
+{
+  In(Vec<Value>),
+  Eq(Value),
+  Ne(Value),
+  LessThan(Value),
+  LessOrEqual(Value),
+  GreaterThan(Value),
+  GreaterOrEqual(Value),
+  And(Vec<Constraint>),
+  Or(Vec<Constraint>),
+  Not(Box<Constraint>),
+}
+
+#[cfg(test)]
+mod tests
+{
+  use super::*;
+
+  #[test]
+  fn value_base_type_matches_variant()
+  {
+    assert_eq!(
+      base_type(&Value::Boolean(true)).unwrap(),
+      LiteralBaseType::Boolean
+    );
+    assert_eq!(
+      base_type(&Value::Integer(1)).unwrap(),
+      LiteralBaseType::Integer
+    );
+    assert_eq!(
+      base_type(&Value::Float(1.0)).unwrap(),
+      LiteralBaseType::Float
+    );
+    assert_eq!(
+      base_type(&Value::String("x".into())).unwrap(),
+      LiteralBaseType::String
+    );
+    assert_eq!(
+      base_type(&Value::TimeStamp(graphcore::TimeStamp::now())).unwrap(),
+      LiteralBaseType::TimeStamp
+    );
+  }
+
+  #[test]
+  fn nested_constraint_tree_clones_and_compares_equal()
+  {
+    let c = Constraint::And(vec![
+      Constraint::Or(vec![
+        Constraint::GreaterThan(Value::Integer(10)),
+        Constraint::LessThan(Value::Integer(0)),
+      ]),
+      Constraint::Not(Box::new(Constraint::Eq(Value::Integer(5)))),
+    ]);
+    assert_eq!(c, c.clone());
+  }
+}

data/ext/gqlparser/src/gqls/error.rs

@@ -0,0 +1,22 @@
+#[derive(thiserror::Error, Debug, PartialEq, Clone)]
+#[allow(missing_docs)]
+#[non_exhaustive]
+pub enum Error
+{
+  #[error("ParseError: {0}.")]
+  Parse(String),
+  #[error("IncompleteParsingError: '{0}' was not parsed.")]
+  IncompleteParsing(String),
+  #[error("MultiTypeCannotBeConvertedToSingle")]
+  MultiTypeCannotBeConvertedToSingle,
+  #[error("InvalidType")]
+  InvalidType,
+  #[error("InvalidValue")]
+  InvalidValue,
+  /// A type reference points to an undefined type.
+  #[error("undefined type '{0}'")]
+  UndefinedType(String),
+  /// A cycle was detected in the type hierarchy.
+  #[error("cycle detected: {}", .0.join(" -> "))]
+  Cycle(Vec<String>),
+}