gqlite 1.5.1 → 1.7.0

data/ext/gqlitedb/src/compiler.rs

@@ -1,8 +1,9 @@
-pub(crate) mod expression_analyser;
-pub(crate) mod variables_manager;
+use gqlparser::oc::ast;
 
 use crate::{
-  compiler::variables_manager::VariablesManager, interpreter::instructions::VariablesSizes,
+  compiler::{expression_analyser::ExpressionType, variables_manager::VariablesManager},
+  interpreter::instructions::{CreateActionVariable, VariablesSizes},
+  planner::{LogicalPlan, LogicalPlans, ProjectionKind},
   prelude::*,
 };
 
@@ -10,7 +11,9 @@ use interpreter::instructions::{
   self, Block, BlockMatch, CreateAction, Instruction, Instructions, Modifiers, RWAggregation,
   RWExpression,
 };
-use parser::ast;
+
+pub(crate) mod expression_analyser;
+pub(crate) mod variables_manager;
 
 macro_rules! compile_binary_op {
   ( $this:tt, $x:tt, $instructions:tt, $aggregations:tt ) => {
@@ -27,6 +30,25 @@ struct CompiledReturnWith
   variables_sizes: VariablesSizes,
 }
 
+struct PlannedProjection
+{
+  kind: ProjectionKind,
+  all: bool,
+  expressions: Vec<ast::NamedExpression>,
+  where_expression: Option<ast::Expression>,
+  modifiers: ast::Modifiers,
+}
+
+fn is_scan_plan(plan: &LogicalPlan) -> bool
+{
+  match plan
+  {
+    LogicalPlan::NodeScan { .. } => true,
+    LogicalPlan::Filter { source, .. } => is_scan_plan(source),
+    _ => false,
+  }
+}
+
 struct Compiler
 {
   function_manager: functions::Manager,
@@ -54,7 +76,7 @@ impl Compiler
 
   fn compile_expression(
     &mut self,
-    expression: &crate::parser::ast::Expression,
+    expression: &gqlparser::oc::ast::Expression,
     instructions: &mut Instructions,
     aggregations: &mut Option<&mut Vec<(value_table::ColId, RWAggregation)>>,
   ) -> Result<()>
@@ -321,16 +343,17 @@ impl Compiler
 
   fn compile_create_node(
     &mut self,
-    node: &crate::parser::ast::NodePattern,
+    node: gqlparser::oc::ast::NodePattern,
     instructions: &mut Instructions,
-    variables: &mut Vec<Option<value_table::ColId>>,
+    variables: &mut Vec<CreateActionVariable>,
   ) -> Result<()>
   {
-    variables.push(
-      self
+    variables.push(CreateActionVariable {
+      path: None,
+      element: self
         .variables_manager
         .get_variable_index_option(&node.variable)?,
-    );
+    });
     self
       .variables_manager
       .mark_variables_as_set(&node.variable)?;
@@ -341,6 +364,84 @@ impl Compiler
     Ok(())
   }
 
+  fn compile_create_edge(
+    &mut self,
+    edge: gqlparser::oc::ast::EdgePattern,
+    instructions: &mut Instructions,
+    variables: &mut Vec<CreateActionVariable>,
+    path_variable: Option<ast::VariableIdentifier>,
+  ) -> Result<()>
+  {
+    let source_variable = edge.source.variable.clone();
+    let destination_variable = edge.destination.variable.clone();
+    // Generate source
+    if self
+      .variables_manager
+      .is_set_variable(&edge.source.variable)?
+    {
+      instructions.push(Instruction::GetVariable {
+        col_id: self
+          .variables_manager
+          .get_variable_index(edge.source.variable.as_ref().unwrap())?,
+      });
+    }
+    else
+    {
+      self.compile_create_node(edge.source, instructions, variables)?;
+      instructions.push(Instruction::Duplicate);
+    }
+    // Generate destination
+    if source_variable.is_some()
+      && destination_variable.is_some()
+      && source_variable == destination_variable
+    {
+      instructions.push(Instruction::Duplicate);
+    }
+    else if self
+      .variables_manager
+      .is_set_variable(&edge.destination.variable)?
+    {
+      instructions.push(Instruction::GetVariable {
+        col_id: self
+          .variables_manager
+          .get_variable_index(edge.destination.variable.as_ref().unwrap())?,
+      });
+    }
+    else
+    {
+      self.compile_create_node(edge.destination, instructions, variables)?;
+      instructions.push(Instruction::Duplicate);
+      instructions.push(Instruction::Rot3);
+    }
+    variables.push(CreateActionVariable {
+      element: self
+        .variables_manager
+        .get_variable_index_option(&edge.variable)?,
+      path: self
+        .variables_manager
+        .get_variable_index_option(&path_variable)?,
+    });
+    self
+      .variables_manager
+      .mark_variables_as_set(&edge.variable)?;
+    self.compile_optional_expression(&edge.properties, instructions)?;
+    // Reject variable-length relationships in CREATE statements
+    if edge.recursive_range.is_some()
+    {
+      return Err(CompileTimeError::CreatingVarLength.into());
+    }
+    if !edge.labels.is_string()
+    {
+      Err(CompileTimeError::NoSingleRelationshipType {
+        text: Default::default(),
+        span: Default::default(),
+      })?;
+    }
+    let mut labels = Default::default();
+    Self::compile_labels_expression(&mut labels, &edge.labels)?;
+    instructions.push(Instruction::CreateEdgeLiteral { labels });
+    Ok(())
+  }
   fn compile_labels_expression(
     labels: &mut Vec<String>,
     label_expressions: &ast::LabelExpression,
@@ -442,80 +543,35 @@ impl Compiler
     }
   }
 
-  fn compile_create_patterns(&mut self, patterns: &[crate::parser::ast::Pattern]) -> Result<Block>
+  fn compile_create_patterns(
+    &mut self,
+    patterns: impl IntoIterator<Item = gqlparser::oc::ast::Pattern>,
+  ) -> Result<Block>
   {
-    let actions = patterns.iter().map(|c| {
+    let actions = patterns.into_iter().map(|c| {
       let mut instructions = Instructions::new();
-      let mut variables = Vec::<Option<value_table::ColId>>::new();
+      let mut variables = Vec::<CreateActionVariable>::new();
       match c
       {
-        crate::parser::ast::Pattern::Node(node) =>
+        gqlparser::oc::ast::Pattern::Node(node) =>
         {
           self.compile_create_node(node, &mut instructions, &mut variables)?;
         }
-        crate::parser::ast::Pattern::Edge(edge) =>
+        gqlparser::oc::ast::Pattern::Edge(edge) =>
         {
-          // Generate source
-          if self
-            .variables_manager
-            .is_set_variable(&edge.source.variable)?
-          {
-            instructions.push(Instruction::GetVariable {
-              col_id: self
-                .variables_manager
-                .get_variable_index(edge.source.variable.as_ref().unwrap())?,
-            });
-          }
-          else
-          {
-            self.compile_create_node(&edge.source, &mut instructions, &mut variables)?;
-            instructions.push(Instruction::Duplicate);
-          }
-          // Generate destination
-          if edge.source.variable.is_some()
-            && edge.destination.variable.is_some()
-            && edge.source.variable == edge.destination.variable
-          {
-            instructions.push(Instruction::Duplicate);
-          }
-          else if self
-            .variables_manager
-            .is_set_variable(&edge.destination.variable)?
-          {
-            instructions.push(Instruction::GetVariable {
-              col_id: self
-                .variables_manager
-                .get_variable_index(edge.destination.variable.as_ref().unwrap())?,
-            });
-          }
-          else
-          {
-            self.compile_create_node(&edge.destination, &mut instructions, &mut variables)?;
-            instructions.push(Instruction::Duplicate);
-            instructions.push(Instruction::Rot3);
-          }
-          variables.push(
-            self
-              .variables_manager
-              .get_variable_index_option(&edge.variable)?,
-          );
-          self
-            .variables_manager
-            .mark_variables_as_set(&edge.variable)?;
-          self.compile_optional_expression(&edge.properties, &mut instructions)?;
-          if !edge.labels.is_string()
-          {
-            Err(CompileTimeError::NoSingleRelationshipType)?;
-          }
-          let mut labels = Default::default();
-          Self::compile_labels_expression(&mut labels, &edge.labels)?;
-          instructions.push(Instruction::CreateEdgeLiteral { labels });
+          self.compile_create_edge(edge, &mut instructions, &mut variables, None)?;
         }
-        crate::parser::ast::Pattern::Path(_) =>
+        gqlparser::oc::ast::Pattern::Path(path) =>
         {
-          Err(InternalError::PathPatternInCreateExpression {
-            context: "compiler/compile_create_patterns",
-          })?;
+          self
+            .variables_manager
+            .mark_variables_as_set(&path.variable)?;
+          self.compile_create_edge(
+            path.edge,
+            &mut instructions,
+            &mut variables,
+            Some(path.variable),
+          )?;
         }
       }
       Ok(CreateAction {
@@ -531,7 +587,7 @@ impl Compiler
 
   fn compile_match_node(
     &mut self,
-    node: &crate::parser::ast::NodePattern,
+    node: &gqlparser::oc::ast::NodePattern,
     instructions: &mut Instructions,
     filter: &mut Instructions,
     get_node_function_name: Option<&'static str>,
@@ -570,7 +626,7 @@ impl Compiler
   fn compile_match_edge(
     &mut self,
     path_variable: Option<ast::VariableIdentifier>,
-    edge: &crate::parser::ast::EdgePattern,
+    edge: &gqlparser::oc::ast::EdgePattern,
     single_match: bool,
     previous_edges: &mut Vec<usize>,
   ) -> Result<BlockMatch>
@@ -599,11 +655,13 @@ impl Compiler
         Some("get_source"),
       )?;
     }
-    let mut destination_variable = None;
+    let destination_variable;
     if self
       .variables_manager
       .is_set_variable(&edge.destination.variable)?
     {
+      // Always capture the destination variable so the DFS can filter by pre-bound destination key.
+      destination_variable = edge.destination.variable.to_owned();
       instructions.push(Instruction::GetVariable {
         col_id: self
           .variables_manager
@@ -706,6 +764,7 @@ impl Compiler
         .get_variable_index_option(&path_variable)?,
       filter,
       directivity: edge.directivity,
+      recursive_range: edge.recursive_range.clone(),
     })
   }
 
@@ -796,8 +855,8 @@ impl Compiler
 
   fn compile_match_patterns(
     &mut self,
-    patterns: &[crate::parser::ast::Pattern],
-    where_expression: &Option<crate::parser::ast::Expression>,
+    patterns: &[gqlparser::oc::ast::Pattern],
+    where_expression: &Option<gqlparser::oc::ast::Expression>,
     optional: bool,
   ) -> Result<Block>
   {
@@ -805,7 +864,7 @@ impl Compiler
     let mut edge_variables = vec![];
     let blocks = patterns.iter().map(|c| match c
     {
-      crate::parser::ast::Pattern::Node(node) =>
+      gqlparser::oc::ast::Pattern::Node(node) =>
       {
         let mut instructions = Instructions::new();
         let mut filter = Instructions::new();
@@ -821,11 +880,11 @@ impl Compiler
           filter,
         })
       }
-      crate::parser::ast::Pattern::Edge(edge) =>
+      gqlparser::oc::ast::Pattern::Edge(edge) =>
       {
         self.compile_match_edge(None, edge, is_single_match, &mut edge_variables)
       }
-      crate::parser::ast::Pattern::Path(path) => self.compile_match_edge(
+      gqlparser::oc::ast::Pattern::Path(path) => self.compile_match_edge(
         Some(path.variable.to_owned()),
         &path.edge,
         is_single_match,
@@ -852,11 +911,17 @@ impl Compiler
     })
   }
 
-  fn check_for_constant_integer_expression(&mut self, x: &ast::Expression) -> Result<()>
+  fn check_for_positive_constant_integer_expression(&mut self, x: &ast::Expression) -> Result<()>
   {
+    if let ast::Expression::Value(value) = x
+      && let Ok(v) = <&graphcore::Value as TryInto<i64>>::try_into(&value.value)
+      && v < 0
+    {
+      return Err(error::CompileTimeError::NegativeIntegerArgument.into());
+    }
     let ei = expression_analyser::Analyser::new(&self.variables_manager, &self.function_manager)
       .analyse(x)?;
-    if !ei.constant
+    if !ei.runtime_constant
     {
       Err(error::CompileTimeError::NonConstantExpression.into())
     }
@@ -880,7 +945,7 @@ impl Compiler
       .limit
       .as_ref()
       .map(|x| {
-        self.check_for_constant_integer_expression(x)?;
+        self.check_for_positive_constant_integer_expression(x)?;
         let mut instructions = Instructions::new();
         self.compile_expression(x, &mut instructions, &mut None)?;
         Ok::<_, ErrorType>(instructions)
@@ -890,7 +955,7 @@ impl Compiler
       .skip
       .as_ref()
       .map(|x| {
-        self.check_for_constant_integer_expression(x)?;
+        self.check_for_positive_constant_integer_expression(x)?;
         let mut instructions = Instructions::new();
         self.compile_expression(x, &mut instructions, &mut None)?;
         Ok::<_, ErrorType>(instructions)
@@ -920,11 +985,227 @@ impl Compiler
       order_by,
     })
   }
+
+  fn unpack_scan_plan(
+    logical_plan: LogicalPlan,
+  ) -> Result<(Vec<ast::Pattern>, Option<ast::Expression>, bool)>
+  {
+    match logical_plan
+    {
+      LogicalPlan::NodeScan { patterns, optional } => Ok((patterns, None, optional)),
+      LogicalPlan::Filter { source, expression } =>
+      {
+        let (patterns, filter, optional) = Self::unpack_scan_plan(*source)?;
+        if filter.is_some()
+        {
+          return Err(
+            InternalError::Unreachable {
+              context: "compile/unpack_scan_plan/filter",
+            }
+            .into(),
+          );
+        }
+        Ok((patterns, Some(expression), optional))
+      }
+      _ => Err(
+        InternalError::Unreachable {
+          context: "compile/unpack_scan_plan",
+        }
+        .into(),
+      ),
+    }
+  }
+
+  fn compile_scan_plan(&mut self, logical_plan: LogicalPlan) -> Result<Block>
+  {
+    let (patterns, where_expression, optional) = Self::unpack_scan_plan(logical_plan)?;
+    self.compile_match_patterns(&patterns, &where_expression, optional)
+  }
+
+  fn unpack_projection_plan(logical_plan: LogicalPlan) -> Result<PlannedProjection>
+  {
+    match logical_plan
+    {
+      LogicalPlan::Projection {
+        kind,
+        all,
+        expressions,
+      } => Ok(PlannedProjection {
+        kind,
+        all,
+        expressions,
+        where_expression: None,
+        modifiers: Default::default(),
+      }),
+      LogicalPlan::Filter { source, expression } =>
+      {
+        let mut projection = Self::unpack_projection_plan(*source)?;
+        if projection.where_expression.is_some()
+        {
+          return Err(
+            InternalError::Unreachable {
+              context: "compile/unpack_projection_plan/filter",
+            }
+            .into(),
+          );
+        }
+        projection.where_expression = Some(expression);
+        Ok(projection)
+      }
+      LogicalPlan::Sort {
+        source,
+        expressions,
+      } =>
+      {
+        let mut projection = Self::unpack_projection_plan(*source)?;
+        if projection.modifiers.order_by.is_some()
+        {
+          return Err(
+            InternalError::Unreachable {
+              context: "compile/unpack_projection_plan/sort",
+            }
+            .into(),
+          );
+        }
+        projection.modifiers.order_by = Some(ast::OrderBy { expressions });
+        Ok(projection)
+      }
+      LogicalPlan::Skip { source, expression } =>
+      {
+        let mut projection = Self::unpack_projection_plan(*source)?;
+        if projection.modifiers.skip.is_some()
+        {
+          return Err(
+            InternalError::Unreachable {
+              context: "compile/unpack_projection_plan/skip",
+            }
+            .into(),
+          );
+        }
+        projection.modifiers.skip = Some(expression);
+        Ok(projection)
+      }
+      LogicalPlan::Limit { source, expression } =>
+      {
+        let mut projection = Self::unpack_projection_plan(*source)?;
+        if projection.modifiers.limit.is_some()
+        {
+          return Err(
+            InternalError::Unreachable {
+              context: "compile/unpack_projection_plan/limit",
+            }
+            .into(),
+          );
+        }
+        projection.modifiers.limit = Some(expression);
+        Ok(projection)
+      }
+      _ => Err(
+        InternalError::Unreachable {
+          context: "compile/unpack_projection_plan",
+        }
+        .into(),
+      ),
+    }
+  }
+
+  fn compile_projection_plan(&mut self, logical_plan: LogicalPlan) -> Result<Block>
+  {
+    let projection = Self::unpack_projection_plan(logical_plan)?;
+    let compiled_return_with = self.compile_return_with(
+      projection.all,
+      &projection.expressions,
+      &projection.where_expression,
+      &projection.modifiers,
+    )?;
+
+    match projection.kind
+    {
+      ProjectionKind::Return => Ok(Block::Return {
+        variables: compiled_return_with.variables,
+        filter: compiled_return_with.filter,
+        modifiers: compiled_return_with.modifiers,
+        variables_sizes: compiled_return_with.variables_sizes,
+      }),
+      ProjectionKind::With => Ok(Block::With {
+        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,
+      }),
+    }
+  }
+
+  fn compile_updates(&mut self, updates: &[ast::OneUpdate])
+  -> Result<Vec<instructions::UpdateOne>>
+  {
+    updates
+      .iter()
+      .map(|x| match x
+      {
+        ast::OneUpdate::SetProperty(update_property)
+        | ast::OneUpdate::AddProperty(update_property) =>
+        {
+          let mut instructions = Instructions::new();
+          self.compile_expression(&update_property.expression, &mut instructions, &mut None)?;
+
+          match x
+          {
+            ast::OneUpdate::SetProperty(_) => Ok(instructions::UpdateOne::SetProperty {
+              target: self
+                .variables_manager
+                .get_variable_index(&update_property.target)?,
+              path: update_property.path.to_owned(),
+              instructions,
+            }),
+            ast::OneUpdate::AddProperty(_) => Ok(instructions::UpdateOne::AddProperty {
+              target: self
+                .variables_manager
+                .get_variable_index(&update_property.target)?,
+              path: update_property.path.to_owned(),
+              instructions,
+            }),
+            _ => Err(
+              InternalError::Unreachable {
+                context: "compile_updates/SetAddProperty",
+              }
+              .into(),
+            ),
+          }
+        }
+        ast::OneUpdate::RemoveProperty(remove_property) =>
+        {
+          Ok(instructions::UpdateOne::RemoveProperty {
+            target: self
+              .variables_manager
+              .get_variable_index(&remove_property.target)?,
+            path: remove_property.path.to_owned(),
+          })
+        }
+        ast::OneUpdate::AddLabels(add_labels) => Ok(instructions::UpdateOne::AddLabels {
+          target: self
+            .variables_manager
+            .get_variable_index(&add_labels.target)?,
+          labels: add_labels.labels.to_owned(),
+        }),
+        ast::OneUpdate::RemoveLabels(rm_labels) => Ok(instructions::UpdateOne::RemoveLabels {
+          target: self
+            .variables_manager
+            .get_variable_index(&rm_labels.target)?,
+          labels: rm_labels.labels.to_owned(),
+        }),
+      })
+      .collect::<Result<_>>()
+  }
 }
 
 pub(crate) fn compile(
   function_manager: &functions::Manager,
-  statements: crate::parser::ast::Statements,
+  logical_plans: LogicalPlans,
 ) -> Result<interpreter::Program>
 {
   let mut compiler = Compiler {
@@ -932,93 +1213,64 @@ pub(crate) fn compile(
     function_manager: function_manager.clone(),
     temporary_variables: 0,
   };
-  let mut statements_err = Ok(());
-  let program = statements
-    .iter()
-    .map(|stmt| {
+  let program = logical_plans
+    .into_iter()
+    .map(|logical_plan| {
       compiler.temporary_variables = 0;
-      compiler.variables_manager.analyse(stmt)?;
-      match stmt
+      compiler.variables_manager.analyse(&logical_plan)?;
+      match logical_plan
       {
-        ast::Statement::CreateGraph(create_graph) => Ok(Block::CreateGraph {
-          name: create_graph.name.to_owned(),
-          if_not_exists: create_graph.if_not_exists,
-        }),
-        ast::Statement::DropGraph(drop_graph) => Ok(Block::DropGraph {
-          name: drop_graph.name.to_owned(),
-          if_exists: drop_graph.if_exists,
+        LogicalPlan::CreateGraph {
+          name,
+          if_not_exists,
+        } => Ok(Block::CreateGraph {
+          name,
+          if_not_exists,
         }),
-        ast::Statement::UseGraph(use_graph) => Ok(Block::UseGraph {
-          name: use_graph.name.to_owned(),
-        }),
-        ast::Statement::Create(create) => compiler.compile_create_patterns(&create.patterns),
-        ast::Statement::Match(match_statement) => compiler.compile_match_patterns(
-          &match_statement.patterns,
-          &match_statement.where_expression,
-          match_statement.optional,
-        ),
-        ast::Statement::Return(return_statement) =>
+        LogicalPlan::DropGraph { name, if_exists } => Ok(Block::DropGraph { name, if_exists }),
+        LogicalPlan::UseGraph { name } => Ok(Block::UseGraph { name }),
+        LogicalPlan::Create { patterns } => compiler.compile_create_patterns(patterns),
+        LogicalPlan::NodeScan { .. } => compiler.compile_scan_plan(logical_plan),
+        LogicalPlan::Filter { ref source, .. } if is_scan_plan(source.as_ref()) =>
         {
-          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: compiled_return_with.variables,
-            filter: compiled_return_with.filter,
-            modifiers: compiled_return_with.modifiers,
-            variables_sizes: compiled_return_with.variables_sizes,
-          })
+          compiler.compile_scan_plan(logical_plan)
         }
-        ast::Statement::Call(call) =>
+        LogicalPlan::Projection { .. }
+        | LogicalPlan::Sort { .. }
+        | LogicalPlan::Skip { .. }
+        | LogicalPlan::Limit { .. }
+        | LogicalPlan::Filter { .. } => compiler.compile_projection_plan(logical_plan),
+        LogicalPlan::Call { name, arguments } =>
         {
           let mut instructions = Instructions::new();
-          for e in call.arguments.iter().rev()
+          for e in arguments.iter().rev()
           {
             compiler.compile_expression(e, &mut instructions, &mut None)?;
           }
           Ok(Block::Call {
             arguments: instructions,
-            name: call.name.to_owned(),
+            name,
           })
         }
-        ast::Statement::With(with) =>
-        {
-          let compiled_return_with = compiler.compile_return_with(
-            with.all,
-            &with.expressions,
-            &with.where_expression,
-            &with.modifiers,
-          )?;
-          Ok(Block::With {
-            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) =>
+        LogicalPlan::Unwind {
+          identifier,
+          expression,
+        } =>
         {
           let mut instructions = Instructions::new();
-          compiler.compile_expression(&unwind.expression, &mut instructions, &mut None)?;
+          compiler.compile_expression(&expression, &mut instructions, &mut None)?;
           Ok(Block::Unwind {
-            col_id: compiler
-              .variables_manager
-              .get_variable_index(&unwind.identifier)?,
+            col_id: compiler.variables_manager.get_variable_index(&identifier)?,
             instructions,
             variables_size: compiler.variables_size(),
           })
         }
-        ast::Statement::Delete(delete_statement) => Ok(Block::Delete {
-          detach: delete_statement.detach,
-          instructions: delete_statement
-            .expressions
+        LogicalPlan::Delete {
+          detach,
+          expressions,
+        } => Ok(Block::Delete {
+          detach,
+          instructions: expressions
             .iter()
             .map(|expr| {
               let mut instructions = Instructions::new();
@@ -1039,84 +1291,112 @@ pub(crate) fn compile(
             })
             .collect::<Result<_>>()?,
         }),
-        ast::Statement::Update(update_statement) => Ok(Block::Update {
-          updates: update_statement
-            .updates
-            .iter()
-            .map(|x| match x
-            {
-              ast::OneUpdate::SetProperty(update_property)
-              | ast::OneUpdate::AddProperty(update_property) =>
-              {
-                let mut instructions = Instructions::new();
-                compiler.compile_expression(
-                  &update_property.expression,
-                  &mut instructions,
-                  &mut None,
-                )?;
-
-                match x
-                {
-                  ast::OneUpdate::SetProperty(_) => Ok(instructions::UpdateOne::SetProperty {
-                    target: compiler
-                      .variables_manager
-                      .get_variable_index(&update_property.target)?,
-                    path: update_property.path.to_owned(),
-                    instructions,
-                  }),
-                  ast::OneUpdate::AddProperty(_) => Ok(instructions::UpdateOne::AddProperty {
-                    target: compiler
-                      .variables_manager
-                      .get_variable_index(&update_property.target)?,
-                    path: update_property.path.to_owned(),
-                    instructions,
-                  }),
-                  _ => Err(
-                    InternalError::Unreachable {
-                      context: "compile/Update/SetAddProperty",
-                    }
-                    .into(),
-                  ),
-                }
-              }
-              ast::OneUpdate::RemoveProperty(remove_property) =>
-              {
-                Ok(instructions::UpdateOne::RemoveProperty {
-                  target: compiler
-                    .variables_manager
-                    .get_variable_index(&remove_property.target)?,
-                  path: remove_property.path.to_owned(),
-                })
-              }
-              ast::OneUpdate::AddLabels(add_labels) => Ok(instructions::UpdateOne::AddLabels {
-                target: compiler
-                  .variables_manager
-                  .get_variable_index(&add_labels.target)?,
-                labels: add_labels.labels.to_owned(),
-              }),
-              ast::OneUpdate::RemoveLabels(rm_labels) =>
-              {
-                Ok(instructions::UpdateOne::RemoveLabels {
-                  target: compiler
-                    .variables_manager
-                    .get_variable_index(&rm_labels.target)?,
-                  labels: rm_labels.labels.to_owned(),
-                })
-              }
-            })
-            .collect::<Result<_>>()?,
+        LogicalPlan::Update { updates } => Ok(Block::Update {
+          updates: compiler.compile_updates(&updates)?,
           variables_size: compiler.variables_size(),
         }),
+        LogicalPlan::VectorSearch {
+          index,
+          query,
+          k,
+          result_var,
+          score_var,
+        } =>
+        {
+          let mut query_instructions = Instructions::new();
+          let ei = expression_analyser::Analyser::new(
+            &compiler.variables_manager,
+            &compiler.function_manager,
+          )
+          .analyse(&query)?;
+          if ei.aggregation_result
+          {
+            return Err(CompileTimeError::InvalidAggregation.into());
+          }
+          match ei.expression_type
+          {
+            ExpressionType::Array | ExpressionType::Tensor | ExpressionType::Variant =>
+            {}
+            _ => return Err(CompileTimeError::InvalidVectorInput.into()),
+          }
+          compiler.compile_expression(&query, &mut query_instructions, &mut None)?;
+
+          // Get the column IDs for the output variables from the variables manager
+          let out_node_col_id = compiler.variables_manager.get_variable_index(&result_var)?;
+          let out_score_col_id = compiler
+            .variables_manager
+            .get_variable_index_option(&score_var)?;
+
+          Ok(Block::VectorSearch {
+            index,
+            query_instructions,
+            k,
+            out_node_col_id,
+            out_score_col_id,
+            variables_size: compiler.variables_size(),
+          })
+        }
+        LogicalPlan::Merge {
+          patterns,
+          on_create,
+          on_match,
+        } =>
+        {
+          // 1. Compile the match side
+          let Block::Match {
+            blocks: match_blocks,
+            filter: match_filter,
+            ..
+          } = compiler.compile_match_patterns(&patterns, &None, false)?
+          else
+          {
+            unreachable!()
+          };
+
+          // 2. Compile the create side
+          let Block::Create {
+            actions: create_actions,
+            ..
+          } = compiler.compile_create_patterns(patterns)?
+          else
+          {
+            unreachable!()
+          };
+
+          // 3. Compile ON CREATE / ON MATCH updates
+          let on_create_updates = compiler.compile_updates(&on_create)?;
+          let on_match_updates = compiler.compile_updates(&on_match)?;
+
+          Ok(Block::Merge {
+            match_blocks,
+            match_filter,
+            create_actions,
+            on_create_updates,
+            on_match_updates,
+            variables_size: compiler.variables_size(),
+          })
+        }
+        LogicalPlan::CreateVectorIndex {
+          name,
+          label,
+          property,
+          dimension,
+          metric,
+          if_not_exists,
+        } => Ok(Block::CreateVectorIndex {
+          name,
+          label,
+          property,
+          dimension,
+          metric,
+          if_not_exists,
+        }),
       }
     })
-    .scan(&mut statements_err, |err, gp| {
-      gp.map_err(|e| **err = Err(e)).ok()
-    });
-  let program = program.collect::<interpreter::Program>();
-  statements_err?;
+    .collect::<Result<interpreter::Program>>()?;
   if crate::consts::SHOW_PROGRAM
   {
-    println!("program = {:#?}", program);
+    log::debug!("program = {:#?}", program);
   }
   Ok(program)
 }