gqlite 1.8.0 → 1.8.2

data/ext/gqlitedb/src/planner.rs

@@ -6,6 +6,52 @@ use gqlparser::oc::ast;
 /// Ordered list of logical plans.
 pub type LogicalPlans = Vec<LogicalPlan>;
 
+#[derive(Debug, Clone, PartialEq)]
+pub enum StopCondition
+{
+  Shortest(ast::Expression),
+  ShortestGroups(ast::Expression),
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum PathStrategy
+{
+  Dfs,
+  Bfs
+  {
+    stop_condition: StopCondition,
+  },
+}
+
+/// A pattern the planner has finished with. `Node`/`Edge`/`Path` pass
+/// through unchanged — there's nothing to plan for them yet.
+/// `QuantifiedPath` carries the planner's own decision alongside the
+/// parsed pattern, so the compiler can never see one without the other.
+#[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum PlannedPattern
+{
+  Node(ast::NodePattern),
+  Edge(ast::EdgePattern),
+  Path(ast::PathPattern),
+  QuantifiedPath
+  {
+    pattern: ast::QuantifiedPathPattern,
+    strategy: PathStrategy,
+  },
+}
+
+impl PlannedPattern
+{
+  /// Convenience for call sites (mainly test fixtures) that just want to
+  /// carry an ordinary pattern through planning without constructing a
+  /// `PlannedPattern` variant by hand.
+  pub fn unplanned(pattern: ast::Pattern) -> Self
+  {
+    plan_pattern(pattern)
+  }
+}
+
 /// Logical representation of a statement.
 #[derive(Debug)]
 #[allow(clippy::large_enum_variant)]
@@ -37,13 +83,13 @@ pub enum LogicalPlan
   Create
   {
     /// Patterns to create.
-    patterns: Vec<ast::Pattern>,
+    patterns: Vec<PlannedPattern>,
   },
   /// Direct node scan produced from a MATCH clause.
   NodeScan
   {
     /// Patterns to match, including any label constraints present in the AST.
-    patterns: Vec<ast::Pattern>,
+    patterns: Vec<PlannedPattern>,
     /// Whether the scan is optional.
     optional: bool,
   },
@@ -89,6 +135,12 @@ pub enum LogicalPlan
     /// Limit expression.
     expression: ast::Expression,
   },
+  /// Make sure values only appear onces.
+  Distinct
+  {
+    /// Input operator.
+    source: Box<LogicalPlan>,
+  },
   /// Invoke a callable.
   Call
   {
@@ -123,7 +175,7 @@ pub enum LogicalPlan
   Merge
   {
     /// Patterns to match or create.
-    patterns: Vec<ast::Pattern>,
+    patterns: Vec<PlannedPattern>,
     /// Updates applied when entities are created.
     on_create: Vec<ast::OneUpdate>,
     /// Updates applied when entities are matched.
@@ -183,6 +235,172 @@ fn wrap_filter(plan: LogicalPlan, where_expression: Option<ast::Expression>) ->
   }
 }
 
