gqlite 1.2.3 → 1.3.1

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

@@ -20,6 +20,7 @@ fn unknown_variable_error(name: &ast::VariableIdentifier) -> ErrorType
 //    \_/ \__,_|_|  |_|\__,_|_.__/|_|\___|
 
 #[derive(Debug, Clone)]
+#[allow(clippy::large_enum_variant)]
 pub(crate) enum VariableContent
 {
   Node(ast::NodePattern),
@@ -137,14 +138,14 @@ impl VariablesManager
   {
     identifier
       .as_ref()
-      .map_or(false, |identifier| self.variables.contains_key(&identifier))
+      .is_some_and(|identifier| self.variables.contains_key(identifier))
   }
   /// Get the index of the variable in the row of variables
   pub(crate) fn get_variable_index(&self, identifier: &ast::VariableIdentifier) -> Result<usize>
   {
     self
       .variables
-      .get(&identifier)
+      .get(identifier)
       .ok_or_else(|| unknown_variable_error(identifier))
       .map(|x| x.col_id)
   }
@@ -175,7 +176,7 @@ impl VariablesManager
     var_id.as_ref().map_or(Ok(false), |name| {
       self
         .variables
-        .get(&name)
+        .get(name)
         .ok_or_else(|| unknown_variable_error(name))
         .map(|x| x.is_set)
     })
@@ -190,7 +191,7 @@ impl VariablesManager
     {
       self
         .variables
-        .get_mut(&var_id)
+        .get_mut(var_id)
         .ok_or_else(|| unknown_variable_error(var_id))
         .map(|x| x.is_set = true)
     }
@@ -205,7 +206,7 @@ impl VariablesManager
     expression_type: ExpressionType,
   ) -> Result<()>
   {
-    if self.variables.contains_key(&var_id)
+    if self.variables.contains_key(var_id)
     {
       Err(
         CompileTimeError::VariableAlreadyBound {
@@ -228,7 +229,7 @@ impl VariablesManager
   {
     if let Some(var_id) = &node.variable
     {
-      if let Some(var) = self.variables.get(&var_id)
+      if let Some(var) = self.variables.get(var_id)
       {
         match var.variable_type
         {
@@ -236,7 +237,7 @@ impl VariablesManager
           {
             VariableContent::Node(var_node) =>
             {
-              if (!node.labels.is_none() || !node.properties.is_none())
+              if (!node.labels.is_none() || node.properties.is_some())
                 && (node.labels != var_node.labels || node.properties != var_node.properties)
               {
                 Err(
@@ -271,7 +272,7 @@ impl VariablesManager
       {
         if let Some(props) = &node.properties
         {
-          expression_analyser::Analyser::new(&self, &self.function_manager).analyse(&props)?;
+          expression_analyser::Analyser::new(self, &self.function_manager).analyse(props)?;
         }
         self.variables.insert(
           var_id.clone(),
@@ -291,7 +292,7 @@ impl VariablesManager
     self.validate_node(&edge.destination)?;
     if let Some(var_id) = &edge.variable
     {
-      if let Some(var) = self.variables.get(&var_id)
+      if let Some(var) = self.variables.get(var_id)
       {
         match var.content
         {
@@ -313,7 +314,7 @@ impl VariablesManager
       {
         if let Some(props) = &edge.properties
         {
-          expression_analyser::Analyser::new(&self, &self.function_manager).analyse(&props)?;
+          expression_analyser::Analyser::new(self, &self.function_manager).analyse(props)?;
         }
         self.variables.insert(
           var_id.clone(),
@@ -333,7 +334,7 @@ impl VariablesManager
   {
     if let Some(var_id) = &node.variable
     {
-      if let Some(var) = self.variables.get(&var_id)
+      if let Some(var) = self.variables.get(var_id)
       {
         match var.variable_type
         {
@@ -341,7 +342,7 @@ impl VariablesManager
           {
             VariableContent::Node(var_node) =>
             {
-              if (!node.labels.is_none() || !node.properties.is_none())
+              if (!node.labels.is_none() || node.properties.is_some())
                 && (node.labels != var_node.labels || node.properties != var_node.properties)
               {
                 Err(
@@ -388,7 +389,7 @@ impl VariablesManager
   {
     if let Some(var_id) = &edge.variable
     {
-      if let Some(var) = self.variables.get(&var_id)
+      if let Some(var) = self.variables.get(var_id)
       {
         match var.variable_type
         {
@@ -396,7 +397,7 @@ impl VariablesManager
           {
             VariableContent::Edge(var_edge) =>
             {
-              if (!edge.labels.is_none() || !edge.properties.is_none())
+              if (!edge.labels.is_none() || edge.properties.is_some())
                 && (var_edge.labels != edge.labels || var_edge.properties != edge.properties)
               {
                 Err(
@@ -474,7 +475,7 @@ impl VariablesManager
     {
       self.validate_node(&edge.destination)?;
     }
-    if is_create || !self.is_valid_existing_edge(&edge)?
+    if is_create || !self.is_valid_existing_edge(edge)?
     {
       self.validate_edge(edge)?;
     }
@@ -507,7 +508,7 @@ impl VariablesManager
     named_expression: &ast::NamedExpression,
   ) -> Result<usize>
   {
-    let expression_info = expression_analyser::Analyser::new(&self, &self.function_manager)
+    let expression_info = expression_analyser::Analyser::new(self, &self.function_manager)
       .analyse(&named_expression.expression)?;
     let col_id = self
       .variables
@@ -529,7 +530,7 @@ impl VariablesManager
     {
       let mut var = self
         .variables
-        .remove(&var_id)
+        .remove(var_id)
         .ok_or_else(|| unknown_variable_error(var_id))?;
       var.col_id = col_id;
       new_variables.insert(var_id.clone(), var.mark_set());
@@ -539,7 +540,7 @@ impl VariablesManager
   }
   pub(crate) fn analyse(&mut self, statement: &ast::Statement) -> Result<()>
   {
-    if self.variables.iter().any(|(_, var)| var.is_set != true)
+    if self.variables.iter().any(|(_, var)| !var.is_set)
     {
       return Err(
         InternalError::NotAllVariablesAreSet {
@@ -570,22 +571,17 @@ impl VariablesManager
       {
         for pattern in create.patterns.iter()
         {
-          match &pattern
+          if let ast::Pattern::Node(n) = &pattern
           {
-            ast::Pattern::Node(n) =>
+            if self.has_variable(&n.variable)
             {
-              if self.has_variable(&n.variable)
-              {
-                return Err(
-                  CompileTimeError::VariableAlreadyBound {
-                    name: n.variable.clone().unwrap().name().clone(),
-                  }
-                  .into(),
-                );
-              }
+              return Err(
+                CompileTimeError::VariableAlreadyBound {
+                  name: n.variable.clone().unwrap().name().clone(),
+                }
+                .into(),
+              );
             }
-            _ =>
-            {}
           }
           self.analyse_pattern(pattern, true)?;
         }

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

@@ -19,6 +19,14 @@ macro_rules! compile_binary_op {
   };
 }
 
+struct CompiledReturnWith
+{
+  variables: Vec<(String, RWExpression)>,
+  filter: Instructions,
+  modifiers: Modifiers,
+  variables_sizes: VariablesSizes,
+}
+
 struct Compiler
 {
   function_manager: functions::Manager,
@@ -52,7 +60,7 @@ impl Compiler
   ) -> Result<()>
   {
     expression_analyser::Analyser::new(&self.variables_manager, &self.function_manager)
-      .analyse(&expression)?;
+      .analyse(expression)?;
 
     let expr = match expression
     {
@@ -83,7 +91,7 @@ impl Compiler
             self.compile_expression(
               function_call
                 .arguments
-                .get(0)
+                .first()
                 .ok_or(error::InternalError::MissingAggregationArgument)?,
               &mut argument_instructions,
               aggregations,
@@ -141,7 +149,7 @@ impl Compiler
           self.compile_expression(v, instructions, aggregations)?;
           keys.push(k.to_owned());
         }
-        Instruction::CreateMap { keys: keys }
+        Instruction::CreateMap { keys }
       }
       ast::Expression::MemberAccess(member_access) =>
       {
@@ -328,33 +336,32 @@ impl Compiler
       .mark_variables_as_set(&node.variable)?;
     self.compile_optional_expression(&node.properties, instructions)?;
     let mut labels = Default::default();
-    self.compile_labels_expression(&mut labels, &node.labels)?;
+    Self::compile_labels_expression(&mut labels, &node.labels)?;
     instructions.push(Instruction::CreateNodeLiteral { labels });
     Ok(())
   }
 
   fn compile_labels_expression(
-    &mut self,
     labels: &mut Vec<String>,
     label_expressions: &ast::LabelExpression,
   ) -> Result<()>
   {
-    match &label_expressions
+    match label_expressions
     {
-      &ast::LabelExpression::And(expressions) =>
+      ast::LabelExpression::And(expressions) =>
       {
         for expr in expressions.iter()
         {
-          self.compile_labels_expression(labels, &expr)?;
+          Self::compile_labels_expression(labels, expr)?;
         }
         Ok(())
       }
-      &ast::LabelExpression::String(label) =>
+      ast::LabelExpression::String(label) =>
       {
         labels.push(label.to_owned());
         Ok(())
       }
-      &ast::LabelExpression::None => Ok(()),
+      ast::LabelExpression::None => Ok(()),
       _ => Err(
         InternalError::InvalidCreateLabels {
           context: "compile_create_labels",
@@ -366,21 +373,20 @@ impl Compiler
 
   // Assume top of the stack contains an edge or node
   fn compile_filter_labels(
-    &mut self,
     instructions: &mut Instructions,
     label_expressions: &ast::LabelExpression,
     has_label_function: &functions::Function,
   ) -> Result<()>
   {
-    match &label_expressions
+    match label_expressions
     {
-      &ast::LabelExpression::And(expressions) =>
+      ast::LabelExpression::And(expressions) =>
       {
         instructions.push(Instruction::Push { value: true.into() });
         instructions.push(Instruction::Swap);
         for expr in expressions.iter()
         {
-          self.compile_filter_labels(instructions, expr, has_label_function)?;
+          Self::compile_filter_labels(instructions, expr, has_label_function)?;
           // stack contains (a: bool) (b: labels) (c: bool)
           instructions.push(Instruction::InverseRot3);
           // stack contains (c: bool) (a: bool) (b: labels)
@@ -391,7 +397,7 @@ impl Compiler
         }
         Ok(())
       }
-      &ast::LabelExpression::Or(expressions) =>
+      ast::LabelExpression::Or(expressions) =>
       {
         instructions.push(Instruction::Push {
           value: false.into(),
@@ -399,7 +405,7 @@ impl Compiler
         instructions.push(Instruction::Swap);
         for expr in expressions.iter()
         {
-          self.compile_filter_labels(instructions, expr, has_label_function)?;
+          Self::compile_filter_labels(instructions, expr, has_label_function)?;
           // stack contains (a: bool) (b: labels) (c: bool)
           instructions.push(Instruction::InverseRot3);
           // stack contains (c: bool) (a: bool) (b: labels)
@@ -410,13 +416,13 @@ impl Compiler
         }
         Ok(())
       }
-      &ast::LabelExpression::Not(expr) =>
+      ast::LabelExpression::Not(expr) =>
       {
-        self.compile_filter_labels(instructions, expr, has_label_function)?;
+        Self::compile_filter_labels(instructions, expr, has_label_function)?;
         instructions.push(Instruction::NotUnaryOperator);
         Ok(())
       }
-      &ast::LabelExpression::String(label) =>
+      ast::LabelExpression::String(label) =>
       {
         instructions.push(Instruction::Duplicate);
         instructions.push(Instruction::Push {
@@ -428,7 +434,7 @@ impl Compiler
         });
         Ok(())
       }
-      &ast::LabelExpression::None =>
+      ast::LabelExpression::None =>
       {
         instructions.push(Instruction::Push { value: true.into() });
         Ok(())
@@ -436,10 +442,7 @@ impl Compiler
     }
   }
 
-  fn compile_create_patterns(
-    &mut self,
-    patterns: &Vec<crate::parser::ast::Pattern>,
-  ) -> Result<Block>
+  fn compile_create_patterns(&mut self, patterns: &[crate::parser::ast::Pattern]) -> Result<Block>
   {
     let actions = patterns.iter().map(|c| {
       let mut instructions = Instructions::new();
@@ -505,7 +508,7 @@ impl Compiler
             Err(CompileTimeError::NoSingleRelationshipType)?;
           }
           let mut labels = Default::default();
-          self.compile_labels_expression(&mut labels, &edge.labels)?;
+          Self::compile_labels_expression(&mut labels, &edge.labels)?;
           instructions.push(Instruction::CreateEdgeLiteral { labels });
         }
         crate::parser::ast::Pattern::Path(_) =>
@@ -538,7 +541,7 @@ impl Compiler
     let mut labels = Default::default();
     if node.labels.is_all_inclusive()
     {
-      self.compile_labels_expression(&mut labels, &node.labels)?;
+      Self::compile_labels_expression(&mut labels, &node.labels)?;
     }
     else
     {
@@ -555,7 +558,7 @@ impl Compiler
       let has_label_function = self
         .function_manager
         .get_function::<CompileTimeError>("has_label")?;
-      self.compile_filter_labels(filter, &node.labels, &has_label_function)?;
+      Self::compile_filter_labels(filter, &node.labels, &has_label_function)?;
       filter.push(Instruction::Rot3);
       filter.push(Instruction::AndBinaryOperator);
       filter.push(Instruction::Swap);
@@ -634,14 +637,14 @@ impl Compiler
       let mut labels = Default::default();
       if edge.labels.is_all_inclusive()
       {
-        self.compile_labels_expression(&mut labels, &edge.labels)?;
+        Self::compile_labels_expression(&mut labels, &edge.labels)?;
       }
       else
       {
         let has_label_function = self
           .function_manager
           .get_function::<CompileTimeError>("has_label")?;
-        self.compile_filter_labels(&mut filter, &edge.labels, &has_label_function)?;
+        Self::compile_filter_labels(&mut filter, &edge.labels, &has_label_function)?;
         filter.push(Instruction::Rot3);
         filter.push(Instruction::AndBinaryOperator);
         filter.push(Instruction::Swap);
@@ -690,7 +693,7 @@ impl Compiler
       .mark_variables_as_set(&path_variable)?;
     // Create block
     Ok(BlockMatch::MatchEdge {
-      instructions: instructions,
+      instructions,
       left_variable: self
         .variables_manager
         .get_variable_index_option(&source_variable)?,
@@ -709,15 +712,10 @@ impl Compiler
   fn compile_return_with(
     &mut self,
     all: bool,
-    expressions: &Vec<ast::NamedExpression>,
+    expressions: &[ast::NamedExpression],
     where_expression: &Option<ast::Expression>,
     modifiers: &ast::Modifiers,
-  ) -> Result<(
-    Vec<(String, RWExpression)>,
-    Instructions,
-    Modifiers,
-    VariablesSizes,
-  )>
+  ) -> Result<CompiledReturnWith>
   {
     let mut variables = Vec::<(ast::VariableIdentifier, RWExpression)>::new();
     let mut filter = Default::default();
@@ -755,7 +753,7 @@ impl Compiler
           .into(),
         );
       }
-      let col_id = self.variables_manager.analyse_named_expression(&e)?;
+      let col_id = self.variables_manager.analyse_named_expression(e)?;
       variables.push((
         e.identifier.clone(),
         RWExpression {
@@ -778,8 +776,8 @@ impl Compiler
       self.compile_expression(where_expression, &mut filter, &mut None)?;
     }
 
-    let modifiers = self.compile_modifiers(&modifiers)?;
-    let variables_size = self.variables_size();
+    let modifiers = self.compile_modifiers(modifiers)?;
+    let variables_sizes = self.variables_size();
     self
       .variables_manager
       .keep_variables(variables.iter().map(|(n, _)| n))?;
@@ -788,12 +786,17 @@ impl Compiler
       .into_iter()
       .map(|(var_id, e)| (var_id.take_name(), e))
       .collect();
-    Ok((variables, filter, modifiers, variables_size))
+    Ok(CompiledReturnWith {
+      variables,
+      filter,
+      modifiers,
+      variables_sizes,
+    })
   }
 
   fn compile_match_patterns(
     &mut self,
-    patterns: &Vec<crate::parser::ast::Pattern>,
+    patterns: &[crate::parser::ast::Pattern],
     where_expression: &Option<crate::parser::ast::Expression>,
     optional: bool,
   ) -> Result<Block>
@@ -811,7 +814,7 @@ impl Compiler
           .variables_manager
           .mark_variables_as_set(&node.variable)?;
         Ok(BlockMatch::MatchNode {
-          instructions: instructions,
+          instructions,
           variable: self
             .variables_manager
             .get_variable_index_option(&node.variable)?,
@@ -820,7 +823,7 @@ impl Compiler
       }
       crate::parser::ast::Pattern::Edge(edge) =>
       {
-        self.compile_match_edge(None, &edge, is_single_match, &mut edge_variables)
+        self.compile_match_edge(None, edge, is_single_match, &mut edge_variables)
       }
       crate::parser::ast::Pattern::Path(path) => self.compile_match_edge(
         Some(path.variable.to_owned()),
@@ -841,7 +844,7 @@ impl Compiler
       }
       self.compile_expression(where_expression, &mut filter, &mut None)?;
     }
-    Ok(Block::BlockMatch {
+    Ok(Block::Match {
       blocks,
       filter,
       optional,
@@ -852,7 +855,7 @@ impl Compiler
   fn check_for_constant_integer_expression(&mut self, x: &ast::Expression) -> Result<()>
   {
     let ei = expression_analyser::Analyser::new(&self.variables_manager, &self.function_manager)
-      .analyse(&x)?;
+      .analyse(x)?;
     if !ei.constant
     {
       Err(error::CompileTimeError::NonConstantExpression.into())
@@ -879,7 +882,7 @@ impl Compiler
       .map(|x| {
         self.check_for_constant_integer_expression(x)?;
         let mut instructions = Instructions::new();
-        self.compile_expression(&x, &mut instructions, &mut None)?;
+        self.compile_expression(x, &mut instructions, &mut None)?;
         Ok::<_, ErrorType>(instructions)
       })
       .transpose()?;
@@ -889,7 +892,7 @@ impl Compiler
       .map(|x| {
         self.check_for_constant_integer_expression(x)?;
         let mut instructions = Instructions::new();
-        self.compile_expression(&x, &mut instructions, &mut None)?;
+        self.compile_expression(x, &mut instructions, &mut None)?;
         Ok::<_, ErrorType>(instructions)
       })
       .transpose()?;
@@ -955,17 +958,17 @@ pub(crate) fn compile(
         ),
         ast::Statement::Return(return_statement) =>
         {
-          let (variables, filter, modifiers, variables_size) = compiler.compile_return_with(
+          let compiled_return_with = compiler.compile_return_with(
             return_statement.all,
             &return_statement.expressions,
             &return_statement.where_expression,
             &return_statement.modifiers,
           )?;
           Ok(Block::Return {
-            variables,
-            filter,
-            modifiers,
-            variables_size,
+            variables: compiled_return_with.variables,
+            filter: compiled_return_with.filter,
+            modifiers: compiled_return_with.modifiers,
+            variables_sizes: compiled_return_with.variables_sizes,
           })
         }
         ast::Statement::Call(call) =>
@@ -982,17 +985,21 @@ pub(crate) fn compile(
         }
         ast::Statement::With(with) =>
         {
-          let (variables, filter, modifiers, variables_size) = compiler.compile_return_with(
+          let compiled_return_with = compiler.compile_return_with(
             with.all,
             &with.expressions,
             &with.where_expression,
             &with.modifiers,
           )?;
           Ok(Block::With {
-            variables: variables.into_iter().map(|(_, v)| v).collect(),
-            filter,
-            modifiers,
-            variables_size,
+            variables: compiled_return_with
+              .variables
+              .into_iter()
+              .map(|(_, v)| v)
+              .collect(),
+            filter: compiled_return_with.filter,
+            modifiers: compiled_return_with.modifiers,
+            variables_sizes: compiled_return_with.variables_sizes,
           })
         }
         ast::Statement::Unwind(unwind) =>
@@ -1023,7 +1030,7 @@ pub(crate) fn compile(
                 | expression_analyser::ExpressionType::Edge
                 | expression_analyser::ExpressionType::Variant =>
                 {
-                  compiler.compile_expression(&expr, &mut instructions, &mut None)?
+                  compiler.compile_expression(expr, &mut instructions, &mut None)?
                 }
                 _ => Err(CompileTimeError::InvalidDelete)?,
               }