gqlite 1.8.0 → 1.8.2

data/ext/gqlitedb/src/compiler.rs

@@ -3,13 +3,13 @@ use gqlparser::oc::ast;
 use crate::{
   compiler::{expression_analyser::ExpressionType, variables_manager::VariablesManager},
   interpreter::instructions::{CreateActionVariable, VariablesSizes},
-  planner::{LogicalPlan, LogicalPlans, ProjectionKind},
+  planner::{self, LogicalPlan, LogicalPlans, ProjectionKind},
   prelude::*,
 };
 
 use interpreter::instructions::{
-  self, Block, BlockMatch, CreateAction, Instruction, Instructions, Modifiers, RWAggregation,
-  RWExpression,
+  self, Block, BlockMatch, CreateAction, Instruction, Instructions, Modifiers, PathStrategy,
+  RWAggregation, RWExpression, StopCondition,
 };
 
 pub(crate) mod expression_analyser;
@@ -49,6 +49,59 @@ fn is_scan_plan(plan: &LogicalPlan) -> bool
   }
 }
 
+fn collect_pattern_variables(patterns: &[ast::Pattern]) -> Vec<ast::VariableIdentifier>
+{
+  let mut variables = Vec::new();
+  for pattern in patterns
+  {
+    match pattern
+    {
+      ast::Pattern::Node(n) => variables.extend(n.variable.clone()),
+      ast::Pattern::Edge(e) =>
+      {
+        variables.extend(e.source.variable.clone());
+        variables.extend(e.variable.clone());
+        variables.extend(e.destination.variable.clone());
+      }
+      ast::Pattern::Path(p) => variables.push(p.variable.clone()),
+      ast::Pattern::QuantifiedPath(qp) =>
+      {
+        variables.extend(qp.variable.clone());
+        variables.extend(collect_pattern_variables(&qp.group));
+      }
+    }
+  }
+  variables
+}
+
+/// If this QuantifiedPathPattern is a "plain" single-edge quantifier -
+/// group.len() == 1, and the group's own edge already has
+/// qp.source/qp.destination as its source/destination (Epic 2's
+/// original construction) - returns that edge. Returns None for
+/// everything else: multi-element groups, or explicit group syntax
+/// where the group's own nodes differ from the outer anchors.
+pub(super) fn as_plain_quantifier(qp: &ast::QuantifiedPathPattern) -> Option<&ast::EdgePattern>
+{
+  if qp.group.len() != 1
+  {
+    return None;
+  }
+  let ast::Pattern::Edge(inner_edge) = &qp.group[0]
+  else
+  {
+    return None;
+  };
+  if inner_edge.source.variable == qp.source.variable
+    && inner_edge.destination.variable == qp.destination.variable
+  {
+    Some(inner_edge)
+  }
+  else
+  {
+    None
+  }
+}
+
 struct Compiler
 {
   function_manager: functions::Manager,
@@ -74,6 +127,35 @@ impl Compiler
     col_id + self.variables_manager.variables_count()
   }
 
+  fn compile_path_strategy(&mut self, strategy: &planner::PathStrategy) -> Result<PathStrategy>
+  {
+    match strategy
+    {
+      planner::PathStrategy::Dfs => Ok(PathStrategy::Dfs),
+      planner::PathStrategy::Bfs { stop_condition } =>
+      {
+        let compiled_stop_condition = match stop_condition
+        {
+          planner::StopCondition::Shortest(expr) =>
+          {
+            let mut instructions = Instructions::new();
+            self.compile_expression(expr, &mut instructions, &mut None)?;
+            StopCondition::Shortest(instructions)
+          }
+          planner::StopCondition::ShortestGroups(expr) =>
+          {
+            let mut instructions = Instructions::new();
+            self.compile_expression(expr, &mut instructions, &mut None)?;
+            StopCondition::ShortestGroups(instructions)
+          }
+        };
+        Ok(PathStrategy::Bfs {
+          stop_condition: compiled_stop_condition,
+        })
+      }
+    }
+  }
+
   fn compile_expression(
     &mut self,
     expression: &gqlparser::oc::ast::Expression,
@@ -132,6 +214,7 @@ impl Compiler
                   init_instructions,
                   aggregator,
                   argument_instructions,
+                  distinct: function_call.distinct,
                 },
               ));
             Instruction::GetVariable { col_id: var_col_id }
