gqlite 1.2.3 → 1.3.0

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

@@ -1,6 +1,7 @@
 use crate::{prelude::*, value_table::ColId};
 
 #[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
 pub(crate) enum Instruction
 {
   CreateNodeLiteral
@@ -221,7 +222,7 @@ pub(crate) enum Block
     actions: Vec<CreateAction>,
     variables_size: VariablesSizes,
   },
-  BlockMatch
+  Match
   {
     blocks: Vec<BlockMatch>,
     filter: Instructions,

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

@@ -8,6 +8,8 @@
 
 #![warn(missing_docs)]
 #![deny(warnings)]
+#![allow(clippy::result_large_err)]
+#![allow(clippy::unnecessary_lazy_evaluations)]
 
 mod aggregators;
 #[cfg(feature = "capi")]
@@ -21,7 +23,7 @@ mod graph;
 mod interpreter;
 mod parser;
 mod prelude;
-mod serialize_with;
+mod query_result;
 mod store;
 mod utils;
 mod value;
@@ -31,11 +33,14 @@ mod value_table;
 pub(crate) mod tests;
 
 pub use {
-  connection::Connection,
+  connection::{Backend, Connection},
   error::{CompileTimeError, Error, RunTimeError, StoreError},
-  graph::{Edge, Node, Path},
-  value::{Value, ValueMap, ValueTryIntoRef},
+  graph::{labels, Edge, Node, Path},
+  query_result::QueryResult,
+  value::{array, value_map, Value, ValueMap, ValueTryIntoRef},
 };
 
+pub use graphcore::{table, Table};
+
 /// GQLite Result alias. Usable as a standard `Result<T, E>` or default to gqlite::Error with `Result<T>`
 pub type Result<T, E = error::export::Error> = std::result::Result<T, E>;

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

@@ -60,7 +60,7 @@ impl VariableIdentifiers
       .next_id
       .fetch_add(1, std::sync::atomic::Ordering::Relaxed)
   }
-  pub(crate) fn from_name(&self, name: impl Into<String>) -> VariableIdentifier
+  pub(crate) fn create_variable_from_name(&self, name: impl Into<String>) -> VariableIdentifier
   {
     let name = name.into();
     match self.identifiers.borrow_mut().entry(name)
@@ -77,11 +77,14 @@ impl VariableIdentifiers
       }
     }
   }
-  pub(crate) fn from_name_optional(&self, name: Option<String>) -> Option<VariableIdentifier>
+  pub(crate) fn create_variable_from_name_optional(
+    &self,
+    name: Option<String>,
+  ) -> Option<VariableIdentifier>
   {
-    name.map(|name| self.from_name(name))
+    name.map(|name| self.create_variable_from_name(name))
   }
-  pub(crate) fn anonymous(&self) -> VariableIdentifier
+  pub(crate) fn create_anonymous_variable(&self) -> VariableIdentifier
   {
     let id = self.next_id();
     VariableIdentifier {
@@ -107,13 +110,13 @@ pub(crate) enum Statement
   Update(Update),
 }
 
-macro_rules! create_into_statement {
+macro_rules! create_from_statement {
   ( $x:tt ) => {
-    impl Into<Statement> for $x
+    impl From<$x> for Statement
     {
-      fn into(self) -> Statement
+      fn from(v: $x) -> Statement
       {
-        Statement::$x(self)
+        Statement::$x(v)
       }
     }
   };
@@ -147,7 +150,7 @@ pub(crate) struct Create
   pub(crate) patterns: Vec<Pattern>,
 }
 
-create_into_statement! {Create}
+create_from_statement! {Create}
 
 #[derive(Debug)]
 pub(crate) struct Match
@@ -157,7 +160,7 @@ pub(crate) struct Match
   pub(crate) optional: bool,
 }
 
-create_into_statement! {Match}
+create_from_statement! {Match}
 
 #[derive(Debug)]
 pub(crate) struct Return
@@ -168,7 +171,7 @@ pub(crate) struct Return
   pub(crate) where_expression: Option<Expression>,
 }
 
