gqlite 1.8.1 → 1.8.2

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

@@ -1,9 +1,10 @@
 use std::collections::{HashMap, HashSet};
 
-use rustc_hash::FxHashSet;
-
 use crate::{
-  interpreter::instructions::{Block, VariablesSizes},
+  interpreter::{
+    instructions::{Block, VariablesSizes},
+    path,
+  },
   prelude::*,
   store::{SelectNodeQuery, TransactionBoxable},
   value_table::{MutableRowInterface, Row, RowInterface},
@@ -12,7 +13,7 @@ use interpreter::instructions;
 
 #[derive(Debug, Clone)]
 #[allow(clippy::enum_variant_names)]
-enum Value
+pub(crate) enum Value
 {
   GraphValue(value::Value),
   NodeQuery(store::SelectNodeQuery),
@@ -157,18 +158,18 @@ macro_rules! contain_to_value {
 }
 
 #[derive(Default, Debug)]
-struct Stack
+pub(crate) struct Stack
 {
   stack: Vec<Value>,
 }
 
 impl Stack
 {
-  fn push(&mut self, value: impl Into<Value>)
+  pub(crate) fn push(&mut self, value: impl Into<Value>)
   {
     self.stack.push(value.into());
   }
-  fn try_pop(&mut self) -> Result<Value>
+  pub(crate) fn try_pop(&mut self) -> Result<Value>
   {
     self.stack.pop().ok_or(InternalError::EmptyStack.into())
   }
@@ -191,7 +192,7 @@ impl Stack
   {
     self.stack
   }
-  fn try_pop_as_boolean(&mut self) -> Result<bool>
+  pub(crate) fn try_pop_as_boolean(&mut self) -> Result<bool>
   {
     let v = self.try_pop()?;
     match v
@@ -205,7 +206,7 @@ impl Stack
   }
 }
 
-trait TryPopInto<T>
+pub(crate) trait TryPopInto<T>
 {
   fn try_pop_into(&mut self) -> Result<T>;
   fn try_drain_into(&mut self, n: usize) -> Result<Vec<T>>;
@@ -354,7 +355,7 @@ fn execute_string_operator(
   Ok(())
 }
 
-fn eval_instructions(
+pub(crate) fn eval_instructions(
   stack: &mut Stack,
   row: &impl value_table::RowInterface,
   instructions: &instructions::Instructions,
@@ -1228,6 +1229,39 @@ fn filter_rows(
     .collect()
 }
 
+/// Executes a chain of `BlockMatch` blocks sequentially against `current_rows`.
+/// Each block transforms the rows for the next block in the sequence.
+///
+/// This is the reusable helper for executing a `Vec<BlockMatch>` chain, used by
+/// `Block::Match` handlers, group-repetition steps (WI4), and similar contexts.
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn execute_block_matches<TStore: store::Store>(
+  blocks: &[instructions::BlockMatch],
+  store: &TStore,
+  tx: &mut TStore::TransactionBox,
+  graph_name: &str,
+  stack: &mut Stack,
+  parameters: &crate::value::ValueMap,
+  mut current_rows: Vec<value_table::Row>,
+  allow_recursive: bool,
+) -> Result<Vec<value_table::Row>>
+{
+  for block in blocks
+  {
+    current_rows = execute_block_match(
+      block,
+      store,
+      tx,
+      graph_name,
+      stack,
+      parameters,
+      current_rows,
+      allow_recursive,
+    )?;
+  }
+  Ok(current_rows)
+}
+
 /// Executes a single `BlockMatch` (node or edge) against every row in `current_rows`,
 /// appending matching rows into `new_rows`.
 ///
@@ -1290,309 +1324,34 @@ fn execute_block_match<TStore: store::Store>(
         }
       }
 
-      instructions::BlockMatch::MatchEdge {
-        instructions,
-        left_variable,
-        edge_variable,
-        right_variable,
-        path_variable,
-        filter,
-        directivity,
-        recursive_range,
-      } =>
+      instructions::BlockMatch::MatchEdge { .. } =>
       {
-        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;
-                }
+        super::path::execute_match_edge(
+          block,
+          store,
+          tx,
+          graph_name,
+          stack,
+          parameters,
+          &row,
+          allow_recursive,
+          &mut new_rows,
+        )?;
+      }
 
-                if let Some(frame) = push_next
-                {
-                  dfs_stack.push(frame);
-                  continue;
-                }
-              }
-            }
-          }
-        }
+      instructions::BlockMatch::MatchQuantifiedPath { .. } =>
+      {
+        path::execute_match_quantified_path(
+          block,
+          store,
+          tx,
+          graph_name,
+          stack,
+          parameters,
+          &row,
+          allow_recursive,
+          &mut new_rows,
+        )?;
       }
     }
   }