@@ -317,6 +400,21 @@ impl Compiler
         instructions.push(Instruction::IsNullUnaryOperator);
         Instruction::NotUnaryOperator
       }
+      ast::Expression::Contains(contains) =>
+      {
+        compile_binary_op!(self, contains, instructions, aggregations);
+        Instruction::StringContainsOperator
+      }
+      ast::Expression::StartsWith(starts_with) =>
+      {
+        compile_binary_op!(self, starts_with, instructions, aggregations);
+        Instruction::StringStartsWithOperator
+      }
+      ast::Expression::EndsWith(ends_with) =>
+      {
+        compile_binary_op!(self, ends_with, instructions, aggregations);
+        Instruction::StringEndsWithOperator
+      }
     };
     instructions.push(expr);
     Ok(())
@@ -425,11 +523,6 @@ impl Compiler
       .variables_manager
       .mark_variables_as_set(&edge.variable)?;
     self.compile_optional_expression(&edge.properties, instructions)?;
-    // Reject variable-length relationships in CREATE statements
-    if edge.recursive_range.is_some()
-    {
-      return Err(CompileTimeError::CreatingVarLength.into());
-    }
     if !edge.labels.is_string()
     {
       Err(CompileTimeError::NoSingleRelationshipType {
@@ -545,7 +638,7 @@ impl Compiler
 
   fn compile_create_patterns(
     &mut self,
-    patterns: impl IntoIterator<Item = gqlparser::oc::ast::Pattern>,
+    patterns: impl IntoIterator<Item = planner::PlannedPattern>,
   ) -> Result<Block>
   {
     let actions = patterns.into_iter().map(|c| {
@@ -553,15 +646,15 @@ impl Compiler
       let mut variables = Vec::<CreateActionVariable>::new();
       match c
       {
-        gqlparser::oc::ast::Pattern::Node(node) =>
+        planner::PlannedPattern::Node(node) =>
         {
           self.compile_create_node(node, &mut instructions, &mut variables)?;
         }
-        gqlparser::oc::ast::Pattern::Edge(edge) =>
+        planner::PlannedPattern::Edge(edge) =>
         {
           self.compile_create_edge(edge, &mut instructions, &mut variables, None)?;
         }
-        gqlparser::oc::ast::Pattern::Path(path) =>
+        planner::PlannedPattern::Path(path) =>
         {
           self
             .variables_manager
@@ -573,6 +666,10 @@ impl Compiler
             Some(path.variable),
           )?;
         }
+        planner::PlannedPattern::QuantifiedPath { .. } =>
+        {
+          return Err(CompileTimeError::CreatingVarLength.into());
+        }
       }
       Ok(CreateAction {
         instructions,
@@ -619,6 +716,26 @@ impl Compiler
       filter.push(Instruction::AndBinaryOperator);
       filter.push(Instruction::Swap);
     }
+    if let Some(predicate) = &node.predicate
+    {
+      self.compile_expression(predicate, filter, &mut None)?;
+      // When there are no labels, we use InverseRot3 to combine the predicate result
+      // with the passes_so_far/candidate stack (same as the label loop does).
+      // When there are labels, the outer code already uses Rot3, so we only
+      // apply these stack operations if there were no labels.
+      if node.labels.is_all_inclusive()
+      {
+        filter.push(Instruction::InverseRot3);
+        filter.push(Instruction::AndBinaryOperator);
+        filter.push(Instruction::Swap);
+      }
+      else
+      {
+        filter.push(Instruction::Rot3);
+        filter.push(Instruction::AndBinaryOperator);
+        filter.push(Instruction::Swap);
+      }
+    }
     instructions.push(Instruction::CreateNodeQuery { labels });
     Ok(())
   }
@@ -629,6 +746,7 @@ impl Compiler
     edge: &gqlparser::oc::ast::EdgePattern,
     single_match: bool,
     previous_edges: &mut Vec<usize>,
+    recursive_range: Option<std::ops::Range<usize>>,
   ) -> Result<BlockMatch>
   {
     let mut instructions = Instructions::new();
@@ -681,6 +799,15 @@ impl Compiler
     }
     if self.variables_manager.is_set_variable(&edge.variable)?
     {
+      // Predicates on reused edge variables are not supported.
+      // This intentionally diverges from the silent-ignore behavior for
+      // `properties` on reused variables: predicates represent load-bearing
+      // user intent (a filter condition), whereas redundant properties on a
+      // reused variable are more likely user error that's safe to ignore.
+      if edge.predicate.is_some()
+      {
+        return Err(CompileTimeError::InvalidArgumentType.into());
+      }
       instructions.push(Instruction::GetVariable {
         col_id: self
           .variables_manager
@@ -707,6 +834,23 @@ impl Compiler
         filter.push(Instruction::AndBinaryOperator);
         filter.push(Instruction::Swap);
       }
+      if let Some(predicate) = &edge.predicate
+      {
+        self.compile_expression(predicate, &mut filter, &mut None)?;
+        // Same logic as compile_match_node: use InverseRot3 when there are no labels
+        if edge.labels.is_all_inclusive()
+        {
+          filter.push(Instruction::InverseRot3);
+          filter.push(Instruction::AndBinaryOperator);
+          filter.push(Instruction::Swap);
+        }
+        else
+        {
+          filter.push(Instruction::Rot3);
+          filter.push(Instruction::AndBinaryOperator);
+          filter.push(Instruction::Swap);
+        }
+      }
       instructions.push(Instruction::CreateEdgeQuery { labels });
     }
 
@@ -764,7 +908,281 @@ impl Compiler
         .get_variable_index_option(&path_variable)?,
       filter,
       directivity: edge.directivity,
-      recursive_range: edge.recursive_range.clone(),
+      recursive_range,
+    })
+  }
+
+  fn compile_quantified_path(
+    &mut self,
+    qp: ast::QuantifiedPathPattern,
+    strategy: &planner::PathStrategy,
+  ) -> Result<BlockMatch>
+  {
+    let mut source_instructions = Instructions::new();
+    let mut source_filter = Instructions::new();
+    let source_variable = qp.source.variable.clone();
+    if !self
+      .variables_manager
+      .is_set_variable(&qp.source.variable)?
+    {
+      self.compile_match_node(
+        &qp.source,
+        &mut source_instructions,
+        &mut source_filter,
+        None,
+      )?;
+    }
+
+    let destination_variable = qp.destination.variable.clone();
+    let mut destination_filter = Instructions::new();
+    let is_dest_set = self
+      .variables_manager
+      .is_set_variable(&qp.destination.variable)?;
+    if !is_dest_set
+    {
+      // Do NOT call compile_match_node here. Its filter output assumes it's being
+      // appended into an already-running stack-based accumulator (with Duplicate/Rot3/Swap
+      // instructions). check_destination_filter always starts from a fresh, empty stack.
+      // This is a fundamental contract mismatch. Instead, build destination_filter
+      // directly as a standalone, empty-stack-starting boolean check.
+
+      let dest_col = match &qp.destination.variable
+      {
+        Some(var_id) => self.variables_manager.get_variable_index(var_id)?,
+        None =>
+        {
+          return Err(
+            error::InternalError::Unreachable {
+              context: "compile_quantified_path: destination.variable should always be Some",
+            }
+            .into(),
+          );
+        }
+      };
+
+      let mut checks: Vec<Instructions> = Vec::new();
+
+      // Build label check
+      if !matches!(qp.destination.labels, ast::LabelExpression::None)
+      {
+        let mut label_check = Instructions::new();
+        label_check.push(Instruction::GetVariable { col_id: dest_col });
+        let has_label_function = self
+          .function_manager
+          .get_function::<CompileTimeError>("has_label")?;
+        Self::compile_filter_labels(
+          &mut label_check,
+          &qp.destination.labels,
+          &has_label_function,
+        )?;
+        checks.push(label_check);
+      }
+
+      // Build property checks
+      if let Some(properties) = &qp.destination.properties
+      {
+        if let ast::Expression::Map(map) = properties
+        {
+          for (key, value_expr) in &map.map
+          {
+            let mut prop_check = Instructions::new();
+            prop_check.push(Instruction::GetVariable { col_id: dest_col });
+            prop_check.push(Instruction::MemberAccess {
+              path: vec![key.clone()],
+            });
+            self.compile_expression(value_expr, &mut prop_check, &mut None)?;
+            prop_check.push(Instruction::EqualBinaryOperator);
+            checks.push(prop_check);
+          }
+        }
+        else
+        {
+          // Non-Map properties expressions (parameters, variables, etc.) not yet supported
+          return Err(error::InternalError::Unreachable {
+            context: "compile_quantified_path: destination properties as non-Map expression not yet supported for destination_filter",
+          }
+          .into());
+        }
+      }
+
+      // Build predicate (WHERE) check
+      if let Some(predicate) = &qp.destination.predicate
+      {
+        let mut pred_check = Instructions::new();
+        self.compile_expression(predicate, &mut pred_check, &mut None)?;
+        checks.push(pred_check);
+      }
+
+      // Combine all checks with AND
+      for (i, check) in checks.into_iter().enumerate()
+      {
+        destination_filter.extend(check);
+        if i > 0
+        {
+          destination_filter.push(Instruction::AndBinaryOperator);
+        }
+      }
+    }
+
+    // Mark the group's own entry point as already-bound BEFORE compiling
+    // group_instructions - this tells compile_match_edge to generate GetVariable
+    // instructions instead of unconstrained CreateNodeQuery, so the source node
+    // will be constrained to whatever value is in that column at runtime.
+    let group_entry_variable_identifier = qp
+      .group
+      .first()
+      .and_then(|p| {
+        match p {
+          ast::Pattern::Node(n) => n.variable.clone(),
+          ast::Pattern::Edge(e) => e.source.variable.clone(),
+          _ => None,
+        }
+      })
+      .ok_or_else(|| error::InternalError::Unreachable {
+        context: "compile_quantified_path: group should start with a node or edge (guaranteed by parser)",
+      })?;
+    self
+      .variables_manager
+      .mark_variables_as_set(&Some(group_entry_variable_identifier.clone()))?;
+    let group_entry_variable = self
+      .variables_manager
+      .get_variable_index(&group_entry_variable_identifier)?;
+
+    // For bare quantifiers (where the group's terminal node is the same as the
+    // outer destination), create a modified group with unconstrained destination
+    // nodes. This prevents compile_match_edge from baking qp.destination's
+    // constraints into every per-hop edge query.
+    let group_terminal_variable_identifier = qp
+      .group
+      .iter()
+      .rev()
+      .find_map(|p| {
+        if let ast::Pattern::Edge(e) = p {
+          e.destination.variable.clone()
+        } else {
+          None
+        }
+      })
+      .ok_or_else(|| error::InternalError::Unreachable {
+        context: "compile_quantified_path: group should have at least one edge (guaranteed by parser)",
+      })?;
+
+    let modified_group = if Some(&group_terminal_variable_identifier)
+      == qp.destination.variable.as_ref()
+      && (qp.destination.labels != ast::LabelExpression::None
+        || qp.destination.properties.is_some()
+        || qp.destination.predicate.is_some())
+    {
+      // Create a copy of the group with unconstrained destination
+      qp.group
+        .iter()
+        .map(|p| {
+          if let ast::Pattern::Edge(e) = p
+          {
+            let mut modified_edge = e.clone();
+            // Strip constraints from destination while keeping the variable name
+            modified_edge.destination = ast::NodePattern {
+              variable: modified_edge.destination.variable.clone(),
+              labels: ast::LabelExpression::None,
+              properties: None,
+              predicate: None,
+            };
+            ast::Pattern::Edge(modified_edge)
+          }
+          else
+          {
+            p.clone()
+          }
+        })
+        .collect()
+    }
+    else
+    {
+      qp.group.clone()
+    };
+
+    let group_variable_identifiers = collect_pattern_variables(&modified_group);
+    let planned_group = planner::plan_patterns(modified_group.clone());
+    let group_instructions = self.compile_pattern_blocks(&planned_group)?;
+    let group_variables = group_variable_identifiers
+      .iter()
+      .map(|v| self.variables_manager.get_variable_index(v))
+      .collect::<Result<Vec<_>>>()?;
+
+    // Find the terminal variable: the destination of the last edge in the group
+    let group_terminal_variable = self
+      .variables_manager
+      .get_variable_index(&group_terminal_variable_identifier)?;
+
+    let group_where_filter = match &qp.group_where
+    {
+      Some(expr) =>
+      {
+        let mut instructions = Instructions::new();
+        self.compile_expression(expr, &mut instructions, &mut None)?;
+        Some(instructions)
+      }
+      None => None,
+    };
+
+    let path_filter = match &qp.path_where
+    {
+      Some(expr) =>
+      {
+        let mut instructions = Instructions::new();
+        self.compile_expression(expr, &mut instructions, &mut None)?;
+        Some(instructions)
+      }
+      None => None,
+    };
+
+    let path_variable_opt = qp.variable.clone();
+    let path_variable = path_variable_opt
+      .as_ref()
+      .map(|v| self.variables_manager.get_variable_index(v))
+      .transpose()?;
+
+    // Mark all pattern variables as set (same as compile_match_edge does)
+    self
+      .variables_manager
+      .mark_variables_as_set(&source_variable)?;
+    self
+      .variables_manager
+      .mark_variables_as_set(&destination_variable)?;
+    self
+      .variables_manager
+      .mark_variables_as_set(&path_variable_opt)?;
+    for var in &group_variable_identifiers
+    {
+      self
+        .variables_manager
+        .mark_variables_as_set(&Some(var.clone()))?;
+    }
+
+    let compiled_strategy = self.compile_path_strategy(strategy)?;
+
+    Ok(BlockMatch::MatchQuantifiedPath {
+      source_instructions,
+      source_variable: source_variable
+        .map(|v| self.variables_manager.get_variable_index(&v))
+        .transpose()?,
+      source_filter,
+      destination_variable: destination_variable
+        .map(|v| self.variables_manager.get_variable_index(&v))
+        .transpose()?,
+      destination_filter,
+      path_variable,
+      quantifier: qp.quantifier.expect(
+        "compile_quantified_path called with quantifier: None — the pre-filter \
+         scoping-wrapper use (design §1d) isn't reachable until Milestone 5",
+      ),
+      group_instructions,
+      group_variables,
+      group_terminal_variable,
+      group_entry_variable,
+      group_where_filter,
+      path_filter,
+      strategy: compiled_strategy,
     })
   }
 
@@ -853,45 +1271,77 @@ impl Compiler
     })
   }
 