-create_into_statement! {Return}
+create_from_statement! {Return}
 
 #[derive(Debug)]
 pub(crate) struct With
@@ -179,7 +182,7 @@ pub(crate) struct With
   pub(crate) where_expression: Option<Expression>,
 }
 
-create_into_statement! {With}
+create_from_statement! {With}
 
 #[derive(Debug)]
 pub(crate) struct Unwind
@@ -188,7 +191,7 @@ pub(crate) struct Unwind
   pub(crate) expression: Expression,
 }
 
-create_into_statement! {Unwind}
+create_from_statement! {Unwind}
 
 #[derive(Debug)]
 pub(crate) struct Delete
@@ -263,6 +266,7 @@ pub(crate) struct Modifiers
 // Expressions
 
 #[derive(Debug, Clone, PartialEq)]
+#[allow(clippy::large_enum_variant)]
 pub(crate) enum Expression
 {
   Array(Array),
@@ -351,8 +355,8 @@ pub(crate) enum LabelExpression
 {
   #[allow(dead_code)]
   Not(Box<LabelExpression>),
-  And(Vec<Box<LabelExpression>>),
-  Or(Vec<Box<LabelExpression>>),
+  And(Vec<LabelExpression>),
+  Or(Vec<LabelExpression>),
   String(String),
   None,
 }
@@ -374,7 +378,7 @@ impl LabelExpression
         }
         other =>
         {
-          vec.push(other.boxed());
+          vec.push(other);
           LabelExpression::And(vec)
         }
       },
@@ -383,10 +387,10 @@ impl LabelExpression
         LabelExpression::None => self,
         LabelExpression::And(mut vec) =>
         {
-          vec.push(self.boxed());
+          vec.push(self);
           LabelExpression::And(vec)
         }
-        _ => LabelExpression::And(vec![self.boxed(), rhs.boxed()]),
+        _ => LabelExpression::And(vec![self, rhs]),
       },
     }
   }
@@ -405,7 +409,7 @@ impl LabelExpression
         }
         other =>
         {
-          vec.push(other.boxed());
+          vec.push(other);
           LabelExpression::Or(vec)
         }
       },
@@ -414,17 +418,13 @@ impl LabelExpression
         LabelExpression::None => self,
         LabelExpression::Or(mut vec) =>
         {
-          vec.push(self.boxed());
+          vec.push(self);
           LabelExpression::Or(vec)
         }
-        _ => LabelExpression::Or(vec![self.boxed(), rhs.boxed()]),
+        _ => LabelExpression::Or(vec![self, rhs]),
       },
     }
   }
-  pub(crate) fn boxed(self) -> Box<LabelExpression>
-  {
-    Box::new(self)
-  }
   pub(crate) fn is_all_inclusive(&self) -> bool
   {
     match self
@@ -438,43 +438,35 @@ impl LabelExpression
   }
   pub(crate) fn is_none(&self) -> bool
   {
-    match self
-    {
-      LabelExpression::None => true,
-      _ => false,
-    }
+    matches!(self, LabelExpression::None)
   }
   pub(crate) fn is_string(&self) -> bool
   {
-    match self
-    {
-      LabelExpression::String(_) => true,
-      _ => false,
-    }
+    matches!(self, LabelExpression::String(_))
   }
 }
 
 // Expressions
 