+fn one_literal() -> ast::Expression
+{
+  ast::Value { value: 1i64.into() }.into()
+}
+
+pub(crate) fn choose_path_strategy(selector: &ast::PathSelector) -> PathStrategy
+{
+  match selector
+  {
+    ast::PathSelector::All => PathStrategy::Dfs,
+    ast::PathSelector::Any => PathStrategy::Bfs {
+      stop_condition: StopCondition::Shortest(one_literal()),
+    },
+    ast::PathSelector::AllShortest => PathStrategy::Bfs {
+      stop_condition: StopCondition::ShortestGroups(one_literal()),
+    },
+    ast::PathSelector::Shortest(k) => PathStrategy::Bfs {
+      stop_condition: StopCondition::Shortest(k.clone()),
+    },
+    ast::PathSelector::ShortestGroups(k) => PathStrategy::Bfs {
+      stop_condition: StopCondition::ShortestGroups(k.clone()),
+    },
+  }
+}
+
+/// The one place `choose_path_strategy` is called from. Every pattern
+/// that becomes part of a `LogicalPlan` goes through this.
+pub(crate) fn plan_pattern(pattern: ast::Pattern) -> PlannedPattern
+{
+  match pattern
+  {
+    ast::Pattern::Node(n) => PlannedPattern::Node(n),
+    ast::Pattern::Edge(e) => PlannedPattern::Edge(e),
+    ast::Pattern::Path(p) => PlannedPattern::Path(p),
+    ast::Pattern::QuantifiedPath(qp) if qp.quantifier.is_none() =>
+    {
+      // Selector-scoped pre-filter wrapper (design §1d): promote the
+      // inner content to a degenerate single-repetition quantified
+      // pattern if it isn't already quantified, then apply the outer
+      // selector's strategy to the result. The inner content's own
+      // `.selector` is always `All` in this construct (nothing in the
+      // grammar lets it be otherwise), so this is a plain override, not
+      // a merge.
+      let inner = qp
+        .group
+        .into_iter()
+        .next()
+        .expect("selector-scoped wrapper must have exactly one inner pattern");
+      let strategy = choose_path_strategy(&qp.selector);
+      match inner
+      {
+        ast::Pattern::QuantifiedPath(mut inner_qp) =>
+        {
+          // Already quantified (e.g. `--+`) — keep its own quantifier,
+          // just override the strategy. The wrapper's predicate becomes
+          // path_where (whole-path filter), not group_where (per-repetition).
+          inner_qp.variable = qp.variable.or(inner_qp.variable);
+          inner_qp.path_where = qp.group_where; // Wrapper predicate → path_where
+          PlannedPattern::QuantifiedPath {
+            pattern: inner_qp,
+            strategy,
+          }
+        }
+        other =>
+        {
+          // Not already quantified — promote to a degenerate
+          // exactly-one-repetition group. The wrapper's predicate becomes
+          // path_where (whole-path filter), not group_where (per-repetition).
+          let promoted = ast::QuantifiedPathPattern {
+            variable: qp.variable,
+            source: qp.source,
+            group: vec![other],
+            group_where: None, // Wrapper-promoted patterns never have group_where
+            path_where: qp.group_where, // Wrapper predicate → path_where
+            quantifier: Some(1..1),
+            destination: qp.destination,
+            selector: qp.selector,
+          };
+          PlannedPattern::QuantifiedPath {
+            pattern: promoted,
+            strategy,
+          }
+        }
+      }
+    }
+    ast::Pattern::QuantifiedPath(qp) if !matches!(qp.selector, ast::PathSelector::All) =>
+    {
+      // Selector-scoped pattern with selector override (e.g., SHORTEST 1).
+      // Two cases:
+      // 1. quantifier.is_none(): pre-filter wrapper with no inner quantifier,
+      //    needs promotion to 1..1 with inner pattern in group
+      // 2. quantifier.is_some(): already-quantified inner (like --+), wrapped
+      //    with a selector override. The quantifier is already set; just
+      //    apply the selector's strategy. Also move group_where to path_where
+      //    (whole-path filter) if present.
+      let strategy = choose_path_strategy(&qp.selector);
+
+      if qp.quantifier.is_some()
+      {
+        // Already has a quantifier (e.g., from --+ operator).
+        // Move group_where to path_where if present, then apply the strategy.
+        let mut pattern = qp;
+        if pattern.group_where.is_some()
+        {
+          pattern.path_where = pattern.group_where.take();
+        }
+        PlannedPattern::QuantifiedPath { pattern, strategy }
+      }
+      else
+      {
+        // Pre-filter wrapper with no inner quantifier.
+        // Extract and process the inner pattern.
+        let inner = qp
+          .group
+          .into_iter()
+          .next()
+          .expect("selector-scoped wrapper must have exactly one inner pattern");
+        match inner
+        {
+          ast::Pattern::QuantifiedPath(mut inner_qp) =>
+          {
+            // Already quantified — keep its own quantifier and override the strategy.
+            inner_qp.variable = qp.variable.or(inner_qp.variable);
+            inner_qp.path_where = qp.group_where; // Wrapper predicate → path_where
+            PlannedPattern::QuantifiedPath {
+              pattern: inner_qp,
+              strategy,
+            }
+          }
+          other =>
+          {
+            // Not already quantified — promote to a degenerate 1..1 group.
+            let promoted = ast::QuantifiedPathPattern {
+              variable: qp.variable,
+              source: qp.source,
+              group: vec![other],
+              group_where: None,
+              path_where: qp.group_where,
+              quantifier: Some(1..1),
+              destination: qp.destination,
+              selector: qp.selector,
+            };
+            PlannedPattern::QuantifiedPath {
+              pattern: promoted,
+              strategy,
+            }
+          }
+        }
+      }
+    }
+    ast::Pattern::QuantifiedPath(qp) =>
+    {
+      let strategy = choose_path_strategy(&qp.selector);
+      PlannedPattern::QuantifiedPath {
+        pattern: qp,
+        strategy,
+      }
+    }
+  }
+}
+
+pub(crate) fn plan_patterns(patterns: Vec<ast::Pattern>) -> Vec<PlannedPattern>
+{
+  patterns.into_iter().map(plan_pattern).collect()
+}
+
 fn wrap_modifiers(plan: LogicalPlan, modifiers: ast::Modifiers) -> LogicalPlan
 {
   let mut plan = plan;
@@ -211,6 +429,13 @@ fn wrap_modifiers(plan: LogicalPlan, modifiers: ast::Modifiers) -> LogicalPlan
     };
   }
 
