gqlite 1.2.0 → 1.2.3

data/ext/gqliterb/vendor/gqlitedb/src/parser/ast.rs

@@ -0,0 +1,611 @@
+use std::{
+  cell::RefCell,
+  collections::{hash_map::Entry, HashMap},
+  sync::atomic::AtomicU64,
+};
+
+use crate::graph;
+
+/// Represent a variable name. Some variable are explicitly created by the parser, if a node/edge should be considered equal and appear in different expression.
+/// For instance `()-[]->()-[]->()` needs the creation of a variable.
+#[derive(Debug, Clone, Eq)]
+pub(crate) struct VariableIdentifier
+{
+  /// Name of the variable, only useful for debug purposes
+  name: String,
+  /// Unique identifier of the variable, the uniqueness is only guaranteed within a compilation unit.
+  id: u64,
+}
+
+impl VariableIdentifier
+{
+  pub(crate) fn name(&self) -> &String
+  {
+    &self.name
+  }
+  pub(crate) fn take_name(self) -> String
+  {
+    self.name
+  }
+}
+
+impl PartialEq for VariableIdentifier
+{
+  fn eq(&self, other: &Self) -> bool
+  {
+    self.id == other.id
+  }
+}
+
+impl std::hash::Hash for VariableIdentifier
+{
+  fn hash<H: std::hash::Hasher>(&self, state: &mut H)
+  {
+    self.id.hash(state);
+  }
+}
+
+#[derive(Default)]
+pub(crate) struct VariableIdentifiers
+{
+  next_id: AtomicU64,
+  identifiers: RefCell<HashMap<String, VariableIdentifier>>,
+}
+
+impl VariableIdentifiers
+{
+  fn next_id(&self) -> u64
+  {
+    self
+      .next_id
+      .fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+  }
+  pub(crate) fn from_name(&self, name: impl Into<String>) -> VariableIdentifier
+  {
+    let name = name.into();
+    match self.identifiers.borrow_mut().entry(name)
+    {
+      Entry::Occupied(entry) => entry.get().clone(),
+      Entry::Vacant(entry) =>
+      {
+        let vn = VariableIdentifier {
+          name: entry.key().clone(),
+          id: self.next_id(),
+        };
+        entry.insert(vn.clone());
+        vn
+      }
+    }
+  }
+  pub(crate) fn from_name_optional(&self, name: Option<String>) -> Option<VariableIdentifier>
+  {
+    name.map(|name| self.from_name(name))
+  }
+  pub(crate) fn anonymous(&self) -> VariableIdentifier
+  {
+    let id = self.next_id();
+    VariableIdentifier {
+      name: format!("anonymous_{}", id),
+      id,
+    }
+  }
+}
+
+#[derive(Debug)]
+pub(crate) enum Statement
+{
+  CreateGraph(CreateGraph),
+  DropGraph(DropGraph),
+  UseGraph(UseGraph),
+  Create(Create),
+  Match(Match),
+  Return(Return),
+  Call(Call),
+  With(With),
+  Unwind(Unwind),
+  Delete(Delete),
+  Update(Update),
+}
+
+macro_rules! create_into_statement {
+  ( $x:tt ) => {
+    impl Into<Statement> for $x
+    {
+      fn into(self) -> Statement
+      {
+        Statement::$x(self)
+      }
+    }
+  };
+}
+
+pub(crate) type Statements = Vec<Statement>;
+pub(crate) type Queries = Vec<Statements>;
+
+#[derive(Debug)]
+pub(crate) struct CreateGraph
+{
+  pub(crate) name: String,
+}
+
+#[derive(Debug)]
+pub(crate) struct DropGraph
+{
+  pub(crate) name: String,
+  pub(crate) if_exists: bool,
+}
+
+#[derive(Debug)]
+pub(crate) struct UseGraph
+{
+  pub(crate) name: String,
+}
+
+#[derive(Debug)]
+pub(crate) struct Create
+{
+  pub(crate) patterns: Vec<Pattern>,
+}
+
+create_into_statement! {Create}
+
+#[derive(Debug)]
+pub(crate) struct Match
+{
+  pub(crate) patterns: Vec<Pattern>,
+  pub(crate) where_expression: Option<Expression>,
+  pub(crate) optional: bool,
+}
+
+create_into_statement! {Match}
+
+#[derive(Debug)]
+pub(crate) struct Return
+{
+  pub(crate) all: bool,
+  pub(crate) expressions: Vec<NamedExpression>,
+  pub(crate) modifiers: Modifiers,
+  pub(crate) where_expression: Option<Expression>,
+}
+
+create_into_statement! {Return}
+
+#[derive(Debug)]
+pub(crate) struct With
+{
+  pub(crate) all: bool,
+  pub(crate) expressions: Vec<NamedExpression>,
+  pub(crate) modifiers: Modifiers,
+  pub(crate) where_expression: Option<Expression>,
+}
+
+create_into_statement! {With}
+
+#[derive(Debug)]
+pub(crate) struct Unwind
+{
+  pub(crate) identifier: VariableIdentifier,
+  pub(crate) expression: Expression,
+}
+
+create_into_statement! {Unwind}
+
+#[derive(Debug)]
+pub(crate) struct Delete
+{
+  pub(crate) detach: bool,
+  pub(crate) expressions: Vec<Expression>,
+}
+
+#[derive(Debug)]
+pub(crate) struct Update
+{
+  pub(crate) updates: Vec<OneUpdate>,
+}
+
+#[derive(Debug)]
+pub(crate) struct Call
+{
+  pub(crate) name: String,
+  pub(crate) arguments: Vec<Expression>,
+}
+
+// Set/remove Statements
+
+#[derive(Debug)]
+pub(crate) enum OneUpdate
+{
+  SetProperty(UpdateProperty),
+  AddProperty(UpdateProperty),
+  RemoveProperty(RemoveProperty),
+  AddLabels(AddRemoveLabels),
+  RemoveLabels(AddRemoveLabels),
+}
+
+#[derive(Debug)]
+pub(crate) struct UpdateProperty
+{
+  pub(crate) target: VariableIdentifier,
+  pub(crate) path: Vec<String>,
+  pub(crate) expression: Expression,
+}
+
+#[derive(Debug)]
+pub(crate) struct RemoveProperty
+{
+  pub(crate) target: VariableIdentifier,
+  pub(crate) path: Vec<String>,
+}
+
+#[derive(Debug)]
+pub(crate) struct AddRemoveLabels
+{
+  pub(crate) target: VariableIdentifier,
+  pub(crate) labels: Vec<String>,
+}
+
+// Modifiers
+
+#[derive(Debug)]
+pub(crate) struct OrderBy
+{
+  pub(crate) expressions: Vec<OrderByExpression>,
+}
+
+#[derive(Default, Debug)]
+pub(crate) struct Modifiers
+{
+  pub(crate) skip: Option<Expression>,
+  pub(crate) limit: Option<Expression>,
+  pub(crate) order_by: Option<OrderBy>,
+}
+
+// Expressions
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) enum Expression
+{
+  Array(Array),
+  FunctionCall(FunctionCall),
+  Map(Map),
+  IndexAccess(Box<IndexAccess>),
+  RangeAccess(Box<RangeAccess>),
+  MemberAccess(Box<MemberAccess>),
+  Parameter(Parameter),
+  Value(Value),
+  Variable(Variable),
+
+  LogicalAnd(Box<LogicalAnd>),
+  LogicalOr(Box<LogicalOr>),
+  LogicalXor(Box<LogicalXor>),
+  RelationalEqual(Box<RelationalEqual>),
+  RelationalDifferent(Box<RelationalDifferent>),
+  RelationalInferior(Box<RelationalInferior>),
+  RelationalSuperior(Box<RelationalSuperior>),
+  RelationalInferiorEqual(Box<RelationalInferiorEqual>),
+  RelationalSuperiorEqual(Box<RelationalSuperiorEqual>),
+  RelationalIn(Box<RelationalIn>),
+  RelationalNotIn(Box<RelationalNotIn>),
+
+  Addition(Box<Addition>),
+  Subtraction(Box<Subtraction>),
+  Multiplication(Box<Multiplication>),
+  Division(Box<Division>),
+  Modulo(Box<Modulo>),
+  Exponent(Box<Exponent>),
+
+  Negation(Box<Negation>),
+  LogicalNegation(Box<LogicalNegation>),
+  IsNull(Box<IsNull>),
+  IsNotNull(Box<IsNotNull>),
+}
+
+// Order By Expression
+
+#[derive(Debug)]
+pub(crate) struct OrderByExpression
+{
+  pub asc: bool,
+  pub expression: Expression,
+}
+
+// Values: CreatePatterns
+
+#[derive(Debug)]
+pub(crate) enum Pattern
+{
+  Node(NodePattern),
+  Edge(EdgePattern),
+  Path(PathPattern),
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct NodePattern
+{
+  pub(crate) variable: Option<VariableIdentifier>,
+  pub(crate) labels: LabelExpression,
+  pub(crate) properties: Option<Expression>,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct EdgePattern
+{
+  pub(crate) variable: Option<VariableIdentifier>,
+  pub(crate) source: NodePattern,
+  pub(crate) destination: NodePattern,
+  pub(crate) directivity: graph::EdgeDirectivity,
+  pub(crate) labels: LabelExpression,
+  pub(crate) properties: Option<Expression>,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct PathPattern
+{
+  pub(crate) variable: VariableIdentifier,
+  pub(crate) edge: EdgePattern,
+}
+
+// Label Expression
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) enum LabelExpression
+{
+  #[allow(dead_code)]
+  Not(Box<LabelExpression>),
+  And(Vec<Box<LabelExpression>>),
+  Or(Vec<Box<LabelExpression>>),
+  String(String),
+  None,
+}
+
+impl LabelExpression
+{
+  pub(crate) fn and(self, rhs: LabelExpression) -> LabelExpression
+  {
+    match self
+    {
+      LabelExpression::None => rhs,
+      LabelExpression::And(mut vec) => match rhs
+      {
+        LabelExpression::None => LabelExpression::And(vec),
+        LabelExpression::And(mut rhs_vec) =>
+        {
+          vec.append(&mut rhs_vec);
+          LabelExpression::And(vec)
+        }
+        other =>
+        {
+          vec.push(other.boxed());
+          LabelExpression::And(vec)
+        }
+      },
+      _ => match rhs
+      {
+        LabelExpression::None => self,
+        LabelExpression::And(mut vec) =>
+        {
+          vec.push(self.boxed());
+          LabelExpression::And(vec)
+        }
+        _ => LabelExpression::And(vec![self.boxed(), rhs.boxed()]),
+      },
+    }
+  }
+  pub(crate) fn or(self, rhs: LabelExpression) -> LabelExpression
+  {
+    match self
+    {
+      LabelExpression::None => rhs,
+      LabelExpression::Or(mut vec) => match rhs
+      {
+        LabelExpression::None => LabelExpression::And(vec),
+        LabelExpression::Or(mut rhs_vec) =>
+        {
+          vec.append(&mut rhs_vec);
+          LabelExpression::Or(vec)
+        }
+        other =>
+        {
+          vec.push(other.boxed());
+          LabelExpression::Or(vec)
+        }
+      },
+      _ => match rhs
+      {
+        LabelExpression::None => self,
+        LabelExpression::Or(mut vec) =>
+        {
+          vec.push(self.boxed());
+          LabelExpression::Or(vec)
+        }
+        _ => LabelExpression::Or(vec![self.boxed(), rhs.boxed()]),
+      },
+    }
+  }
+  pub(crate) fn boxed(self) -> Box<LabelExpression>
+  {
+    Box::new(self)
+  }
+  pub(crate) fn is_all_inclusive(&self) -> bool
+  {
+    match self
+    {
+      LabelExpression::None => true,
+      LabelExpression::And(exprs) => !exprs.iter().any(|f| !f.is_all_inclusive()),
+      LabelExpression::Or(_) => false,
+      LabelExpression::String(_) => true,
+      LabelExpression::Not(_) => false,
+    }
+  }
+  pub(crate) fn is_none(&self) -> bool
+  {
+    match self
+    {
+      LabelExpression::None => true,
+      _ => false,
+    }
+  }
+  pub(crate) fn is_string(&self) -> bool
+  {
+    match self
+    {
+      LabelExpression::String(_) => true,
+      _ => false,
+    }
+  }
+}
+
+// Expressions
+
+macro_rules! create_into_expr {
+  ( $x:tt ) => {
+    impl Into<Expression> for $x
+    {
+      fn into(self) -> Expression
+      {
+        Expression::$x(self)
+      }
+    }
+  };
+}
+
+macro_rules! create_into_boxed_expr {
+  ( $x:tt ) => {
+    impl Into<Expression> for $x
+    {
+      fn into(self) -> Expression
+      {
+        Expression::$x(Box::new(self))
+      }
+    }
+  };
+}
+
+#[derive(Debug)]
+pub(crate) struct NamedExpression
+{
+  pub(crate) identifier: VariableIdentifier,
+  pub(crate) expression: Expression,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct Parameter
+{
+  pub(crate) name: String,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct Variable
+{
+  pub(crate) identifier: VariableIdentifier,
+}
+
+create_into_expr! {Variable}
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct MemberAccess
+{
+  pub(crate) left: Expression,
+  pub(crate) path: Vec<String>,
+}
+
+create_into_boxed_expr! {MemberAccess}
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct IndexAccess
+{
+  pub(crate) left: Expression,
+  pub(crate) index: Expression,
+}
+
+create_into_boxed_expr! {IndexAccess}
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct RangeAccess
+{
+  pub(crate) left: Expression,
+  pub(crate) start: Option<Expression>,
+  pub(crate) end: Option<Expression>,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct FunctionCall
+{
+  pub(crate) name: String,
+  pub(crate) arguments: Vec<Expression>,
+}
+
+create_into_expr! {FunctionCall}
+
+macro_rules! create_binary_op {
+  ( $x:tt ) => {
+    #[derive(Debug, Clone, PartialEq)]
+    pub(crate) struct $x
+    {
+      pub(crate) left: Expression,
+      pub(crate) right: Expression,
+    }
+
+    create_into_boxed_expr! { $x }
+  };
+}
+
+create_binary_op! {LogicalAnd}
+create_binary_op! {LogicalOr}
+create_binary_op! {LogicalXor}
+create_binary_op! {RelationalEqual}
+create_binary_op! {RelationalDifferent}
+create_binary_op! {RelationalInferior}
+create_binary_op! {RelationalSuperior}
+create_binary_op! {RelationalInferiorEqual}
+create_binary_op! {RelationalSuperiorEqual}
+create_binary_op! {RelationalIn}
+create_binary_op! {RelationalNotIn}
+
+create_binary_op! {Addition}
+create_binary_op! {Subtraction}
+create_binary_op! {Multiplication}
+create_binary_op! {Division}
+create_binary_op! {Modulo}
+create_binary_op! {Exponent}
+
+macro_rules! create_unary_op {
+  ( $x:tt ) => {
+    #[derive(Debug, Clone, PartialEq)]
+    pub(crate) struct $x
+    {
+      pub(crate) value: Expression,
+    }
+    create_into_boxed_expr! { $x }
+  };
+}
+
+create_unary_op! {LogicalNegation}
+create_unary_op! {Negation}
+create_unary_op! {IsNull}
+create_unary_op! {IsNotNull}
+
+// Values
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct Value
+{
+  pub(crate) value: crate::value::Value,
+}
+
+create_into_expr! {Value}
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct Map
+{
+  pub(crate) map: Vec<(String, Expression)>,
+}
+
+create_into_expr! {Map}
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct Array
+{
+  pub(crate) array: Vec<Expression>,
+}
+
+create_into_expr! {Array}