-macro_rules! create_into_expr {
+macro_rules! create_from_expr {
   ( $x:tt ) => {
-    impl Into<Expression> for $x
+    impl From<$x> for Expression
     {
-      fn into(self) -> Expression
+      fn from(v: $x) -> Expression
       {
-        Expression::$x(self)
+        Expression::$x(v)
       }
     }
   };
 }
 
-macro_rules! create_into_boxed_expr {
+macro_rules! create_from_boxed_expr {
   ( $x:tt ) => {
-    impl Into<Expression> for $x
+    impl From<$x> for Expression
     {
-      fn into(self) -> Expression
+      fn from(v: $x) -> Expression
       {
-        Expression::$x(Box::new(self))
+        Expression::$x(Box::new(v))
       }
     }
   };
@@ -499,7 +491,7 @@ pub(crate) struct Variable
   pub(crate) identifier: VariableIdentifier,
 }
 
-create_into_expr! {Variable}
+create_from_expr! {Variable}
 
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct MemberAccess
@@ -508,7 +500,7 @@ pub(crate) struct MemberAccess
   pub(crate) path: Vec<String>,
 }
 
-create_into_boxed_expr! {MemberAccess}
+create_from_boxed_expr! {MemberAccess}
 
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct IndexAccess
@@ -517,7 +509,7 @@ pub(crate) struct IndexAccess
   pub(crate) index: Expression,
 }
 
-create_into_boxed_expr! {IndexAccess}
+create_from_boxed_expr! {IndexAccess}
 
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct RangeAccess
@@ -534,7 +526,7 @@ pub(crate) struct FunctionCall
   pub(crate) arguments: Vec<Expression>,
 }
 
-create_into_expr! {FunctionCall}
+create_from_expr! {FunctionCall}
 
 macro_rules! create_binary_op {
   ( $x:tt ) => {
@@ -545,7 +537,7 @@ macro_rules! create_binary_op {
       pub(crate) right: Expression,
     }
 
-    create_into_boxed_expr! { $x }
+    create_from_boxed_expr! { $x }
   };
 }
 
@@ -575,7 +567,7 @@ macro_rules! create_unary_op {
     {
       pub(crate) value: Expression,
     }
-    create_into_boxed_expr! { $x }
+    create_from_boxed_expr! { $x }
   };
 }
 
@@ -592,7 +584,7 @@ pub(crate) struct Value
   pub(crate) value: crate::value::Value,
 }
 
-create_into_expr! {Value}
+create_from_expr! {Value}
 
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct Map
@@ -600,7 +592,7 @@ pub(crate) struct Map
   pub(crate) map: Vec<(String, Expression)>,
 }
 
-create_into_expr! {Map}
+create_from_expr! {Map}
 
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct Array
@@ -608,4 +600,4 @@ pub(crate) struct Array
   pub(crate) array: Vec<Expression>,
 }
 
-create_into_expr! {Array}
+create_from_expr! {Array}

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/parser/gql.pest

@@ -29,7 +29,7 @@ nothing = { nothing_ident? }
 // fragments
 
 labels       = { ":" ~ label_expression }
-pattern      = { ident? ~ labels? ~ map? }
+pattern      = { ident? ~ labels? ~ (map | parameter)? }
 node_pattern = { "(" ~ pattern ~ ")" }
 
 directed_edge_pattern   = { (")-[" ~ pattern ~ "]->(") | (nothing ~ ")-->(") }

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

@@ -19,7 +19,7 @@ trait TryNext: Iterator
   }
 }
 
-fn remove_hex_prefix<'a>(string: &'a str) -> String
+fn remove_hex_prefix(string: &str) -> String
 {
   if &string[0..1] == "-"
   {
@@ -31,7 +31,7 @@ fn remove_hex_prefix<'a>(string: &'a str) -> String
   }
 }
 
