gqlite 1.2.2 → 1.3.0

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

@@ -6,6 +6,7 @@ pub(super) struct Head {}
 
 impl Head
 {
+  #[allow(clippy::ptr_arg)]
   fn call_impl(array: &Vec<value::Value>) -> FResult<value::Value>
   {
     Ok(
@@ -34,20 +35,17 @@ impl Keys
     match container
     {
       value::Value::Map(obj) => Ok(obj.keys().map(|x| x.to_owned().into()).collect()),
-      value::Value::Node(n) => Ok(n.properties.keys().map(|x| x.to_owned().into()).collect()),
-      value::Value::Edge(e) => Ok(e.properties.keys().map(|x| x.to_owned().into()).collect()),
-      _ =>
-      {
-        return Err(
-          RunTimeError::InvalidArgument {
-            function_name: "keys",
-            index: 0,
-            expected_type: "map, node or relationship",
-            value: format!("{:?}", container),
-          }
-          .into(),
-        )
-      }
+      value::Value::Node(n) => Ok(n.properties().keys().map(|x| x.to_owned().into()).collect()),
+      value::Value::Edge(e) => Ok(e.properties().keys().map(|x| x.to_owned().into()).collect()),
+      _ => Err(
+        RunTimeError::InvalidArgument {
+          function_name: "keys",
+          index: 0,
+          expected_type: "map, node or relationship",
+          value: format!("{:?}", container),
+        }
+        .into(),
+      ),
     }
   }
 }
@@ -88,18 +86,15 @@ impl super::FunctionTrait for Size
       value::Value::Array(arr) => Ok((arr.len() as i64).into()),
       value::Value::Map(obj) => Ok((obj.len() as i64).into()),
       value::Value::Path(..) => Ok(1.into()),
-      _ =>
-      {
-        return Err(
-          RunTimeError::InvalidArgument {
-            function_name: "size",
-            index: 0,
-            expected_type: "array or map",
-            value: format!("{:?}", container),
-          }
-          .into(),
-        )
-      }
+      _ => Err(
+        RunTimeError::InvalidArgument {
+          function_name: "size",
+          index: 0,
+          expected_type: "array or map",
+          value: format!("{:?}", container),
+        }
+        .into(),
+      ),
     }
   }
   fn validate_arguments(&self, _: Vec<ExpressionType>) -> Result<ExpressionType>

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

@@ -1,6 +1,6 @@
 use crate::prelude::*;
 
-use super::{FResult, FunctionTypeTrait};
+use super::FResult;
 
 #[derive(Debug, Default)]
 pub(super) struct Type {}
@@ -10,9 +10,9 @@ impl Type
   fn call_impl(edge: &graph::Edge) -> FResult<String>
   {
     edge
-      .labels
+      .labels()
       .first()
-      .ok_or_else(|| RunTimeError::MissingEdgeLabel)
+      .ok_or(RunTimeError::MissingEdgeLabel)
       .map(|v| v.to_owned())
   }
 }

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

@@ -2,7 +2,7 @@ use rand::Rng;
 
 use crate::prelude::*;
 
-use super::{FResult, FunctionTypeTrait};
+use super::FResult;
 
 #[derive(Debug, Default)]
 pub(super) struct Rand {}
@@ -24,7 +24,7 @@ impl Ceil
 {
   fn call_impl(value: &f64) -> FResult<f64>
   {
-    Ok(value.ceil() as f64)
+    Ok(value.ceil())
   }
 }
 
@@ -37,7 +37,7 @@ impl Floor
 {
   fn call_impl(value: &f64) -> FResult<f64>
   {
-    Ok(value.floor() as f64)
+    Ok(value.floor())
   }
 }
 

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

@@ -1,6 +1,6 @@
 use crate::prelude::*;
 
-use super::{FResult, FunctionTypeTrait};
+use super::FResult;
 
 #[derive(Debug, Default)]
 pub(super) struct Labels {}
@@ -9,7 +9,7 @@ impl Labels
 {
   fn call_impl(node: &graph::Node) -> FResult<Vec<String>>
   {
-    Ok(node.labels.to_owned())
+    Ok(node.labels().to_owned())
   }
 }
 

data/ext/gqlitedb/src/functions/path.rs

