gqlite 1.8.0 → 1.8.2

data/ext/gqlitedb/src/interpreter/path/dfs.rs

@@ -0,0 +1,267 @@
+use rustc_hash::FxHashSet;
+
+use crate::{
+  graph,
+  interpreter::{
+    evaluators::{Stack, TryPopInto, eval_instructions},
+    instructions,
+    path::PathUniqueness,
+  },
+  prelude::*,
+  store,
+  value_table::{self, MutableRowInterface, RowInterface},
+};
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn execute<TStore: store::Store>(
+  recursive_range: &std::ops::Range<usize>,
+  query: &store::SelectEdgeQuery,
+  left_variable: &Option<value_table::ColId>,
+  edge_variable: &Option<value_table::ColId>,
+  right_variable: &Option<value_table::ColId>,
+  path_variable: &Option<value_table::ColId>,
+  filter: &instructions::Instructions,
+  directivity: graphcore::EdgeDirectivity,
+  store: &TStore,
+  tx: &mut TStore::TransactionBox,
+  graph_name: &str,
+  parameters: &crate::value::ValueMap,
+  row: &value_table::Row,
+  allow_recursive: bool,
+  new_rows: &mut Vec<value_table::Row>,
+  uniqueness: PathUniqueness,
+) -> Result<()>
+{
+  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 !uniqueness.is_reusable(&used_edges, &edge_key)
+          {
+            continue;
+          }
+
+          let next_node = if edge_result.reversed
+          {
+            edge_result.path.source().clone()
+          }
+          else
+          {
+            edge_result.path.destination().clone()
+          };
+
+          uniqueness.mark_used(&mut used_edges, 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.clone(),
+            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()
+        {
+          uniqueness.mark_unused(&mut used_edges, &last_edge.key());
+        }
+        continue;
+      }
+
+      if let Some(frame) = push_next
+      {
+        dfs_stack.push(frame);
+        continue;
+      }
+    }
+  }
+
+  Ok(())
+}

data/ext/gqlitedb/src/interpreter/path/group.rs