@@ -1770,20 +1529,17 @@ pub(crate) fn eval_program<TStore: store::Store>(
         let mut output_table = value_table::ValueTable::new(variables_size.persistent_variables);
         for row in input_table.into_row_iter()
         {
-          let mut current_rows: Vec<_> = vec![row.clone().extended(variables_size.total_size())?];
-          for block in blocks.iter()
-          {
-            current_rows = execute_block_match(
-              block,
-              store,
-              &mut tx,
-              &graph_name,
-              &mut stack,
-              parameters,
-              current_rows,
-              true, // recursive patterns allowed in MATCH
-            )?;
-          }
+          let current_rows: Vec<_> = vec![row.clone().extended(variables_size.total_size())?];
+          let mut current_rows = execute_block_matches(
+            blocks,
+            store,
+            &mut tx,
+            &graph_name,
+            &mut stack,
+            parameters,
+            current_rows,
+            true, // recursive patterns allowed in MATCH
+          )?;
           if !filter.is_empty()
           {
             current_rows = filter_rows(current_rows.into_iter(), filter, parameters)?;
@@ -2440,6 +2196,16 @@ pub(crate) fn eval_program<TStore: store::Store>(
           );
           return Ok(crate::value::Value::Map(res).into());
         }
+        else if name == "gqlite.db.list_graphs"
+        {
+          let mut graphs = store.graphs_list(&mut tx)?;
+          graphs.sort();
+          let list: Vec<crate::value::Value> = graphs
+            .into_iter()
+            .map(crate::value::Value::String)
+            .collect();
+          return Ok(crate::value::Value::Array(list).into());
+        }
         else
         {
           return Err(InternalError::Unimplemented("call for any other function").into());

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

@@ -1,5 +1,22 @@
 use crate::{prelude::*, value_table::ColId};
 
+#[derive(Debug)]
+pub(crate) enum StopCondition
+{
+  Shortest(Instructions),
+  ShortestGroups(Instructions),
+}
+
+#[derive(Debug)]
+pub(crate) enum PathStrategy
+{
+  Dfs,
+  Bfs
+  {
+    stop_condition: StopCondition,
+  },
+}
+
 #[derive(Debug)]
 #[allow(clippy::large_enum_variant)]
 pub(crate) enum Instruction
@@ -103,6 +120,7 @@ pub(crate) struct CreateAction
 }
 
 #[derive(Debug)]
+#[allow(clippy::enum_variant_names)]
 pub(crate) enum BlockMatch
 {
   MatchNode
@@ -122,6 +140,60 @@ pub(crate) enum BlockMatch
     directivity: graphcore::EdgeDirectivity,
     recursive_range: Option<std::ops::Range<usize>>,
   },
+  MatchQuantifiedPath
+  {
+    /// Compiled query for the group's fixed anchor before it (`qp.source`).
+    /// Pops one `SelectNodeQuery`, same as an ordinary `MatchNode`'s
+    /// `instructions` field — reuses `compile_match_node` directly (WI2).
+    source_instructions: Instructions,
+    source_variable: Option<ColId>,
+    source_filter: Instructions,
+    /// The destination node is validated only at emission time via
+    /// `destination_filter`, not queried from the store.
+    destination_variable: Option<ColId>,
+    destination_filter: Instructions,
+    /// The `p = ...` binding, if present.
+    path_variable: Option<ColId>,
+    /// Resolved `min..max` from `qp.quantifier` — always `Some` in
+    /// practice by the time this instruction exists (WI3 only ever
+    /// constructs one from a `QuantifiedPathPattern` with `group.len() > 1`,
+    /// and Milestone 2/4's `None`-quantifier scoping-wrapper use case,
+    /// design §1d, isn't reachable from real query text until Milestone 5).
+    quantifier: std::ops::Range<usize>,
+    /// The group's inner pattern sequence, compiled the same way an
+    /// ordinary top-level pattern chain is (WI2) — run once per repetition.
+    group_instructions: Vec<BlockMatch>,
+    /// Every variable declared inside the group (`n`, `r`, `m` for
+    /// `(a) ((n)-[r]->(m)){1,5} (b)`) — however many there are. Bound as a
+    /// list at execution (Epic 8); this field only declares *which*
+    /// columns need that treatment.
+    group_variables: Vec<ColId>,
+    /// Which entry in `group_variables` is the group's own terminal node
+    /// (the exit node of its last inner edge) - guaranteed present by the
+    /// parser-level fix. Used for chaining repetitions and for
+    /// checking `destination_filter`/binding `destination_variable`,
+    /// replacing the "first Node found" heuristic.
+    group_terminal_variable: ColId,
+    /// Which entry in `group_variables` is the group's own entry node
+    /// (the source node of its first inner edge) - guaranteed present by the
+    /// parser-level fix. Used to wire the previous repetition's terminal
+    /// to the next repetition's entry, so pattern search is constrained
+    /// from the current position rather than all nodes.
+    group_entry_variable: ColId,
+    /// Compiled group `WHERE`, if present (design §1, `qp.group_where`) —
+    /// evaluated once per repetition once Epic 8 wires up execution.
+    /// Genuine groups only; never `Some` on wrapper-promoted patterns.
+    group_where_filter: Option<Instructions>,
+    /// Whole-completed-path predicate, from the selector-scoped wrapper
+    /// (`qp.path_where`). Evaluated once a candidate reaches `destination`,
+    /// before it's admitted to shortest-path selection. Distinct from
+    /// `group_where_filter`'s per-repetition timing; never both `Some` on
+    /// the same instruction in practice (a wrapper-promoted pattern has no
+    /// genuine group `WHERE` of its own).
+    path_filter: Option<Instructions>,
+    /// The path strategy (Dfs or Bfs with stop condition) from the planner.
+    strategy: PathStrategy,
+  },
 }
 
 #[derive(Debug)]

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

@@ -1,4 +1,5 @@
 pub(crate) mod evaluators;
 pub(crate) mod instructions;
+pub(crate) mod path;
 
 pub(crate) type Program = Vec<instructions::Block>;