@@ -0,0 +1,75 @@
+use super::ExpressionType;
+use crate::{functions::FResult, prelude::*};
+
+#[derive(Debug, Default)]
+pub(super) struct Length {}
+
+impl super::FunctionTrait for Length
+{
+  fn call(&self, arguments: Vec<value::Value>) -> crate::Result<value::Value>
+  {
+    let container = arguments
+      .first()
+      .ok_or_else(|| RunTimeError::InvalidNumberOfArguments {
+        function_name: "length",
+        got: arguments.len(),
+        expected: 1,
+      })?;
+
+    match container
+    {
+      value::Value::Array(arr) => Ok((arr.len() as i64).into()),
+      value::Value::Map(obj) => Ok((obj.len() as i64).into()),
+      value::Value::Path(..) => Ok(1.into()),
+      _ => Err(
+        RunTimeError::InvalidArgument {
+          function_name: "length",
+          index: 0,
+          expected_type: "array or map",
+          value: format!("{:?}", container),
+        }
+        .into(),
+      ),
+    }
+  }
+  fn validate_arguments(&self, _: Vec<ExpressionType>) -> crate::Result<ExpressionType>
+  {
+    Ok(ExpressionType::Variant)
+  }
+  fn is_deterministic(&self) -> bool
+  {
+    true
+  }
+}
+
+super::declare_function!(length, Length, custom_trait);
+
+#[derive(Debug, Default)]
+pub(super) struct Nodes {}
+
+impl Nodes
+{
+  fn call_impl(path: &graph::Path) -> FResult<Vec<graph::Node>>
+  {
+    Ok(vec![path.source().clone(), path.destination().clone()])
+  }
+}
+
+super::declare_function!(nodes, Nodes, call_impl(crate::graph::Path) -> Vec<graph::Node>);
+
+#[derive(Debug, Default)]
+pub(super) struct Edges {}
+
+impl Edges
+{
+  fn call_impl(path: &graph::Path) -> FResult<Vec<graph::Edge>>
+  {
+    Ok(vec![graph::Edge::new(
+      path.key(),
+      path.labels().clone(),
+      path.properties().clone(),
+    )])
+  }
+}
+
+super::declare_function!(edges, Edges, call_impl(crate::graph::Path) -> Vec<graph::Edge>);

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

@@ -59,7 +59,7 @@ impl ToInteger
   }
 }
 
-super::declare_function!(toInteger, ToInteger, call_impl(crate::value::Value) -> i64);
+super::declare_function!(tointeger, ToInteger, call_impl(crate::value::Value) -> i64);
 
 #[derive(Debug, Default)]
 pub(super) struct Properties {}