-  fn compile_match_patterns(
+  fn compile_pattern_blocks(
     &mut self,
-    patterns: &[gqlparser::oc::ast::Pattern],
-    where_expression: &Option<gqlparser::oc::ast::Expression>,
-    optional: bool,
-  ) -> Result<Block>
+    patterns: &[planner::PlannedPattern],
+  ) -> Result<Vec<BlockMatch>>
   {
     let is_single_match = patterns.len() == 1;
     let mut edge_variables = vec![];
-    let blocks = patterns.iter().map(|c| match c
-    {
-      gqlparser::oc::ast::Pattern::Node(node) =>
+    patterns
+      .iter()
+      .map(|c| match c
       {
-        let mut instructions = Instructions::new();
-        let mut filter = Instructions::new();
-        self.compile_match_node(node, &mut instructions, &mut filter, None)?;
-        self
-          .variables_manager
-          .mark_variables_as_set(&node.variable)?;
-        Ok(BlockMatch::MatchNode {
-          instructions,
-          variable: self
+        planner::PlannedPattern::Node(node) =>
+        {
+          let mut instructions = Instructions::new();
+          let mut filter = Instructions::new();
+          self.compile_match_node(node, &mut instructions, &mut filter, None)?;
+          self
             .variables_manager
-            .get_variable_index_option(&node.variable)?,
-          filter,
-        })
-      }
-      gqlparser::oc::ast::Pattern::Edge(edge) =>
-      {
-        self.compile_match_edge(None, edge, is_single_match, &mut edge_variables)
-      }
-      gqlparser::oc::ast::Pattern::Path(path) => self.compile_match_edge(
-        Some(path.variable.to_owned()),
-        &path.edge,
-        is_single_match,
-        &mut edge_variables,
-      ),
-    });
-    let blocks = blocks.collect::<Result<_>>()?;
+            .mark_variables_as_set(&node.variable)?;
+          Ok(BlockMatch::MatchNode {
+            instructions,
+            variable: self
+              .variables_manager
+              .get_variable_index_option(&node.variable)?,
+            filter,
+          })
+        }
+        planner::PlannedPattern::Edge(edge) =>
+        {
+          self.compile_match_edge(None, edge, is_single_match, &mut edge_variables, None)
+        }
+        planner::PlannedPattern::Path(path) => self.compile_match_edge(
+          Some(path.variable.to_owned()),
+          &path.edge,
+          is_single_match,
+          &mut edge_variables,
+          None,
+        ),
+        planner::PlannedPattern::QuantifiedPath {
+          pattern: qp,
+          strategy,
+        } =>
+        {
+          if let Some(edge) = as_plain_quantifier(qp)
+            && matches!(strategy, planner::PathStrategy::Dfs)
+          {
+            self.compile_match_edge(
+              qp.variable.clone(),
+              edge,
+              is_single_match,
+              &mut edge_variables,
+              qp.quantifier.clone(),
+            )
+          }
+          else
+          {
+            self.compile_quantified_path(qp.clone(), strategy)
+          }
+        }
+      })
+      .collect::<Result<_>>()
+  }
+
+  fn compile_match_patterns(
+    &mut self,
+    patterns: &[planner::PlannedPattern],
+    where_expression: &Option<gqlparser::oc::ast::Expression>,
+    optional: bool,
+  ) -> Result<Block>
+  {
+    let blocks = self.compile_pattern_blocks(patterns)?;
     let mut filter = Instructions::new();
     if let Some(where_expression) = where_expression
     {
@@ -980,6 +1430,7 @@ impl Compiler
       },
     )?;
     Ok(instructions::Modifiers {
+      distinct: modifiers.distinct,
       limit,
       skip,
       order_by,
@@ -988,7 +1439,7 @@ impl Compiler
 
   fn unpack_scan_plan(
     logical_plan: LogicalPlan,
-  ) -> Result<(Vec<ast::Pattern>, Option<ast::Expression>, bool)>
+  ) -> Result<(Vec<planner::PlannedPattern>, Option<ast::Expression>, bool)>
   {
     match logical_plan
     {
@@ -1100,6 +1551,12 @@ impl Compiler
         projection.modifiers.limit = Some(expression);
         Ok(projection)
       }
+      LogicalPlan::Distinct { source } =>
+      {
+        let mut projection = Self::unpack_projection_plan(*source)?;
+        projection.modifiers.distinct = true;
+        Ok(projection)
+      }
       _ => Err(
         InternalError::Unreachable {
           context: "compile/unpack_projection_plan",
@@ -1239,7 +1696,8 @@ pub(crate) fn compile(
         | LogicalPlan::Sort { .. }
         | LogicalPlan::Skip { .. }
         | LogicalPlan::Limit { .. }
-        | LogicalPlan::Filter { .. } => compiler.compile_projection_plan(logical_plan),
+        | LogicalPlan::Filter { .. }
+        | LogicalPlan::Distinct { .. } => compiler.compile_projection_plan(logical_plan),
         LogicalPlan::Call { name, arguments } =>
         {
           let mut instructions = Instructions::new();