gqlite 1.5.0 → 1.7.0

data/ext/gqlitedb/src/interpreter/evaluators.rs

@@ -1,9 +1,11 @@
 use std::collections::HashMap;
 
+use rustc_hash::FxHashSet;
+
 use crate::{
   interpreter::instructions::{Block, VariablesSizes},
   prelude::*,
-  store::TransactionBoxable,
+  store::{SelectNodeQuery, TransactionBoxable},
   value_table::{MutableRowInterface, Row, RowInterface},
 };
 use interpreter::instructions;
@@ -60,6 +62,7 @@ try_into_gv_impl! {f64}
 try_into_gv_impl! {String}
 try_into_gv_impl! {graph::Node}
 try_into_gv_impl! {graph::Edge}
+try_into_gv_impl! {value::Tensor}
 
 macro_rules! try_into_impl {
   ($typename:tt, $type:ty, $errorname:tt) => {
@@ -357,11 +360,14 @@ fn eval_instructions(
         let props: value::Value = stack.try_pop_into()?;
         let dst: graph::Node = stack.try_pop_into()?;
         let src: graph::Node = stack.try_pop_into()?;
-        stack.push(crate::graph::Path::new(
-          graph::Key::default(),
+        stack.push(crate::graph::SinglePath::new(
           src,
-          labels.to_owned(),
-          props.into_map(),
+          graphcore::Edge::new(
+            None,
+            graph::Key::default(),
+            labels.to_owned(),
+            props.into_map(),
+          ),
           dst,
         ));
       }
@@ -369,6 +375,7 @@ fn eval_instructions(
       {
         let props: value::Value = stack.try_pop_into()?;
         stack.push(crate::graph::Node::new(
+          None,
           crate::graph::Key::default(),
           labels.clone(),
           props.into_map(),
@@ -865,7 +872,7 @@ pub(crate) fn eval_update_property<TStore: store::Store>(
     }
     value::Value::Null =>
     {}
-    _ => Err(InternalError::ExpectedEdge {
+    _ => Err(RunTimeError::ExpectedEdge {
       context: "evaluator/eval_program",
     })?,
   }
@@ -1006,10 +1013,8 @@ fn compute_return_with_table(
     for (row, aggregations_states) in aggregation_table
     {
       let mut out_row = value_table::Row::new(Default::default(), variables_sizes.total_size());
-      for (idx, (rw_expr, aggregation_states)) in variables
-        .iter()
-        .zip(aggregations_states.into_iter())
-        .enumerate()
+      for (idx, (rw_expr, aggregation_states)) in
+        variables.iter().zip(aggregations_states).enumerate()
       {
         if rw_expr.aggregations.is_empty()
         {
@@ -1167,6 +1172,378 @@ fn filter_rows(
     .collect()
 }
 
+/// Executes a single `BlockMatch` (node or edge) against every row in `current_rows`,
+/// appending matching rows into `new_rows`.
+///
+/// `allow_recursive` controls whether a recursive edge range pattern is permitted.
+/// Pass `true` for `Block::Match` and `false` for `Block::Merge` — the latter
+/// returns `RunTimeError::UnsupportedRecursivePatternInMerge` when a recursive
+/// range is encountered.
+#[allow(clippy::too_many_arguments)]
+fn execute_block_match<TStore: store::Store>(
+  block: &instructions::BlockMatch,
+  store: &TStore,
+  tx: &mut TStore::TransactionBox,
+  graph_name: &str,
+  stack: &mut Stack,
+  parameters: &crate::value::ValueMap,
+  current_rows: Vec<value_table::Row>,
+  allow_recursive: bool,
+) -> Result<Vec<value_table::Row>>
+{
+  let mut new_rows = Vec::<value_table::Row>::default();
+
+  for row in current_rows
+  {
+    match block
+    {
+      instructions::BlockMatch::MatchNode {
+        instructions,
+        variable,
+        filter,
+      } =>
+      {
+        eval_instructions(stack, &row, instructions, parameters)?;
+        let query: store::SelectNodeQuery = stack.try_pop_into()?;
+        let nodes = store.select_nodes(tx, graph_name, query)?;
+
+        for node in nodes.into_iter()
+        {
+          let mut new_row = row.clone();
+          if let Some(variable) = variable
+          {
+            new_row.set_if_unset(*variable, node.to_owned().into())?;
+          }
+          let should_add_row = if filter.is_empty()
+          {
+            true
+          }
+          else
+          {
+            let mut stack = Stack::default();
+            stack.push(true);
+            stack.push(node);
+            eval_instructions(&mut stack, &new_row, filter, parameters)?;
+            stack.try_pop()?; // discard the sentinel
+            stack.try_pop_into()?
+          };
+          if should_add_row
+          {
+            new_rows.push(new_row);
+          }
+        }
+      }
+
+      instructions::BlockMatch::MatchEdge {
+        instructions,
+        left_variable,
+        edge_variable,
+        right_variable,
+        path_variable,
+        filter,
+        directivity,
+        recursive_range,
+      } =>
+      {
+        eval_instructions(stack, &row, instructions, parameters)?;
+        let query = stack.try_pop_into()?;
+
+        match recursive_range
+        {
+          None =>
+          {
+            let edges = store.select_edges(tx, graph_name, query, *directivity)?;
+
+            for edge in edges.into_iter()
+            {
+              let mut new_row = row.clone();
+              let (left, right) = if edge.reversed
+              {
+                (edge.path.destination(), edge.path.source())
+              }
+              else
+              {
+                (edge.path.source(), edge.path.destination())
+              };
+
+              if let Some(left_variable) = left_variable
+              {
+                new_row.set(*left_variable, left.to_owned().into())?;
+              }
+              if let Some(right_variable) = right_variable
+              {
+                new_row.set(*right_variable, right.to_owned().into())?;
+              }
+              if let Some(edge_variable) = edge_variable
+              {
+                new_row.set(*edge_variable, edge.path.to_edge().into())?;
+              }
+              if let Some(path_variable) = path_variable
+              {
+                new_row.set(*path_variable, edge.path.to_owned().into())?;
+              }
+
+              let should_add_row = if filter.is_empty()
+              {
+                true
+              }
+              else
+              {
+                let mut stack = Stack::default();
+                stack.push(true);
+                stack.push(edge.path.to_edge());
+                eval_instructions(&mut stack, &new_row, filter, parameters)?;
+                stack.try_pop()?;
+                stack.try_pop_into()?
+              };
+
+              if should_add_row
+              {
+                new_rows.push(new_row);
+              }
+            }
+          }
+
+          Some(recursive_range) =>
+          {
+            if !allow_recursive
+            {
+              return Err(InternalError::UnsupportedRecursivePatternInMerge.into());
+            }
+
+            // Recursive DFS
+            let min_hops = recursive_range.start;
+            let max_hops = recursive_range.end;
+            let capacity = max_hops.min(100);
+
+            let bound_dest_key: Option<graph::Key> = if let Some(right_col) = right_variable
+            {
+              match row.get(*right_col)?
+              {
+                value::Value::Node(node) => Some(node.key()),
+                _ => None,
+              }
+            }
+            else
+            {
+              None
+            };
+
+            let start_nodes: Vec<graph::Node> = {
+              let source_query = query.source_query();
+              store.select_nodes(tx, graph_name, source_query)?
+            };
+
+            struct Frame
+            {
+              node: graph::Node,
+              edges: Vec<store::EdgeResult>,
+              edge_index: usize,
+              depth: usize,
+            }
+
+            for start_node in start_nodes
+            {
+              let mut path_edges: Vec<graph::Edge> = Vec::with_capacity(capacity);
+              let mut used_edges: FxHashSet<graph::Key> =
+                FxHashSet::with_capacity_and_hasher(capacity, Default::default());
+              let mut dedup_set: FxHashSet<(Option<graph::Key>, Option<graph::Key>, usize)> =
+                FxHashSet::with_capacity_and_hasher(capacity, Default::default());
+
+              let initial_edges = {
+                let q = store::SelectEdgeQuery::select_source_keys(
+                  store::SelectNodeQuery::select_keys(vec![start_node.key()]),
+                );
+                store.select_edges(tx, graph_name, q, *directivity)?
+              };
+
+              let mut dfs_stack: Vec<Frame> = vec![Frame {
+                node: start_node.clone(),
+                edges: initial_edges,
+                edge_index: 0,
+                depth: 0,
+              }];
+
+              while !dfs_stack.is_empty()
+              {
+                let mut push_next: Option<Frame> = None;
+                let mut should_pop = false;
+
+                let dfs_intermediate_nodes: Vec<graph::Node> = if dfs_stack.len() >= 2
+                {
+                  dfs_stack[1..dfs_stack.len() - 1]
+                    .iter()
+                    .map(|f| f.node.clone())
+                    .collect()
+                }
+                else
+                {
+                  Vec::new()
+                };
+
+                {
+                  let frame = dfs_stack.last_mut().unwrap();
+
+                  // Emit row
+                  if frame.edge_index == 0 && frame.depth >= min_hops
+                  {
+                    let current_node = &frame.node;
+
+                    let mut new_row = row.clone();
+
+                    if let Some(left_var) = left_variable
+                    {
+                      new_row.set(*left_var, start_node.clone().into())?;
+                    }
+                    if let Some(right_var) = right_variable
+                    {
+                      new_row.set(*right_var, current_node.clone().into())?;
+                    }
+                    if let Some(edge_var) = edge_variable
+                      && let Some(last_edge) = path_edges.last()
+                    {
+                      new_row.set(*edge_var, last_edge.clone().into())?;
+                    }
+                    if let Some(path_var) = path_variable
+                    {
+                      let path = graph::Path::new(
+                        start_node.clone(),
+                        path_edges
+                          .clone()
+                          .into_iter()
+                          .zip(
+                            dfs_intermediate_nodes
+                              .clone()
+                              .into_iter()
+                              .chain(std::iter::once(current_node.clone())),
+                          )
+                          .collect(),
+                      );
+                      new_row.set(*path_var, path.into())?;
+                    }
+
+                    let passes_filter = if filter.is_empty()
+                    {
+                      true
+                    }
+                    else
+                    {
+                      let mut eval_stack = Stack::default();
+                      eval_stack.push(true);
+                      if let Some(last_edge) = path_edges.last()
+                      {
+                        eval_stack.push(last_edge.clone());
+                      }
+                      eval_instructions(&mut eval_stack, &new_row, filter, parameters)?;
+                      eval_stack.try_pop()?;
+                      eval_stack.try_pop_into()?
+                    };
+
+                    let matches_dest = if let Some(dest_key) = bound_dest_key
+                    {
+                      current_node.key() == dest_key
+                    }
+                    else
+                    {
+                      true
+                    };
+
+                    if passes_filter && matches_dest
+                    {
+                      let left_key_opt: Option<graph::Key> = if left_variable.is_some()
+                      {
+                        Some(start_node.key())
+                      }
+                      else
+                      {
+                        None
+                      };
+                      let right_key_opt: Option<graph::Key> = Some(current_node.key());
+                      let path_len = path_edges.len();
+                      let sig = (left_key_opt, right_key_opt, path_len);
+
+                      if !dedup_set.contains(&sig)
+                      {
+                        dedup_set.insert(sig);
+                        new_rows.push(new_row);
+                      }
+                    }
+                  }
+
+                  // Stop for max depth
+                  if frame.depth == max_hops || frame.edge_index >= frame.edges.len()
+                  {
+                    should_pop = true;
+                  }
+                  else
+                  {
+                    // Next hop
+                    let edge_result = &frame.edges[frame.edge_index];
+                    frame.edge_index += 1;
+
+                    let edge = edge_result.path.to_edge();
+                    let edge_key = edge.key();
+
+                    if used_edges.contains(&edge_key)
+                    {
+                      continue;
+                    }
+
+                    let next_node = if edge_result.reversed
+                    {
+                      edge_result.path.source().clone()
+                    }
+                    else
+                    {
+                      edge_result.path.destination().clone()
+                    };
+
+                    used_edges.insert(edge_key);
+                    path_edges.push(edge.clone());
+
+                    let next_edges = {
+                      let q = store::SelectEdgeQuery::select_source_keys(
+                        store::SelectNodeQuery::select_keys(vec![next_node.key()]),
+                      );
+                      store.select_edges(tx, graph_name, q, *directivity)?
+                    };
+
+                    push_next = Some(Frame {
+                      node: next_node,
+                      edges: next_edges,
+                      edge_index: 0,
+                      depth: frame.depth + 1,
+                    });
+                  }
+                }
+
+                // Mutate stack
+                if should_pop
+                {
+                  dfs_stack.pop();
+                  if let Some(last_edge) = path_edges.pop()
+                  {
+                    used_edges.remove(&last_edge.key());
+                  }
+                  continue;
+                }
+
+                if let Some(frame) = push_next
+                {
+                  dfs_stack.push(frame);
+                  continue;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  Ok(new_rows)
+}
+
 fn is_write_program(program: &super::Program) -> bool
 {
   program.iter().any(|b| match b
@@ -1176,12 +1553,15 @@ fn is_write_program(program: &super::Program) -> bool
     | Block::Return { .. }
     | Block::Unwind { .. }
     | Block::Call { .. }
-    | Block::With { .. } => false,
+    | Block::With { .. }
+    | Block::VectorSearch { .. } => false,
     Block::CreateGraph { .. }
     | Block::DropGraph { .. }
     | Block::Create { .. }
     | Block::Update { .. }
-    | Block::Delete { .. } => true,
+    | Block::Merge { .. }
+    | Block::Delete { .. }
+    | Block::CreateVectorIndex { .. } => true,
   })
 }
 
@@ -1267,17 +1647,50 @@ pub(crate) fn eval_program<TStore: store::Store>(
                 crate::value::Value::Node(n) =>
                 {
                   store.create_nodes(&mut tx, &graph_name, vec![&n])?;
-                  if let Some(var) = var
+                  if let Some(var) = var.element
                   {
-                    new_row.set_if_unset(*var, crate::value::Value::Node(n))?;
+                    new_row.set_if_unset(
+                      var,
+                      crate::value::Value::Node(n.with_graph_name(graph_name.to_owned())),
+                    )?;
                   }
                 }
-                crate::value::Value::Path(p) =>
+                crate::value::Value::SinglePath(p) =>
                 {
-                  store.create_edges(&mut tx, &graph_name, vec![&p])?;
-                  if let Some(var) = var
+                  store.create_edges(&mut tx, &graph_name, vec![p.as_ref()])?;
+
+                  match (var.element, var.path)
                   {
-                    new_row.set(*var, crate::value::Value::Edge(p.into()))?;
+                    (Some(edge_var), Some(path_var)) =>
+                    {
+                      new_row.set(
+                        edge_var,
+                        crate::value::Value::Edge(
+                          p.clone().into_edge().with_graph_name(graph_name.to_owned()),
+                        ),
+                      )?;
+                      new_row.set(
+                        path_var,
+                        crate::value::Value::SinglePath(
+                          p.with_graph_name(graph_name.to_owned()).into(),
+                        ),
+                      )?;
+                    }
+                    (None, Some(path_var)) =>
+                    {
+                      new_row.set(path_var, crate::value::Value::SinglePath(p))?;
+                    }
+                    (Some(edge_var), None) =>
+                    {
+                      new_row.set(
+                        edge_var,
+                        crate::value::Value::Edge(
+                          p.into_edge().with_graph_name(graph_name.to_owned()),
+                        ),
+                      )?;
+                    }
+                    (None, None) =>
+                    {}
                   }
                 }
                 _ =>
@@ -1304,111 +1717,16 @@ pub(crate) fn eval_program<TStore: store::Store>(
           let mut current_rows: Vec<_> = vec![row.clone().extended(variables_size.total_size())?];
           for block in blocks.iter()
           {
-            let mut new_rows = Vec::<value_table::Row>::default();
-            for row in current_rows
-            {
-              match block
-              {
-                instructions::BlockMatch::MatchNode {
-                  instructions,
-                  variable,
-                  filter,
-                } =>
-                {
-                  eval_instructions(&mut stack, &row, instructions, parameters)?;
-                  let query: store::SelectNodeQuery = stack.try_pop_into()?;
-                  let nodes = store.select_nodes(&mut tx, &graph_name, query)?;
-
-                  for node in nodes.into_iter()
-                  {
-                    let mut new_row = row.clone();
-                    if let Some(variable) = variable
-                    {
-                      new_row.set_if_unset(*variable, node.to_owned().into())?;
-                    }
-                    let should_add_row = if filter.is_empty()
-                    {
-                      true
-                    }
-                    else
-                    {
-                      let mut stack = Stack::default();
-                      stack.push(true);
-                      stack.push(node);
-                      eval_instructions(&mut stack, &new_row, filter, parameters)?;
-                      stack.try_pop()?; // Get rid of the edge
-                      stack.try_pop_into()?
-                    };
-                    if should_add_row
-                    {
-                      new_rows.push(new_row);
-                    }
-                  }
-                }
-                instructions::BlockMatch::MatchEdge {
-                  instructions,
-                  left_variable,
-                  edge_variable,
-                  right_variable,
-                  path_variable,
-                  filter,
-                  directivity,
-                } =>
-                {
-                  eval_instructions(&mut stack, &row, instructions, parameters)?;
-                  let query = stack.try_pop_into()?;
-
-                  let edges = store.select_edges(&mut tx, &graph_name, query, *directivity)?;
-
-                  for edge in edges.into_iter()
-                  {
-                    let mut new_row = row.clone();
-                    let (left, right) = if edge.reversed
-                    {
-                      (edge.path.destination(), edge.path.source())
-                    }
-                    else
-                    {
-                      (edge.path.source(), edge.path.destination())
-                    };
-                    if let Some(left_variable) = left_variable.to_owned()
-                    {
-                      new_row.set(left_variable, left.to_owned().into())?;
-                    }
-                    if let Some(right_variable) = right_variable.to_owned()
-                    {
-                      new_row.set(right_variable, right.to_owned().into())?;
-                    }
-                    if let Some(edge_variable) = edge_variable.to_owned()
-                    {
-                      new_row.set(edge_variable, edge.path.to_edge().into())?;
-                    }
-                    if let Some(path_variable) = path_variable.to_owned()
-                    {
-                      new_row.set(path_variable, edge.path.to_owned().into())?;
-                    }
-                    let should_add_row = if filter.is_empty()
-                    {
-                      true
-                    }
-                    else
-                    {
-                      let mut stack = Stack::default();
-                      stack.push(true);
-                      stack.push(edge.path.into_edge());
-                      eval_instructions(&mut stack, &new_row, filter, parameters)?;
-                      stack.try_pop()?; // Get rid of the edge
-                      stack.try_pop_into()?
-                    };
-                    if should_add_row
-                    {
-                      new_rows.push(new_row);
-                    }
-                  }
-                }
-              }
-            }
-            current_rows = new_rows;
+            current_rows = execute_block_match(
+              block,
+              store,
+              &mut tx,
+              &graph_name,
+              &mut stack,
+              parameters,
+              current_rows,
+              true, // recursive patterns allowed in MATCH
+            )?;
           }
           if !filter.is_empty()
           {
@@ -1445,7 +1763,7 @@ pub(crate) fn eval_program<TStore: store::Store>(
         let mut data = Vec::<crate::value::Value>::new();
         for row in output_table.into_row_iter()
         {
-          data.extend(row.into_iter());
+          data.extend(row);
         }
         tx.close()?;
         return Ok(graphcore::Table::new(headers, data)?.into());
@@ -1517,8 +1835,8 @@ pub(crate) fn eval_program<TStore: store::Store>(
             let value: value::Value = stack.try_pop_into()?;
             match value
             {
-              value::Value::Node(node) => nodes_keys.push(node.unpack().0),
-              value::Value::Edge(edge) => edges_keys.push(edge.unpack().0),
+              value::Value::Node(node) => nodes_keys.push(node.key()),
+              value::Value::Edge(edge) => edges_keys.push(edge.key()),
               value::Value::Null =>
               {}
               _ => return Err(RunTimeError::InvalidDelete.into()),
@@ -1530,7 +1848,7 @@ pub(crate) fn eval_program<TStore: store::Store>(
           &mut tx,
           &graph_name,
           store::SelectEdgeQuery::select_keys(edges_keys),
-          graph::EdgeDirectivity::Directed,
+          graphcore::EdgeDirectivity::Undirected,
         )?;
         store.delete_nodes(
           &mut tx,
@@ -1610,7 +1928,7 @@ pub(crate) fn eval_program<TStore: store::Store>(
                   }
                   value::Value::Null =>
                   {}
-                  _ => Err(InternalError::ExpectedEdge {
+                  _ => Err(RunTimeError::ExpectedEdge {
                     context: "evaluator/eval_program",
                   })?,
                 }
@@ -1660,7 +1978,7 @@ pub(crate) fn eval_program<TStore: store::Store>(
                   }
                   value::Value::Null =>
                   {}
-                  _ => Err(InternalError::ExpectedEdge {
+                  _ => Err(RunTimeError::ExpectedEdge {
                     context: "evaluator/eval_program",
                   })?,
                 }
@@ -1671,6 +1989,383 @@ pub(crate) fn eval_program<TStore: store::Store>(
         }
         input_table = output_table;
       }
+      instructions::Block::Merge {
+        match_blocks,
+        match_filter,
+        create_actions,
+        on_create_updates,
+        on_match_updates,
+        variables_size,
+      } =>
+      {
+        let mut output_table = value_table::ValueTable::new(variables_size.persistent_variables);
+
+        for row in input_table.into_row_iter()
+        {
+          // Step 1: Try to match the pattern using the compiled match blocks
+          let mut current_rows: Vec<_> = vec![row.clone().extended(variables_size.total_size())?];
+
+          for block in match_blocks.iter()
+          {
+            current_rows = execute_block_match(
+              block,
+              store,
+              &mut tx,
+              &graph_name,
+              &mut stack,
+              parameters,
+              current_rows,
+              false,
+            )?;
+          }
+
+          // Apply WHERE filter
+          let matched_rows = if !match_filter.is_empty()
+          {
+            filter_rows(current_rows.into_iter(), match_filter, parameters)?
+          }
+          else
+          {
+            current_rows
+          };
+
+          if matched_rows.is_empty()
+          {
+            // Step 2: No match - create new entities
+            let mut new_row = row.extended(variables_size.total_size())?;
+            for action in create_actions.iter()
+            {
+              eval_instructions(&mut stack, &new_row, &action.instructions, parameters)?;
+              for (v, var) in stack
+                .try_drain_into(action.variables.len())?
+                .into_iter()
+                .zip(action.variables.iter())
+              {
+                match v
+                {
+                  crate::value::Value::Node(n) =>
+                  {
+                    if n.properties().values().any(|v| v.is_null())
+                    {
+                      return Err(RunTimeError::MergeReadOwnWrites.into());
+                    }
+                    store.create_nodes(&mut tx, &graph_name, vec![&n])?;
+                    if let Some(var) = var.element
+                    {
+                      new_row.set_if_unset(
+                        var,
+                        crate::value::Value::Node(n.with_graph_name(graph_name.to_owned())),
+                      )?;
+                    }
+                  }
+                  crate::value::Value::SinglePath(p) =>
+                  {
+                    if p.to_edge().properties().values().any(|v| v.is_null())
+                    {
+                      return Err(RunTimeError::MergeReadOwnWrites.into());
+                    }
+                    store.create_edges(&mut tx, &graph_name, vec![p.as_ref()])?;
+
+                    match (var.element, var.path)
+                    {
+                      (Some(edge_var), Some(path_var)) =>
+                      {
+                        new_row.set(
+                          edge_var,
+                          crate::value::Value::Edge(
+                            p.clone().into_edge().with_graph_name(graph_name.to_owned()),
+                          ),
+                        )?;
+                        new_row.set(
+                          path_var,
+                          crate::value::Value::SinglePath(
+                            p.with_graph_name(graph_name.to_owned()).into(),
+                          ),
+                        )?;
+                      }
+                      (None, Some(path_var)) =>
+                      {
+                        new_row.set(path_var, crate::value::Value::SinglePath(p))?;
+                      }
+                      (Some(edge_var), None) =>
+                      {
+                        new_row.set(
+                          edge_var,
+                          crate::value::Value::Edge(
+                            p.into_edge().with_graph_name(graph_name.to_owned()),
+                          ),
+                        )?;
+                      }
+                      (None, None) =>
+                      {}
+                    }
+                  }
+                  _ =>
+                  {
+                    return Err(InternalError::Unimplemented("executor/eval/create").into());
+                  }
+                }
+              }
+            }
+
+            // Apply on_create updates
+            for update in on_create_updates.iter()
+            {
+              match update
+              {
+                instructions::UpdateOne::SetProperty {
+                  target,
+                  path,
+                  instructions,
+                } =>
+                {
+                  eval_update_property(
+                    store,
+                    &mut tx,
+                    &graph_name,
+                    &mut new_row,
+                    *target,
+                    path,
+                    instructions,
+                    parameters,
+                    true,
+                  )?;
+                }
+                instructions::UpdateOne::AddProperty {
+                  target,
+                  path,
+                  instructions,
+                } =>
+                {
+                  eval_update_property(
+                    store,
+                    &mut tx,
+                    &graph_name,
+                    &mut new_row,
+                    *target,
+                    path,
+                    instructions,
+                    parameters,
+                    false,
+                  )?;
+                }
+                instructions::UpdateOne::RemoveProperty { target, path } =>
+                {
+                  let var = new_row.get(*target)?;
+                  let mut piter = path.iter();
+                  match var
+                  {
+                    value::Value::Node(n) =>
+                    {
+                      let mut n = n.to_owned();
+                      n.properties_mut().remove_value(piter.next(), piter)?;
+                      store.update_node(&mut tx, &graph_name, &n)?;
+                      new_row.set(*target, n.into())?;
+                    }
+                    value::Value::Edge(e) =>
+                    {
+                      let mut e = e.to_owned();
+                      e.properties_mut().remove_value(piter.next(), piter)?;
+                      store.update_edge(&mut tx, &graph_name, &e)?;
+                      new_row.set(*target, e.into())?;
+                    }
+                    value::Value::Null =>
+                    {}
+                    _ => Err(RunTimeError::ExpectedEdge {
+                      context: "evaluator/eval_program",
+                    })?,
+                  }
+                }
+                instructions::UpdateOne::AddLabels { target, labels }
+                | instructions::UpdateOne::RemoveLabels { target, labels } =>
+                {
+                  let add_labels = match update
+                  {
+                    instructions::UpdateOne::AddLabels { .. } => true,
+                    instructions::UpdateOne::RemoveLabels { .. } => false,
+                    _ => Err(InternalError::Unreachable {
+                      context: "evaluator/eval_program/add_remove_labels",
+                    })?,
+                  };
+
+                  let var = new_row.get(*target)?;
+                  match var
+                  {
+                    value::Value::Node(n) =>
+                    {
+                      let mut n = n.to_owned();
+                      if add_labels
+                      {
+                        n.labels_mut().append(&mut labels.clone());
+                      }
+                      else
+                      {
+                        n.labels_edit(|l| l.into_iter().filter(|x| !labels.contains(x)).collect());
+                      }
+                      store.update_node(&mut tx, &graph_name, &n)?;
+                      new_row.set(*target, n.into())?;
+                    }
+                    value::Value::Edge(e) =>
+                    {
+                      let mut e = e.to_owned();
+                      if add_labels
+                      {
+                        e.labels_mut().append(&mut labels.clone());
+                      }
+                      else
+                      {
+                        e.labels_edit(|l| l.into_iter().filter(|x| !labels.contains(x)).collect());
+                      }
+                      store.update_edge(&mut tx, &graph_name, &e)?;
+                      new_row.set(*target, e.into())?;
+                    }
+                    value::Value::Null =>
+                    {}
+                    _ => Err(RunTimeError::ExpectedEdge {
+                      context: "evaluator/eval_program",
+                    })?,
+                  }
+                }
+              }
+            }
+
+            output_table.add_truncated_row(new_row)?;
+          }
+          else
+          {
+            // Step 3: Match succeeded - apply on_match updates to each matched row
+            for mut matched_row in matched_rows
+            {
+              for update in on_match_updates.iter()
+              {
+                match update
+                {
+                  instructions::UpdateOne::SetProperty {
+                    target,
+                    path,
+                    instructions,
+                  } =>
+                  {
+                    eval_update_property(
+                      store,
+                      &mut tx,
+                      &graph_name,
+                      &mut matched_row,
+                      *target,
+                      path,
+                      instructions,
+                      parameters,
+                      true,
+                    )?;
+                  }
+                  instructions::UpdateOne::AddProperty {
+                    target,
+                    path,
+                    instructions,
+                  } =>
+                  {
+                    eval_update_property(
+                      store,
+                      &mut tx,
+                      &graph_name,
+                      &mut matched_row,
+                      *target,
+                      path,
+                      instructions,
+                      parameters,
+                      false,
+                    )?;
+                  }
+                  instructions::UpdateOne::RemoveProperty { target, path } =>
+                  {
+                    let var = matched_row.get(*target)?;
+                    let mut piter = path.iter();
+                    match var
+                    {
+                      value::Value::Node(n) =>
+                      {
+                        let mut n = n.to_owned();
+                        n.properties_mut().remove_value(piter.next(), piter)?;
+                        store.update_node(&mut tx, &graph_name, &n)?;
+                        matched_row.set(*target, n.into())?;
+                      }
+                      value::Value::Edge(e) =>
+                      {
+                        let mut e = e.to_owned();
+                        e.properties_mut().remove_value(piter.next(), piter)?;
+                        store.update_edge(&mut tx, &graph_name, &e)?;
+                        matched_row.set(*target, e.into())?;
+                      }
+                      value::Value::Null =>
+                      {}
+                      _ => Err(RunTimeError::ExpectedEdge {
+                        context: "evaluator/eval_program",
+                      })?,
+                    }
+                  }
+                  instructions::UpdateOne::AddLabels { target, labels }
+                  | instructions::UpdateOne::RemoveLabels { target, labels } =>
+                  {
+                    let add_labels = match update
+                    {
+                      instructions::UpdateOne::AddLabels { .. } => true,
+                      instructions::UpdateOne::RemoveLabels { .. } => false,
+                      _ => Err(InternalError::Unreachable {
+                        context: "evaluator/eval_program/add_remove_labels",
+                      })?,
+                    };
+
+                    let var = matched_row.get(*target)?;
+                    match var
+                    {
+                      value::Value::Node(n) =>
+                      {
+                        let mut n = n.to_owned();
+                        if add_labels
+                        {
+                          n.labels_mut().append(&mut labels.clone());
+                        }
+                        else
+                        {
+                          n.labels_edit(|l| {
+                            l.into_iter().filter(|x| !labels.contains(x)).collect()
+                          });
+                        }
+                        store.update_node(&mut tx, &graph_name, &n)?;
+                        matched_row.set(*target, n.into())?;
+                      }
+                      value::Value::Edge(e) =>
+                      {
+                        let mut e = e.to_owned();
+                        if add_labels
+                        {
+                          e.labels_mut().append(&mut labels.clone());
+                        }
+                        else
+                        {
+                          e.labels_edit(|l| {
+                            l.into_iter().filter(|x| !labels.contains(x)).collect()
+                          });
+                        }
+                        store.update_edge(&mut tx, &graph_name, &e)?;
+                        matched_row.set(*target, e.into())?;
+                      }
+                      value::Value::Null =>
+                      {}
+                      _ => Err(RunTimeError::ExpectedEdge {
+                        context: "evaluator/eval_program",
+                      })?,
+                    }
+                  }
+                }
+              }
+              output_table.add_truncated_row(matched_row)?;
+            }
+          }
+        }
+
+        input_table = output_table;
+      }
       instructions::Block::Call { arguments: _, name } =>
       {
         if name == "gqlite.internal.stats"
@@ -1694,6 +2389,149 @@ pub(crate) fn eval_program<TStore: store::Store>(
           return Err(InternalError::Unimplemented("call for any other function").into());
         }
       }
+      instructions::Block::VectorSearch {
+        index,
+        query_instructions,
+        k,
+        out_node_col_id,
+        out_score_col_id,
+        variables_size,
+      } =>
+      {
+        let mut output_table = value_table::ValueTable::new(variables_size.persistent_variables);
+        for row in input_table.into_row_iter()
+        {
+          let mut query_stack = Stack::default();
+          eval_instructions(&mut query_stack, &row, query_instructions, parameters)?;
+
+          let query_tensor: value::Tensor = query_stack.try_pop_into()?;
+
+          let index_dimension = store
+            .list_vector_indexes(&mut tx, &graph_name)?
+            .into_iter()
+            .find(|spec| spec.name == *index)
+            .ok_or_else(|| {
+              StoreError::InvalidFormat(format!(
+                "Vector index '{}' does not exist in graph '{}'",
+                index, graph_name
+              ))
+            })?
+            .dimension;
+          if query_tensor.len() != index_dimension
+          {
+            return Err(
+              StoreError::InvalidFormat(format!(
+                "Vector dimension {} does not match index dimension {}",
+                query_tensor.len(),
+                index_dimension
+              ))
+              .into(),
+            );
+          }
+
+          // Perform vector search
+          let results = store.vector_search(&mut tx, &graph_name, index, &query_tensor, *k)?;
+
+          // Batch fetch all nodes using select_nodes by keys
+          let node_keys: Vec<crate::graph::Key> = results.iter().map(|r| r.node_id).collect();
+          let mut nodes_by_key = std::collections::HashMap::new();
+          if !node_keys.is_empty()
+          {
+            let nodes = store.select_nodes(
+              &mut tx,
+              &graph_name,
+              SelectNodeQuery::select_keys(node_keys),
+            )?;
+            for node in nodes
+            {
+              nodes_by_key.insert(node.key(), node);
+            }
+          }
+
+          // Add result rows to output table
+          for result in results
+          {
+            let mut out_row = row.clone().extended(variables_size.total_size())?;
+            // Look up the node from our pre-fetched map; skip the row if the node no longer
+            // exists (stale vector index entry from a deleted node)
+            if let Some(node) = nodes_by_key.get(&result.node_id)
+            {
+              out_row.set(*out_node_col_id, value::Value::Node(node.clone()))?;
+              if let Some(score_col_id) = out_score_col_id
+              {
+                out_row.set(*score_col_id, (result.score as f64).into())?;
+              }
+              output_table.add_truncated_row(out_row)?;
+            }
+          }
+        }
+        input_table = output_table;
+      }
+      instructions::Block::CreateVectorIndex {
+        name,
+        label,
+        property,
+        dimension,
+        metric,
+        if_not_exists,
+      } =>
+      {
+        let vector_metric = match metric
+        {
+          Some(gqlparser::oc::ast::Metric::Cosine) | None => store::VectorMetric::Cosine,
+          Some(gqlparser::oc::ast::Metric::L2) => store::VectorMetric::L2,
+          Some(gqlparser::oc::ast::Metric::DotProduct) => store::VectorMetric::DotProduct,
+        };
+        let spec = store::VectorIndexSpec {
+          name: name.clone(),
+          label: Some(label.clone()),
+          property: Some(property.clone()),
+          dimension: dimension.unwrap_or(0),
+          metric: vector_metric,
+          hnsw_params: Default::default(),
+          dtype: value::DType::F32,
+        };
+
+        let result = store.create_vector_index(&mut tx, &graph_name, spec);
+        match result
+        {
+          Ok(()) =>
+          {
+            let existing_nodes = store.select_nodes(
+              &mut tx,
+              &graph_name,
+              store::SelectNodeQuery::select_labels(vec![label.clone()]),
+            )?;
+
+            for node in existing_nodes
+            {
+              store.apply_vector_indices_for_node(&mut tx, &graph_name, &node)?;
+            }
+          }
+          Err(e) =>
+          {
+            if *if_not_exists
+            {
+              if let Error::StoreError(StoreError::DuplicatedVectorIndex { .. }) = e.error()
+              {
+                // silently skip — index already exists
+              }
+              else
+              {
+                return Err(e);
+              }
+            }
+            else
+            {
+              return Err(
+                error::map_error!(e, Error::StoreError(StoreError::DuplicatedVectorIndex { index_name }) => RunTimeError::DuplicatedVectorIndex {
+                  index_name: index_name.clone(),
+                }),
+              );
+            }
+          }
+        }
+      }
     }
   }
   tx.close()?;
@@ -1708,7 +2546,7 @@ mod tests
     prelude::*,
   };
 
-  use super::{execute_boolean_operator, TryPopInto};
+  use super::{TryPopInto, execute_boolean_operator};
 
   fn test_execute_boolean_operator_(
     instruction: &interpreter::instructions::Instruction,