@@ -70,8 +70,8 @@ impl Properties
   {
     match value
     {
-      value::Value::Node(n) => Ok(n.properties.to_owned()),
-      value::Value::Edge(e) => Ok(e.properties.to_owned()),
+      value::Value::Node(n) => Ok(n.properties().to_owned()),
+      value::Value::Edge(e) => Ok(e.properties().to_owned()),
       value::Value::Map(m) => Ok(m.to_owned()),
       _ => Err(RunTimeError::InvalidArgument {
         function_name: "properties",

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

@@ -25,4 +25,4 @@ impl ToString
   }
 }
 
-super::declare_function!(toString, ToString, call_impl(crate::value::Value) -> String, validate_args(ExpressionType::Boolean | ExpressionType::Integer | ExpressionType::Float | ExpressionType::String | ExpressionType::Null));
+super::declare_function!(tostring, ToString, call_impl(crate::value::Value) -> String, validate_args(ExpressionType::Boolean | ExpressionType::Integer | ExpressionType::Float | ExpressionType::String | ExpressionType::Null));

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

@@ -1,6 +1,6 @@
 use crate::prelude::*;
 
-use super::{ExpressionType, FResult, FunctionTypeTrait};
+use super::{ExpressionType, FResult};
 
 #[derive(Debug, Default)]
 pub(super) struct HasLabel {}
@@ -11,8 +11,8 @@ impl HasLabel
   {
     match value
     {
-      value::Value::Edge(e) => Ok(e.labels.contains(label)),
-      value::Value::Node(n) => Ok(n.labels.contains(label)),
+      value::Value::Edge(e) => Ok(e.labels().contains(label)),
+      value::Value::Node(n) => Ok(n.labels().contains(label)),
       _ => Err(RunTimeError::InvalidArgument {
         function_name: "has_label",
         index: 0,
@@ -45,11 +45,11 @@ impl super::FunctionTrait for HasLabels
     }
     else
     {
-      let mut it = arguments.into_iter();
+      let mut it = arguments.iter();
       let labels = match it.next().unwrap()
       {
-        value::Value::Edge(e) => e.labels,
-        value::Value::Node(n) => n.labels,
+        value::Value::Edge(e) => e.labels(),
+        value::Value::Node(n) => n.labels(),
         value::Value::Null => return Ok(value::Value::Null),
         _ => Err(RunTimeError::InvalidArgument {
           function_name: "has_labels",
@@ -64,7 +64,7 @@ impl super::FunctionTrait for HasLabels
         {
           value::Value::String(l) =>
           {
-            if !labels.contains(&l)
+            if !labels.contains(l)
             {
               return Ok(false.into());
             }

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

@@ -133,56 +133,53 @@ impl Manager
     Self {
       inner: ManagerInner {
         functions: HashMap::from([
-          containers::Head::new(),
-          containers::Keys::new(),
-          containers::Range::new(),
-          containers::Size::new(),
-          edge::Type::new(),
-          math::Ceil::new(),
-          math::Floor::new(),
-          math::Rand::new(),
-          node::Labels::new(),
-          path::Length::new(),
-          scalar::Coalesce::new(),
-          scalar::Properties::new(),
-          scalar::ToInteger::new(),
-          string::ToString::new(),
-          value::HasLabel::new(),
-          value::HasLabels::new(),
+          containers::Head::create(),
+          containers::Keys::create(),
+          containers::Range::create(),
+          containers::Size::create(),
+          edge::Type::create(),
+          math::Ceil::create(),
+          math::Floor::create(),
+          math::Rand::create(),
+          node::Labels::create(),
+          path::Length::create(),
+          path::Nodes::create(),
+          path::Edges::create(),
+          scalar::Coalesce::create(),
+          scalar::Properties::create(),
+          scalar::ToInteger::create(),
+          string::ToString::create(),
+          value::HasLabel::create(),
+          value::HasLabels::create(),
         ]),
         aggregators: aggregators::init_aggregators(),
       }
       .into(),
     }
   }
-  pub(crate) fn get_function<E: error::GenericErrors>(
-    &self,
-    name: impl Into<String>,
-  ) -> Result<Function>
+  pub(crate) fn get_function<E: error::GenericErrors>(&self, name: &str) -> Result<Function>
   {
-    let name = name.into();
     Ok(
       self
         .inner
         .read()?
         .functions
-        .get(&name)
+        .get(&name.to_lowercase())
         .ok_or_else(|| E::unknown_function(name).into())?
         .clone(),
     )
   }
   pub(crate) fn get_aggregator<E: error::GenericErrors>(
     &self,
-    name: impl Into<String>,
+    name: &str,
   ) -> Result<aggregators::Aggregator>
   {
-    let name = name.into();
     Ok(
       self
         .inner
         .read()?
         .aggregators
-        .get(&name)
+        .get(&name.to_lowercase())
         .ok_or_else(|| E::unknown_function(name).into())?
         .clone(),
     )
@@ -190,13 +187,13 @@ impl Manager
   pub(crate) fn is_deterministic(&self, name: impl Into<String>) -> Result<bool>
   {
     let name = name.into();
-    let fun = self.get_function::<crate::error::CompileTimeError>(name.clone());
+    let fun = self.get_function::<crate::error::CompileTimeError>(&name);
     match fun
     {
       Ok(fun) => Ok(fun.is_deterministic()),
       Err(_) =>
       {
-        self.get_aggregator::<crate::error::CompileTimeError>(name)?;
+        self.get_aggregator::<crate::error::CompileTimeError>(&name)?;
         Ok(false)
       }
     }
@@ -213,12 +210,12 @@ impl Manager
   ) -> Result<ExpressionType>
   {
     let name = name.into();
-    let fun = self.get_function::<crate::error::CompileTimeError>(name.clone());
+    let fun = self.get_function::<crate::error::CompileTimeError>(&name);
     match fun
     {
       Ok(fun) => fun.validate_arguments(arguments),
       Err(_) => self
-        .get_aggregator::<crate::error::CompileTimeError>(name)?
+        .get_aggregator::<crate::error::CompileTimeError>(&name)?
         .validate_arguments(arguments),
     }
   }
@@ -288,6 +285,7 @@ macro_rules! default_validate_ {
       -> crate::Result<$crate::compiler::expression_analyser::ExpressionType>
     {
       // TODO
+      use $crate::functions::FunctionTypeTrait;
       Ok(<$ret_type>::result_type())
     }
   };
@@ -325,7 +323,7 @@ macro_rules! declare_function_ {
   ($function_name: ident, $type_name: ty, $f_name: ident (  $( $arg_type: ty $(,)? )* ) -> $ret_type: ty, $allow_null: expr, $validator: block ) => {
     impl $type_name
     {
-      pub(super) fn new() -> (String, crate::functions::Function)
+      pub(super) fn create() -> (String, crate::functions::Function)
       {
         (
           stringify!($function_name).to_string(),
@@ -391,7 +389,7 @@ macro_rules! declare_function {
   ($function_name: ident, $type_name: ty, custom_trait ) => {
     impl $type_name
     {
-      pub(super) fn new() -> (String, crate::functions::Function)
+      pub(super) fn create() -> (String, crate::functions::Function)
       {
         (
           stringify!($function_name).to_string(),

data/ext/gqlitedb/src/graph.rs

@@ -0,0 +1,11 @@
+pub(crate) use graphcore::SinglePath;
+pub use graphcore::{Edge, Key, Node, SinglePath as Path};
+
+pub use graphcore::labels;
+
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum EdgeDirectivity
+{
+  Undirected,
+  Directed,
+}