gqlite 1.2.2 → 1.3.0

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>
@@ -197,6 +197,13 @@ impl AstBuilder
           }
           .into(),
         ),
+        Rule::exponent => Ok(
+          ast::Exponent {
+            left: lhs?,
+            right: rhs?,
+          }
+          .into(),
+        ),
         Rule::or => Ok(
           ast::LogicalOr {
             left: lhs?,
@@ -331,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(),
@@ -360,10 +367,25 @@ impl AstBuilder
                 .collect::<Result<_>>()?,
             }))
           }
-          Rule::count_star => Ok(ast::Expression::FunctionCall(ast::FunctionCall {
-            name: "count".into(),
-            arguments: vec![ast::Expression::Value(ast::Value { value: 0.into() })],
-          })),
+          Rule::function_star =>
+          {
+            let mut it = pair.into_inner();
+            let function_name = it
+              .next()
+              .ok_or_else(|| error::InternalError::MissingFunctionName)?
+              .as_str();
+            if function_name.to_lowercase() != "count"
+            {
+              Err(error::CompileTimeError::UnknownFunction {
+                name: function_name.to_owned(),
+              })?;
+            }
+
+            Ok(ast::Expression::FunctionCall(ast::FunctionCall {
+              name: "count".into(),
+              arguments: vec![ast::Expression::Value(ast::Value { value: 0.into() })],
+            }))
+          }
           Rule::parenthesised_expression =>
           {
             let mut it = pair.into_inner();
@@ -380,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
@@ -510,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,
@@ -541,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)
       }
@@ -594,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(
@@ -610,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,
     })
@@ -640,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(
@@ -659,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,
@@ -667,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,
@@ -683,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,
@@ -743,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(
@@ -771,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,
         }));
       }
@@ -874,6 +910,14 @@ impl AstBuilder
       Rule::create_graph_statement => Ok(ast::Statement::CreateGraph(ast::CreateGraph {
         name: self.build_ident(&mut pair.into_inner())?,
       })),
+      Rule::drop_graph_statement => Ok(ast::Statement::DropGraph(ast::DropGraph {
+        name: self.build_ident(&mut pair.into_inner())?,
+        if_exists: false,
+      })),
+      Rule::drop_graph_if_exists_statement => Ok(ast::Statement::DropGraph(ast::DropGraph {
+        name: self.build_ident(&mut pair.into_inner())?,
+        if_exists: true,
+      })),
       Rule::use_graph_statement => Ok(ast::Statement::UseGraph(ast::UseGraph {
         name: self.build_ident(&mut pair.into_inner())?,
       })),
@@ -974,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 {
@@ -994,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,
@@ -1019,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,
@@ -1029,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,
@@ -1052,9 +1104,8 @@ impl AstBuilder
           .collect::<Vec<&str>>()
           .join(".");
         Ok(ast::Statement::Call(ast::Call {
-          name: name,
+          name,
           arguments: Default::default(),
-          yield_: Default::default(),
         }))
       }
       unknown_expression => Err(
@@ -1086,7 +1137,8 @@ pub(crate) fn parse(input: &str) -> Result<ast::Queries>
     .op(
       Op::infix(Rule::multiplication, Assoc::Left)
         | Op::infix(Rule::division, Assoc::Left)
-        | Op::infix(Rule::modulo, Assoc::Left),
+        | Op::infix(Rule::modulo, Assoc::Left)
+        | Op::infix(Rule::exponent, Assoc::Left),
     )
     .op(Op::prefix(Rule::not) | Op::prefix(Rule::negation))
     .op(

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(";")
+      ),
+    }
+  }
+}