@@ -0,0 +1,418 @@
+use rustc_hash::FxHashSet;
+
+use crate::{
+  graph,
+  interpreter::{
+    evaluators::{Stack, eval_instructions},
+    instructions,
+    path::{self, PathUniqueness},
+  },
+  prelude::*,
+  store,
+  value_table::{self, MutableRowInterface, RowInterface},
+};
+
+struct Frame
+{
+  candidates: Vec<value_table::Row>,
+  candidate_index: usize,
+  depth: usize,
+  /// Edges marked as used when this frame was pushed.
+  /// Used during backtracking to unmark exactly the edges this frame consumed (WI#692).
+  edges_marked: Vec<graph::Key>,
+}
+
+/// Execute a quantified path pattern using list-capture (group repetition) strategy.
+///
+/// This generalizes the DFS traversal: instead of each frame representing "one next edge,"
+/// each frame represents "one candidate result from executing the group's group_instructions."
+/// Group variables are accumulated into lists, pushed/popped with the frame stack.
+///
+/// Design decisions (WI#672):
+/// 1. Edge detection: Extract edges at runtime by checking value types (Value::Edge)
+/// 2. group_where_filter: Evaluated before acceptance, pruning as traversal progresses
+/// 3. path_variable: Accumulated from edges in group variables (explicit edges only)
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn execute<TStore: store::Store>(
+  block: &instructions::BlockMatch,
+  store: &TStore,
+  tx: &mut TStore::TransactionBox,
+  graph_name: &str,
+  stack: &mut Stack,
+  parameters: &crate::value::ValueMap,
+  row: &value_table::Row,
+  allow_recursive: bool,
+  new_rows: &mut Vec<value_table::Row>,
+) -> Result<()>
+{
+  let instructions::BlockMatch::MatchQuantifiedPath {
+    source_instructions,
+    source_variable,
+    source_filter,
+    destination_variable,
+    destination_filter,
+    path_variable,
+    quantifier,
+    group_instructions,
+    group_variables,
+    group_terminal_variable,
+    group_entry_variable,
+    group_where_filter,
+    path_filter: _,
+    strategy: _,
+  } = block
+  else
+  {
+    unreachable!("execute called with a non-MatchQuantifiedPath block");
+  };
+
+  if !allow_recursive
+  {
+    return Err(InternalError::UnsupportedRecursivePatternInMerge.into());
+  }
+
+  let min_hops = quantifier.start;
+  let max_hops = quantifier.end;
+  let capacity = max_hops.min(100);
+
+  // Resolve start nodes via shared function
+  let start_nodes = path::resolve_start_nodes(
+    source_instructions,
+    source_variable,
+    source_filter,
+    store,
+    tx,
+    graph_name,
+    parameters,
+    row,
+  )?;
+
+  let uniqueness = PathUniqueness::Trail;
+
+  for start_node in start_nodes
+  {
+    let mut used_edges: FxHashSet<graph::Key> =
+      FxHashSet::with_capacity_and_hasher(capacity, Default::default());
+    let mut path_edges: Vec<graph::Edge> = Vec::with_capacity(capacity);
+    let mut group_lists: Vec<Vec<value::Value>> =
+      vec![Vec::with_capacity(capacity); group_variables.len()];
+
+    // Zero-repetition case: if min_hops == 0, the start node itself,
+    // with no edges traversed, is a valid match - nothing else in this
+    // function ever considers this, since initial_candidates always
+    // represents one repetition already completed.
+    if min_hops == 0
+    {
+      let mut zero_row = row.clone();
+      if let Some(sv) = source_variable
+      {
+        zero_row.set(*sv, start_node.clone().into())?;
+      }
+      for var_col in group_variables
+      {
+        zero_row.set(*var_col, value::Value::Array(Vec::new()))?;
+      }
+      if let Some(dv) = destination_variable
+      {
+        zero_row.set(*dv, start_node.clone().into())?;
+      }
+      if let Some(pv) = path_variable
+      {
+        zero_row.set(*pv, graph::Path::new(start_node.clone(), vec![]).into())?;
+      }
+      if path::check_destination_filter(destination_filter, &zero_row, parameters)?
+      {
+        new_rows.push(zero_row);
+      }
+    }
+
+    let mut position_row = row.clone();
+    if let Some(sv) = source_variable
+    {
+      position_row.set(*sv, start_node.clone().into())?;
+    }
+    // For the first iteration, set the group's entry point to the start node
+    // (compile_match_edge expects this column to be pre-populated with the source node)
+    position_row.set(*group_entry_variable, start_node.clone().into())?;
+
+    // Initial group execution from source node
+    let initial_candidates = crate::interpreter::evaluators::execute_block_matches(
+      group_instructions,
+      store,
+      tx,
+      graph_name,
+      stack,
+      parameters,
+      vec![position_row],
+      allow_recursive,
+    )?;
+
+    let mut dfs_stack: Vec<Frame> = vec![Frame {
+      candidates: initial_candidates.clone(),
+      candidate_index: 0,
+      // depth = number of real repetitions completed. initial_candidates
+      // is the result of ONE execution of group_instructions, so this is
+      // already 1 repetition done, not 0 - matching dfs.rs's convention
+      // where depth means "hops taken to reach this position."
+      depth: 1,
+      edges_marked: Vec::new(),
+    }];
+
+    while !dfs_stack.is_empty() && !initial_candidates.is_empty()
+    {
+      let mut push_next: Option<Frame> = None;
+      let mut should_pop = false;
+
+      {
+        let frame = dfs_stack.last_mut().unwrap();
+
+        // Emission: if depth >= min_hops and at start of candidate list, emit a row
+        if frame.candidate_index == 0 && frame.depth >= min_hops
+        {
+          // For emission, we need to include edges from the current frame's first candidate
+          // along with accumulated path_edges from previous frames.
+          let current_candidate = &frame.candidates[0];
+
+          // Check group_where_filter against the current candidate BEFORE emission.
+          // This prevents emitting candidates that don't satisfy the filter.
+          let should_emit = if let Some(gwf) = group_where_filter
+            && !gwf.is_empty()
+          {
+            let mut eval_stack = Stack::default();
+            eval_instructions(&mut eval_stack, current_candidate, gwf, parameters)?;
+            let passes: bool = eval_stack.try_pop_as_boolean()?;
+            passes
+          }
+          else
+          {
+            true
+          };
+
+          if should_emit
+          {
+            let mut new_row = row.clone();
+
+            // Save the start node's key - this is what the source should be bound to
+            let start_node_key = start_node.key();
+
+            // Bind source node
+            if let Some(sv) = source_variable
+            {
+              new_row.set(*sv, start_node.clone().into())?;
+            }
+
+            let mut emission_path_edges = path_edges.clone();
+            let mut emission_group_lists = group_lists.clone();
+
+            // Extract edges from current frame's first candidate
+            for (var_idx, var_col) in group_variables.iter().enumerate()
+            {
+              if let Ok(val) = current_candidate.get(*var_col)
+              {
+                emission_group_lists[var_idx].push(val.clone());
+                if let value::Value::Edge(edge) = val
+                {
+                  emission_path_edges.push(edge.clone());
+                }
+              }
+            }
+
+            // BEFORE overwriting group_variables with arrays, extract and bind destination/path
+            // using the shared function to ensure consistent logic across strategies
+            let (terminal_node, path) = path::bind_destination_and_path(
+              current_candidate,
+              *group_terminal_variable,
+              group_variables,
+              &emission_path_edges,
+              &start_node,
+            );
+
+            // NOW overwrite group variables with their accumulated arrays,
+            // except for source/destination which stay as scalars
+            for (var_idx, var_col) in group_variables.iter().enumerate()
+            {
+              // Skip wrapping source and destination columns - they're already bound
+              // as scalars and should not be overwritten as arrays
+              if Some(*var_col) == *source_variable || Some(*var_col) == *destination_variable
+              {
+                continue;
+              }
+
+              new_row.set(
+                *var_col,
+                value::Value::Array(emission_group_lists[var_idx].clone()),
+              )?;
+            }
+
+            // Save the terminal_node's key BEFORE it gets moved
+            let terminal_node_key = terminal_node.as_ref().map(|n| n.key());
+
+            // Bind destination node (using pre-computed terminal_node)
+            if let Some(dv) = destination_variable
+              && let Some(node) = terminal_node
+            {
+              new_row.set(*dv, node.into())?;
+            }
+
+            // Bind path variable (using pre-computed path)
+            if let Some(pv) = path_variable
+              && let Some(path_value) = path
+            {
+              new_row.set(*pv, path_value.into())?;
+            }
+
+            // Apply destination_filter before emission using shared function
+            let passes_destination_filter =
+              path::check_destination_filter(destination_filter, &new_row, parameters)?;
+
+            // When destination_filter is empty (meaning the destination variable was already set),
+            // and the source and destination variables are the same column, check that the
+            // destination node equals the start node (for patterns like "(a) ... (a)").
+            let is_same_variable_different_nodes = if destination_filter.is_empty()
+              && source_variable.is_some()
+              && source_variable == destination_variable
+            {
+              // The destination (terminal_node) must equal the start node
+              if let Some(tnk) = terminal_node_key
+              {
+                tnk != start_node_key
+              }
+              else
+              {
+                false
+              }
+            }
+            else
+            {
+              false
+            };
+
+            if passes_destination_filter && !is_same_variable_different_nodes
+            {
+              new_rows.push(new_row);
+            }
+          }
+        }
+
+        // Stop condition
+        if frame.depth == max_hops || frame.candidate_index >= frame.candidates.len()
+        {
+          should_pop = true;
+        }
+        else
+        {
+          // Advance: process next candidate
+          let mut candidate_row = frame.candidates[frame.candidate_index].clone();
+          frame.candidate_index += 1;
+
+          // Extract edges from this candidate using shared function
+          let candidate_edges = path::extract_edges(&candidate_row, group_variables);
+
+          // Check uniqueness: all edges must be available
+          let all_available = candidate_edges
+            .iter()
+            .all(|ek| uniqueness.is_reusable(&used_edges, ek));
+
+          if !all_available
+          {
+            continue;
+          }
+
+          // Check group_where_filter if present (pruning before acceptance)
+          if let Some(gwf) = group_where_filter
+            && !gwf.is_empty()
+          {
+            let mut eval_stack = Stack::default();
+            eval_instructions(&mut eval_stack, &candidate_row, gwf, parameters)?;
+            let passes: bool = eval_stack.try_pop_as_boolean()?;
+            if !passes
+            {
+              continue;
+            }
+          }
+
+          // Mark edges as used and push values onto lists
+          for edge_key in &candidate_edges
+          {
+            uniqueness.mark_used(&mut used_edges, *edge_key);
+          }
+
+          for (var_idx, var_col) in group_variables.iter().enumerate()
+          {
+            if let Ok(val) = candidate_row.get(*var_col)
+            {
+              group_lists[var_idx].push(val.clone());
+
+              // If it's an edge, add to path_edges
+              if let value::Value::Edge(edge) = val
+              {
+                path_edges.push(edge.clone());
+              }
+            }
+          }
+
+          // Repetition N's landing point becomes repetition N+1's starting point.
+          // Nothing does this automatically - group_entry_variable and
+          // group_terminal_variable are different columns.
+          let terminal_value = candidate_row.get(*group_terminal_variable)?.clone();
+          candidate_row.set(*group_entry_variable, terminal_value)?;
+
+          // Execute group_instructions for next frame
+          let next_candidates = crate::interpreter::evaluators::execute_block_matches(
+            group_instructions,
+            store,
+            tx,
+            graph_name,
+            stack,
+            parameters,
+            vec![candidate_row],
+            allow_recursive,
+          )?;
+
+          if !next_candidates.is_empty()
+          {
+            push_next = Some(Frame {
+              candidates: next_candidates,
+              candidate_index: 0,
+              depth: frame.depth + 1,
+              edges_marked: candidate_edges.clone(),
+            });
+          }
+        }
+      }
+
+      // Backtrack
+      if should_pop
+      {
+        // Get the current frame before popping to access edges_marked
+        if let Some(current_frame) = dfs_stack.pop()
+        {
+          // Pop group variables and path edges for each edge marked by this frame (WI#692)
+          for list in &mut group_lists
+          {
+            list.pop();
+          }
+
+          // Unmark all edges that this frame marked (in reverse order for path_edges)
+          for edge_key in current_frame.edges_marked.iter().rev()
+          {
+            if path_edges.pop().is_some()
+            {
+              uniqueness.mark_unused(&mut used_edges, edge_key);
+            }
+          }
+        }
+        continue;
+      }
+
+      // Push next frame
+      if let Some(frame) = push_next
+      {
+        dfs_stack.push(frame);
+        continue;
+      }
+    }
+  }
+
+  Ok(())
+}