-fn validate_float<'a>(value: f64, text: &'a str) -> Result<f64>
+fn validate_float(value: f64, text: &str) -> Result<f64>
 {
   if value.is_finite()
   {
@@ -67,7 +67,7 @@ impl AstBuilder
     let mut it = pair.into_inner();
     let k = it.try_next()?;
     let v = self.build_expression(it.try_next()?.into_inner())?;
-    return Ok((k.as_str().to_string(), v));
+    Ok((k.as_str().to_string(), v))
   }
 
   fn build_expression(&self, pairs: pest::iterators::Pairs<Rule>) -> Result<ast::Expression>
@@ -338,7 +338,7 @@ impl AstBuilder
             value: value::Value::Float(validate_float(pair.as_str().parse()?, pair.as_str())?),
           })),
           Rule::ident => Ok(ast::Expression::Variable(ast::Variable {
-            identifier: self.var_ids.from_name(pair.as_str()),
+            identifier: self.var_ids.create_variable_from_name(pair.as_str()),
           })),
           Rule::parameter => Ok(ast::Expression::Parameter(ast::Parameter {
             name: pair.as_str().to_string(),
@@ -402,7 +402,7 @@ impl AstBuilder
                   if i == 0
                   {
                     ast::Expression::Variable(ast::Variable {
-                      identifier: self.var_ids.from_name(pair.as_str()),
+                      identifier: self.var_ids.create_variable_from_name(pair.as_str()),
                     })
                   }
                   else
@@ -532,13 +532,15 @@ impl AstBuilder
           {
             let expr = inner.try_next()?;
             Ok(ast::NamedExpression {
-              identifier: self.var_ids.from_name(expr.as_str().trim()),
+              identifier: self.var_ids.create_variable_from_name(expr.as_str().trim()),
               expression: self.build_expression(expr.into_inner())?,
             })
           }
           2 => Ok({
             let expression = self.build_expression(inner.try_next()?.into_inner())?;
-            let identifier = self.var_ids.from_name(inner.try_next()?.as_str());
+            let identifier = self
+              .var_ids
+              .create_variable_from_name(inner.try_next()?.as_str());
             ast::NamedExpression {
               identifier,
               expression,
@@ -563,28 +565,28 @@ impl AstBuilder
     }
   }
 
-  fn build_labels(&self, pair: pest::iterators::Pair<Rule>) -> Result<ast::LabelExpression>
+  fn build_labels(pair: pest::iterators::Pair<Rule>) -> Result<ast::LabelExpression>
   {
     match pair.as_rule()
     {
-      Rule::labels => self.build_labels(pair.into_inner().try_next()?),
+      Rule::labels => Self::build_labels(pair.into_inner().try_next()?),
       Rule::label_alternative =>
       {
         let mut r = ast::LabelExpression::None;
-        let mut inner = pair.into_inner();
-        while let Some(next) = inner.next()
+        let inner = pair.into_inner();
+        for next in inner
         {
-          r = r.or(self.build_labels(next)?);
+          r = r.or(Self::build_labels(next)?);
         }
         Ok(r)
       }
       Rule::label_inclusion =>
       {
         let mut r = ast::LabelExpression::None;
-        let mut inner = pair.into_inner();
-        while let Some(next) = inner.next()
+        let inner = pair.into_inner();
+        for next in inner
         {
-          r = r.and(self.build_labels(next)?);
+          r = r.and(Self::build_labels(next)?);
         }
         Ok(r)
       }
@@ -616,9 +618,15 @@ impl AstBuilder
         }
         Rule::labels =>
         {
-          labels = self.build_labels(pair)?;
+          labels = Self::build_labels(pair)?;
         }
         Rule::map => properties = Some(self.build_map(pair)?),
+        Rule::parameter =>
+        {
+          properties = Some(ast::Expression::Parameter(ast::Parameter {
+            name: pair.as_str().to_string(),
+          }))
+        }
         unknown_expression =>
         {
           return Err(
@@ -632,7 +640,7 @@ impl AstBuilder
       }
     }
     Ok(ast::NodePattern {
-      variable: self.var_ids.from_name_optional(variable),
+      variable: self.var_ids.create_variable_from_name_optional(variable),
       labels,
       properties,
     })
@@ -662,9 +670,15 @@ impl AstBuilder
         }
         Rule::labels =>
         {
-          labels = self.build_labels(pair)?;
+          labels = Self::build_labels(pair)?;
         }
         Rule::map => properties = Some(self.build_map(pair)?),
+        Rule::parameter =>
+        {
+          properties = Some(ast::Expression::Parameter(ast::Parameter {
+            name: pair.as_str().to_string(),
+          }))
+        }
         unknown_expression =>
         {
           return Err(
@@ -681,7 +695,7 @@ impl AstBuilder
     match edge_rule
     {
       Rule::directed_edge_pattern => Ok(ast::EdgePattern {
-        variable: self.var_ids.from_name_optional(variable),
+        variable: self.var_ids.create_variable_from_name_optional(variable),
         source: source_node,
         destination: destination_node,
         directivity: graph::EdgeDirectivity::Directed,
@@ -689,7 +703,7 @@ impl AstBuilder
         properties,
       }),
       Rule::reversed_edge_pattern => Ok(ast::EdgePattern {
-        variable: self.var_ids.from_name_optional(variable),
+        variable: self.var_ids.create_variable_from_name_optional(variable),
         source: destination_node,
         destination: source_node,
         directivity: graph::EdgeDirectivity::Directed,
@@ -705,7 +719,7 @@ impl AstBuilder
           })?;
         }
         Ok(ast::EdgePattern {
-          variable: self.var_ids.from_name_optional(variable),
+          variable: self.var_ids.create_variable_from_name_optional(variable),
           source: source_node,
           destination: destination_node,
           directivity: graph::EdgeDirectivity::Undirected,
@@ -765,7 +779,7 @@ impl AstBuilder
 
           if it.peek().is_some() && destination_node.variable.is_none()
           {
-            destination_node.variable = Some(self.var_ids.anonymous());
+            destination_node.variable = Some(self.var_ids.create_anonymous_variable());
           }
 
           let edge_pattern = self.build_edge_pattern(
@@ -793,7 +807,7 @@ impl AstBuilder
           allow_undirected_edge,
         )?;
         vec.push(ast::Pattern::Path(ast::PathPattern {
-          variable: self.var_ids.from_name(variable),
+          variable: self.var_ids.create_variable_from_name(variable),
           edge: edge_pattern,
         }));
       }
@@ -1004,7 +1018,9 @@ impl AstBuilder
 
               let mut pair = pair.into_inner();
               let mut pair_left = pair.try_next()?.into_inner();
-              let target = self.var_ids.from_name(pair_left.try_next()?.as_str());
+              let target = self
+                .var_ids
+                .create_variable_from_name(pair_left.try_next()?.as_str());
               let path = pair_left.map(|el| el.as_str().to_string()).collect();
               let expression = self.build_expression(pair.try_next()?.into_inner())?;
               let update_property = ast::UpdateProperty {
@@ -1024,7 +1040,9 @@ impl AstBuilder
             Rule::set_label_expression =>
             {
               let mut pair = pair.into_inner();
-              let target = self.var_ids.from_name(pair.try_next()?.as_str());
+              let target = self
+                .var_ids
+                .create_variable_from_name(pair.try_next()?.as_str());
               let labels = pair.map(|el| el.as_str().to_string()).collect();
               updates.push(ast::OneUpdate::AddLabels(ast::AddRemoveLabels {
                 target,
@@ -1049,7 +1067,9 @@ impl AstBuilder
             Rule::remove_member_access =>
             {
               let mut pair = pair.into_inner();
-              let target = self.var_ids.from_name(pair.try_next()?.as_str());
+              let target = self
+                .var_ids
+                .create_variable_from_name(pair.try_next()?.as_str());
               let path = pair.map(|el| el.as_str().to_string()).collect();
               updates.push(ast::OneUpdate::RemoveProperty(ast::RemoveProperty {
                 target,
@@ -1059,7 +1079,9 @@ impl AstBuilder
             Rule::set_label_expression =>
             {
               let mut pair = pair.into_inner();
-              let target = self.var_ids.from_name(pair.try_next()?.as_str());
+              let target = self
+                .var_ids
+                .create_variable_from_name(pair.try_next()?.as_str());
               let labels = pair.map(|el| el.as_str().to_string()).collect();
               updates.push(ast::OneUpdate::RemoveLabels(ast::AddRemoveLabels {
                 target,
@@ -1082,7 +1104,7 @@ impl AstBuilder
           .collect::<Vec<&str>>()
           .join(".");
         Ok(ast::Statement::Call(ast::Call {
-          name: name,
+          name,
           arguments: Default::default(),
         }))
       }

data/ext/gqlitedb/src/parser.rs

@@ -0,0 +1,4 @@
+pub(crate) mod ast;
+pub(crate) mod parser_impl;
+
+pub(crate) use parser_impl::parse;

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

@@ -1,8 +1,9 @@
 pub(crate) use crate::{
   aggregators, compiler, consts,
   error::{self, CompileTimeError, InternalError, RunTimeError, StoreError},
-  functions, graph, interpreter, parser, serialize_with, store, utils, value, value_table, Error,
-  Result,
+  functions, graph, interpreter, parser, query_result, store, utils, value,
+  value::ValueExt as _,
+  value_table, Error, Result,
 };
 
 pub(crate) use error::export::Error as ErrorType;

data/ext/gqlitedb/src/query_result.rs

@@ -0,0 +1,88 @@
+use graphcore::value_map;
+use itertools::Itertools as _;
+
+use crate::error::InternalError;
+
+/// Hold the result of executing a query.
+#[derive(Debug, PartialEq, Clone)]
+#[allow(clippy::large_enum_variant)]
+pub enum QueryResult
+{
+  /// No results are returned by the query
+  Empty,
+  /// A table is returned by the query
+  Table(graphcore::Table),
+  /// Many tables are returned by the query. Happpen if multiple queries are executed at the same time.
+  Array(Vec<QueryResult>),
+  /// A value is returned
+  Value(graphcore::Value),
+}
+
+impl QueryResult
+{
+  /// Convert this query result into a value.
+  pub fn into_value(self) -> graphcore::Value
+  {
+    match self {
+      QueryResult::Empty => graphcore::Value::Null,
+      QueryResult::Value(v) => v,
+      QueryResult::Table(t) => t.into(),
+      QueryResult::Array(qr) => value_map!("type" => "results", "results" => qr.into_iter().map(|x| x.into_value()).collect::<Vec<graphcore::Value>>()).into()
+    }
+  }
+  /// Try convert into table
+  pub fn try_into_table(self) -> Result<graphcore::Table, InternalError>
+  {
+    self.try_into()
+  }
+}
+
+impl From<graphcore::Value> for QueryResult
+{
+  fn from(value: graphcore::Value) -> Self
+  {
+    QueryResult::Value(value)
+  }
+}
+
+impl From<graphcore::Table> for QueryResult
+{
+  fn from(table: graphcore::Table) -> Self
+  {
+    QueryResult::Table(table)
+  }
+}
+
+impl TryInto<graphcore::Table> for QueryResult
+{
+  type Error = InternalError;
+  fn try_into(self) -> Result<graphcore::Table, Self::Error>
+  {
+    match self
+    {
+      QueryResult::Table(tbl) => Ok(tbl),
+      _ => Err(InternalError::InvalidQueryResultCast),
+    }
+  }
+}
+
+impl std::fmt::Display for QueryResult
+{
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
+  {
+    match self
+    {
+      QueryResult::Empty => write!(f, "empty"),
+      QueryResult::Value(v) => write!(f, "{}", v),
+      QueryResult::Array(arr) => write!(f, "[{}]", arr.iter().map(|x| x.to_string()).join(", ")),
+      QueryResult::Table(t) => write!(
+        f,
+        "[{};{}]",
+        t.headers().join(", "),
+        t.row_iter()
+          .map(|x| x.iter().map(|x| x.to_string()).join(", "))
+          .join(";")
+      ),
+    }
+  }
+}