+  if modifiers.distinct
+  {
+    plan = LogicalPlan::Distinct {
+      source: Box::new(plan),
+    }
+  }
+
   plan
 }
 
@@ -253,7 +478,7 @@ fn plan_impl(statement: ast::Statement) -> Result<LogicalPlan>
       name: use_graph.name,
     }),
     ast::Statement::Create(create) => Ok(LogicalPlan::Create {
-      patterns: create.patterns,
+      patterns: plan_patterns(create.patterns),
     }),
     ast::Statement::Match(match_statement) =>
     {
@@ -276,7 +501,7 @@ fn plan_impl(statement: ast::Statement) -> Result<LogicalPlan>
         // Standard node scan when no SEARCH
         Ok(wrap_filter(
           LogicalPlan::NodeScan {
-            patterns: match_statement.patterns,
+            patterns: plan_patterns(match_statement.patterns),
             optional: match_statement.optional,
           },
           match_statement.where_expression,
@@ -313,7 +538,7 @@ fn plan_impl(statement: ast::Statement) -> Result<LogicalPlan>
       updates: update_statement.updates,
     }),
     ast::Statement::Merge(merge_statement) => Ok(LogicalPlan::Merge {
-      patterns: merge_statement.patterns,
+      patterns: plan_patterns(merge_statement.patterns),
       on_create: merge_statement.on_create,
       on_match: merge_statement.on_match,
     }),

data/ext/gqlitedb/src/query_result.rs

@@ -1,7 +1,7 @@
 use graphcore::value_map;
 use itertools::Itertools as _;
 
-use crate::error::InternalError;
+use crate::error::Error;
 
 /// Hold the result of executing a query.
 #[derive(Debug, PartialEq, Clone)]
@@ -31,10 +31,25 @@ impl QueryResult
     }
   }
   /// Try convert into table
-  pub fn try_into_table(self) -> Result<graphcore::Table, InternalError>
+  pub fn try_into_table(self) -> Result<graphcore::Table, Error>
   {
     self.try_into()
   }
+
+  /// This is a convenience method for queries like `RETURN count(*) AS n`.
+  pub fn into_single_value<T>(self) -> Result<T, Error>
+  where
+    T: TryFrom<graphcore::Value>,
+    Error: From<<T as TryFrom<graphcore::Value>>::Error>,
+  {
+    let table = match self
+    {
+      QueryResult::Table(tbl) => tbl,
+      _ => return Err(crate::error::InternalError::InvalidQueryResultCast.into()),
+    };
+    let value = table.value(0, 0)?;
+    Ok(value.clone().try_into()?)
+  }
 }
 
 impl From<graphcore::Value> for QueryResult
@@ -55,13 +70,13 @@ impl From<graphcore::Table> for QueryResult
 
 impl TryInto<graphcore::Table> for QueryResult
 {
-  type Error = InternalError;
+  type Error = Error;
   fn try_into(self) -> Result<graphcore::Table, Self::Error>
   {
     match self
     {
       QueryResult::Table(tbl) => Ok(tbl),
-      _ => Err(InternalError::InvalidQueryResultCast),
+      _ => Err(crate::error::InternalError::InvalidQueryResultCast.into()),
     }
   }
 }

data/ext/gqlitedb/src/store/redb.rs

@@ -570,7 +570,7 @@ impl Store
   /// database forward exactly one step; the function recurses until `from` matches current.
   fn upgrade_database(&self, from: utils::Version, tx: &mut TransactionBox) -> Result<()>
   {
-    if from == consts::GQLITE_VERSION
+    if from.major == consts::GQLITE_VERSION.major && from.minor == consts::GQLITE_VERSION.minor
     {
       return Ok(());
     }