gqlite 1.2.2 → 1.3.0

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

@@ -114,9 +114,16 @@ pub extern "C" fn gqlite_connection_create_from_file(
   check_error(context);
   let options = get_value(options);
   let path = unsafe { std::ffi::CStr::from_ptr(filename) };
+
   if let Ok(path) = handle_error(context, path.to_str())
   {
-    if let Ok(c) = handle_error(context, crate::Connection::open(path, options.into_map()))
+    if let Ok(c) = handle_error(
+      context,
+      crate::Connection::builder()
+        .options(options.into_map())
+        .path(path)
+        .create(),
+    )
     {
       return Box::into_raw(Box::new(GqliteConnectionT { connection: c }));
     }
@@ -124,6 +131,22 @@ pub extern "C" fn gqlite_connection_create_from_file(
   std::ptr::null::<GqliteConnectionT>() as *mut GqliteConnectionT
 }
 
+#[no_mangle]
+pub extern "C" fn gqlite_connection_create(
+  context: *mut GqliteApiContextT,
+  options: *mut GqliteValueT,
+) -> *mut GqliteConnectionT
+{
+  check_error(context);
+  let options = get_value(options);
+
+  if let Ok(c) = handle_error(context, crate::Connection::create(options.into_map()))
+  {
+    return Box::into_raw(Box::new(GqliteConnectionT { connection: c }));
+  }
+  std::ptr::null::<GqliteConnectionT>() as *mut GqliteConnectionT
+}
+
 #[no_mangle]
 pub extern "C" fn gqlite_connection_destroy(
   _context: *mut GqliteApiContextT,
@@ -150,11 +173,13 @@ pub extern "C" fn gqlite_connection_query(
     let conn = unsafe { Box::from_raw(connection) };
     let result = conn
       .connection
-      .execute_query(query, get_value(bindings).into_map());
+      .execute_oc_query(query, get_value(bindings).into_map());
     let _ = Box::into_raw(conn);
     if let Ok(v) = handle_error(context, result)
     {
-      return Box::into_raw(Box::new(GqliteValueT { value: v }));
+      return Box::into_raw(Box::new(GqliteValueT {
+        value: v.into_value(),
+      }));
     }
   }
   std::ptr::null::<GqliteValueT>() as *mut GqliteValueT
@@ -199,7 +224,7 @@ pub extern "C" fn gqlite_value_to_json(
     return r;
   }
   let _ = Box::into_raw(value);
-  return std::ptr::null();
+  std::ptr::null()
 }
 
 #[no_mangle]
@@ -218,7 +243,7 @@ pub extern "C" fn gqlite_value_from_json(
       return Box::into_raw(Box::new(GqliteValueT { value: v }));
     }
   }
-  return std::ptr::null::<GqliteValueT>() as *mut GqliteValueT;
+  std::ptr::null::<GqliteValueT>() as *mut GqliteValueT
 }
 
 #[no_mangle]
@@ -228,9 +253,8 @@ pub extern "C" fn gqlite_value_is_valid(
 ) -> bool
 {
   check_error(context);
-  match unsafe { (*value).value.borrow() }
-  {
-    crate::value::Value::Null => false,
-    _ => true,
-  }
+  !matches!(
+    unsafe { (*value).value.borrow() },
+    crate::value::Value::Null
+  )
 }

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

@@ -11,6 +11,7 @@ use crate::{compiler::variables_manager::VariablesManager, parser::ast, prelude:
 pub(crate) enum ExpressionType
 {
   Array,
+  Key,
   Map,
   Node,
   Edge,
@@ -134,7 +135,7 @@ where
   }
 }
 
-impl<'a, VT> ExpressionAnalyser for (&'a ast::Expression, VT)
+impl<VT> ExpressionAnalyser for (&ast::Expression, VT)
 where
   VT: Fn(ExpressionInfo) -> Result<ExpressionInfo>,
 {
@@ -188,8 +189,8 @@ impl ExpressionInfo
     let dependents = dependents.into();
     Self {
       expression_type,
-      constant: dependents.iter().all(|x| x.constant == true),
-      aggregation_result: dependents.into_iter().any(|x| x.aggregation_result == true),
+      constant: dependents.iter().all(|x| x.constant),
+      aggregation_result: dependents.into_iter().any(|x| x.aggregation_result),
     }
   }
 }
@@ -253,7 +254,7 @@ impl<'b> Analyser<'b>
             arguments.iter().map(|x| x.expression_type).collect(),
           )?,
           self.functions_manager.is_deterministic(&call.name)?
-            && arguments.iter().all(|x| x.constant == true),
+            && arguments.iter().all(|x| x.constant),
           self.functions_manager.is_aggregate(&call.name)?,
         ))
       }
@@ -349,6 +350,10 @@ impl<'b> Analyser<'b>
         ExpressionType::Variant,
         ([&ri.left, &ri.right].into_iter(), validators::any).analyse(self)?,
       )),
+      ast::Expression::Exponent(ri) => Ok(ExpressionInfo::new_type(
+        ExpressionType::Variant,
+        ([&ri.left, &ri.right].into_iter(), validators::any).analyse(self)?,
+      )),
       ast::Expression::Map(map) => Ok(ExpressionInfo::new_type(
         ExpressionType::Map,
         (map.map.iter().map(|(_, v)| v), validators::any).analyse(self)?,
@@ -404,6 +409,7 @@ impl<'b> Analyser<'b>
         match val.value
         {
           value::Value::Array(_) => ExpressionType::Array,
+          value::Value::Key(_) => ExpressionType::Key,
           value::Value::Boolean(_) => ExpressionType::Boolean,
           value::Value::Edge(_) => ExpressionType::Edge,
           value::Value::Node(_) => ExpressionType::Node,

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 {
@@ -558,33 +559,29 @@ impl VariablesManager
         .into(),
       );
     }
-    #[allow(unused_variables)]
     match statement
     {
-      ast::Statement::CreateGraph(create_graph) =>
+      ast::Statement::CreateGraph(..) =>
       {}
-      ast::Statement::UseGraph(use_graph) =>
+      ast::Statement::DropGraph(..) =>
+      {}
+      ast::Statement::UseGraph(..) =>
       {}
       ast::Statement::Create(create) =>
       {
         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)?;
         }
@@ -596,11 +593,11 @@ impl VariablesManager
           self.analyse_pattern(pattern, false)?;
         }
       }
-      ast::Statement::Return(return_statement) =>
+      ast::Statement::Return(..) =>
       {}
-      ast::Statement::Call(call) =>
+      ast::Statement::Call(..) =>
       {}
-      ast::Statement::With(with) =>
+      ast::Statement::With(..) =>
       {}
       ast::Statement::Unwind(unwind) =>
       {
@@ -610,9 +607,9 @@ impl VariablesManager
         )?;
         self.mark_variables_as_set(&unwind.identifier)?;
       }
-      ast::Statement::Delete(delete) =>
+      ast::Statement::Delete(..) =>
       {}
-      ast::Statement::Update(update) =>
+      ast::Statement::Update(..) =>
       {}
     }
     Ok(())

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

@@ -52,7 +52,7 @@ impl Compiler
   ) -> Result<()>
   {
     expression_analyser::Analyser::new(&self.variables_manager, &self.function_manager)
-      .analyse(&expression)?;
+      .analyse(expression)?;
 
     let expr = match expression
     {
@@ -83,7 +83,7 @@ impl Compiler
             self.compile_expression(
               function_call
                 .arguments
-                .get(0)
+                .first()
                 .ok_or(error::InternalError::MissingAggregationArgument)?,
               &mut argument_instructions,
               aggregations,
@@ -141,7 +141,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) =>
       {
@@ -261,6 +261,11 @@ impl Compiler
         compile_binary_op!(self, modulo, instructions, aggregations);
         Instruction::ModuloBinaryOperator
       }
+      ast::Expression::Exponent(exponent) =>
+      {
+        compile_binary_op!(self, exponent, instructions, aggregations);
+        Instruction::ExponentBinaryOperator
+      }
       ast::Expression::Negation(logical_negation) =>
       {
         self.compile_expression(&logical_negation.value, instructions, aggregations)?;
@@ -323,33 +328,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",
@@ -361,21 +365,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)
@@ -386,7 +389,7 @@ impl Compiler
         }
         Ok(())
       }
-      &ast::LabelExpression::Or(expressions) =>
+      ast::LabelExpression::Or(expressions) =>
       {
         instructions.push(Instruction::Push {
           value: false.into(),
@@ -394,7 +397,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)
@@ -405,13 +408,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 {
@@ -423,7 +426,7 @@ impl Compiler
         });
         Ok(())
       }
-      &ast::LabelExpression::None =>
+      ast::LabelExpression::None =>
       {
         instructions.push(Instruction::Push { value: true.into() });
         Ok(())
@@ -431,10 +434,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();
@@ -500,7 +500,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(_) =>
@@ -533,7 +533,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
     {
@@ -550,7 +550,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);
@@ -629,14 +629,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);
@@ -685,7 +685,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)?,
@@ -701,10 +701,11 @@ impl Compiler
     })
   }
 
+  #[allow(clippy::type_complexity)]
   fn compile_return_with(
     &mut self,
     all: bool,
-    expressions: &Vec<ast::NamedExpression>,
+    expressions: &[ast::NamedExpression],
     where_expression: &Option<ast::Expression>,
     modifiers: &ast::Modifiers,
   ) -> Result<(
@@ -750,7 +751,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 {
@@ -773,7 +774,7 @@ impl Compiler
       self.compile_expression(where_expression, &mut filter, &mut None)?;
     }
 
-    let modifiers = self.compile_modifiers(&modifiers)?;
+    let modifiers = self.compile_modifiers(modifiers)?;
     let variables_size = self.variables_size();
     self
       .variables_manager
@@ -788,7 +789,7 @@ impl Compiler
 
   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>
@@ -806,7 +807,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)?,
@@ -815,7 +816,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()),
@@ -836,7 +837,7 @@ impl Compiler
       }
       self.compile_expression(where_expression, &mut filter, &mut None)?;
     }
-    Ok(Block::BlockMatch {
+    Ok(Block::Match {
       blocks,
       filter,
       optional,
@@ -847,7 +848,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())
@@ -874,7 +875,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()?;
@@ -884,7 +885,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()?;
@@ -935,6 +936,10 @@ pub(crate) fn compile(
         ast::Statement::CreateGraph(create_graph) => Ok(Block::CreateGraph {
           name: create_graph.name.to_owned(),
         }),
+        ast::Statement::DropGraph(drop_graph) => Ok(Block::DropGraph {
+          name: drop_graph.name.to_owned(),
+          if_exists: drop_graph.if_exists,
+        }),
         ast::Statement::UseGraph(use_graph) => Ok(Block::UseGraph {
           name: use_graph.name.to_owned(),
         }),
@@ -1014,7 +1019,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)?,
               }