gqlite 1.8.0 → 1.8.2

data/ext/gqlitedb/src/tests/templates/programs.rs

@@ -73,6 +73,7 @@ pub(crate) fn create_named_node() -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(2, 0),
     },
@@ -138,6 +139,7 @@ pub(crate) fn create_named_node_double_return() -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(3, 0),
     },
@@ -166,6 +168,7 @@ pub(crate) fn double_with_return() -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(2, 0),
     },
@@ -187,6 +190,7 @@ pub(crate) fn double_with_return() -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(4, 0),
     },
@@ -204,6 +208,7 @@ pub(crate) fn double_with_return() -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(2, 0),
     },
@@ -239,6 +244,7 @@ pub(crate) fn unwind() -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(1, 0),
     },
@@ -294,6 +300,7 @@ pub(crate) fn match_loop() -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(1, 0),
     },
@@ -333,6 +340,7 @@ pub(crate) fn optional_match() -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(1, 0),
     },
@@ -375,6 +383,7 @@ pub(crate) fn match_count(function_manager: &functions::Manager) -> Program
               aggregator: function_manager
                 .get_aggregator::<error::CompileTimeError>("count")
                 .unwrap(),
+              distinct: false,
             },
           )],
         },
@@ -384,6 +393,7 @@ pub(crate) fn match_count(function_manager: &functions::Manager) -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(2, 1),
     },
@@ -445,6 +455,7 @@ pub(crate) fn aggregation(function_manager: &functions::Manager) -> Program
                 aggregator: function_manager
                   .get_aggregator::<error::CompileTimeError>("count")
                   .unwrap(),
+                distinct: false,
               },
             )],
           },
@@ -455,8 +466,315 @@ pub(crate) fn aggregation(function_manager: &functions::Manager) -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(3, 1),
     },
   ]
 }
+
+/// Program for `MATCH (a) ((n)-[:R]->(m)){1,3} (b) RETURN a, b`.
+/// Uses MatchQuantifiedPath since the group's inner nodes (n, m) differ
+/// from the outer anchors (a, b) - this is an explicit group pattern.
+pub(crate) fn group_single_edge_range() -> Program
+{
+  vec![
+    Block::Match {
+      blocks: vec![BlockMatch::MatchQuantifiedPath {
+        source_instructions: vec![
+          Instruction::Push {
+            value: ValueMap::default().into(),
+          },
+          Instruction::CreateNodeQuery { labels: vec![] },
+        ],
+        source_variable: Some(0),
+        source_filter: vec![],
+        destination_variable: Some(1),
+        destination_filter: vec![],
+        path_variable: None,
+        quantifier: 1..3,
+        group_instructions: vec![BlockMatch::MatchEdge {
+          instructions: vec![
+            Instruction::GetVariable { col_id: 2 },
+            Instruction::CreateNodeQuery { labels: vec![] },
+            Instruction::Push {
+              value: ValueMap::default().into(),
+            },
+            Instruction::CreateNodeQuery { labels: vec![] },
+            Instruction::Push {
+              value: ValueMap::default().into(),
+            },
+            Instruction::CreateEdgeQuery {
+              labels: vec!["R".into()],
+            },
+          ],
+          left_variable: None,
+          edge_variable: Some(4),
+          right_variable: Some(3),
+          path_variable: None,
+          filter: vec![],
+          directivity: EdgeDirectivity::Directed,
+          recursive_range: None,
+        }],
+        group_variables: vec![2, 4, 3],
+        group_terminal_variable: 3,
+        group_entry_variable: 2,
+        group_where_filter: None,
+        path_filter: None,
+        strategy: PathStrategy::Dfs,
+      }],
+      filter: vec![],
+      optional: false,
+      variables_size: create_variable_size(5, 0),
+    },
+    Block::Return {
+      variables: vec![
+        (
+          "a".into(),
+          RWExpression {
+            col_id: 0,
+            instructions: vec![Instruction::GetVariable { col_id: 0 }],
+            aggregations: Default::default(),
+          },
+        ),
+        (
+          "b".into(),
+          RWExpression {
+            col_id: 1,
+            instructions: vec![Instruction::GetVariable { col_id: 1 }],
+            aggregations: Default::default(),
+          },
+        ),
+      ],
+      filter: vec![],
+      modifiers: Modifiers {
+        limit: None,
+        skip: None,
+        order_by: vec![],
+        distinct: false,
+      },
+      variables_sizes: create_variable_size(5, 0),
+    },
+  ]
+}
+
+/// Program for `MATCH (a) ((n)-[:R1]->(x)-[:R2]->(m)){1,3} (b) RETURN a, b`.
+/// Two-edge group: compiler allocates edge columns (5, 6) for deduplication,
+/// and adds filter logic to second edge to prevent revisiting the same edge.
+pub(crate) fn group_two_edges_range() -> Program
+{
+  vec![
+    Block::Match {
+      blocks: vec![BlockMatch::MatchQuantifiedPath {
+        source_instructions: vec![
+          Instruction::Push {
+            value: ValueMap::default().into(),
+          },
+          Instruction::CreateNodeQuery { labels: vec![] },
+        ],
+        source_variable: Some(0),
+        source_filter: vec![],
+        destination_variable: Some(1),
+        destination_filter: vec![],
+        path_variable: None,
+        quantifier: 1..3,
+        group_instructions: vec![
+          BlockMatch::MatchEdge {
+            instructions: vec![
+              Instruction::GetVariable { col_id: 2 },
+              Instruction::CreateNodeQuery { labels: vec![] },
+              Instruction::Push {
+                value: ValueMap::default().into(),
+              },
+              Instruction::CreateNodeQuery { labels: vec![] },
+              Instruction::Push {
+                value: ValueMap::default().into(),
+              },
+              Instruction::CreateEdgeQuery {
+                labels: vec!["R1".into()],
+              },
+            ],
+            left_variable: None,
+            edge_variable: Some(4),
+            right_variable: Some(3),
+            path_variable: None,
+            filter: vec![],
+            directivity: EdgeDirectivity::Directed,
+            recursive_range: None,
+          },
+          BlockMatch::MatchEdge {
+            instructions: vec![
+              Instruction::GetVariable { col_id: 3 },
+              Instruction::CreateNodeQuery { labels: vec![] },
+              Instruction::Push {
+                value: ValueMap::default().into(),
+              },
+              Instruction::CreateNodeQuery { labels: vec![] },
+              Instruction::Push {
+                value: ValueMap::default().into(),
+              },
+              Instruction::CreateEdgeQuery {
+                labels: vec!["R2".into()],
+              },
+            ],
+            left_variable: None,
+            edge_variable: Some(6),
+            right_variable: Some(5),
+            path_variable: None,
+            filter: vec![
+              Instruction::Duplicate,
+              Instruction::GetVariable { col_id: 4 },
+              Instruction::NotEqualBinaryOperator,
+              Instruction::InverseRot3,
+              Instruction::AndBinaryOperator,
+              Instruction::Swap,
+            ],
+            directivity: EdgeDirectivity::Directed,
+            recursive_range: None,
+          },
+        ],
+        group_variables: vec![2, 4, 3, 3, 6, 5],
+        group_terminal_variable: 5,
+        group_entry_variable: 2,
+        group_where_filter: None,
+        path_filter: None,
+        strategy: PathStrategy::Dfs,
+      }],
+      filter: vec![],
+      optional: false,
+      variables_size: create_variable_size(7, 0),
+    },
+    Block::Return {
+      variables: vec![
+        (
+          "a".into(),
+          RWExpression {
+            col_id: 0,
+            instructions: vec![Instruction::GetVariable { col_id: 0 }],
+            aggregations: Default::default(),
+          },
+        ),
+        (
+          "b".into(),
+          RWExpression {
+            col_id: 1,
+            instructions: vec![Instruction::GetVariable { col_id: 1 }],
+            aggregations: Default::default(),
+          },
+        ),
+      ],
+      filter: vec![],
+      modifiers: Modifiers {
+        limit: None,
+        skip: None,
+        order_by: vec![],
+        distinct: false,
+      },
+      variables_sizes: create_variable_size(7, 0),
+    },
+  ]
+}
+
+/// Program for `MATCH p = SHORTEST 1 (a)-[:R]-+(b) RETURN a, b, length(p)`
+/// Shortest path uses BFS with stop condition. **KEY FINDING**: group_variables
+/// DOES include source/destination columns [1, 2] - this was the open question
+/// in WI721.
+pub(crate) fn shortest_single_edge_full_return(function_manager: &functions::Manager) -> Program
+{
+  vec![
+    Block::Match {
+      blocks: vec![BlockMatch::MatchQuantifiedPath {
+        source_instructions: vec![
+          Instruction::Push {
+            value: ValueMap::default().into(),
+          },
+          Instruction::CreateNodeQuery { labels: vec![] },
+        ],
+        source_variable: Some(1),
+        source_filter: vec![],
+        destination_variable: Some(2),
+        destination_filter: vec![],
+        path_variable: Some(0),
+        quantifier: 1..usize::MAX,
+        group_instructions: vec![BlockMatch::MatchEdge {
+          instructions: vec![
+            Instruction::GetVariable { col_id: 1 },
+            Instruction::CreateNodeQuery { labels: vec![] },
+            Instruction::Push {
+              value: ValueMap::default().into(),
+            },
+            Instruction::CreateNodeQuery { labels: vec![] },
+            Instruction::Push {
+              value: ValueMap::default().into(),
+            },
+            Instruction::CreateEdgeQuery {
+              labels: vec!["R".into()],
+            },
+          ],
+          left_variable: None,
+          edge_variable: Some(3),
+          right_variable: Some(2),
+          path_variable: None,
+          filter: vec![],
+          directivity: EdgeDirectivity::Undirected,
+          recursive_range: None,
+        }],
+        group_variables: vec![1, 3, 2],
+        group_terminal_variable: 2,
+        group_entry_variable: 1,
+        group_where_filter: None,
+        path_filter: None,
+        strategy: PathStrategy::Bfs {
+          stop_condition: StopCondition::Shortest(vec![Instruction::Push { value: 1.into() }]),
+        },
+      }],
+      filter: vec![],
+      optional: false,
+      variables_size: create_variable_size(4, 0),
+    },
+    Block::Return {
+      variables: vec![
+        (
+          "a".into(),
+          RWExpression {
+            col_id: 1,
+            instructions: vec![Instruction::GetVariable { col_id: 1 }],
+            aggregations: Default::default(),
+          },
+        ),
+        (
+          "b".into(),
+          RWExpression {
+            col_id: 2,
+            instructions: vec![Instruction::GetVariable { col_id: 2 }],
+            aggregations: Default::default(),
+          },
+        ),
+        (
+          "length(p)".into(),
+          RWExpression {
+            col_id: 4,
+            instructions: vec![
+              Instruction::GetVariable { col_id: 0 },
+              Instruction::FunctionCall {
+                function: function_manager
+                  .get_function::<error::CompileTimeError>("length")
+                  .unwrap(),
+                arguments_count: 1,
+              },
+            ],
+            aggregations: Default::default(),
+          },
+        ),
+      ],
+      filter: vec![],
+      modifiers: Modifiers {
+        limit: None,
+        skip: None,
+        order_by: vec![],
+        distinct: false,
+      },
+      variables_sizes: create_variable_size(5, 0),
+    },
+  ]
+}

data/ext/gqliterb/Cargo.toml

@@ -11,7 +11,6 @@ repository.workspace = true
 crate-type = ["cdylib"]
 
 [features]
-_cmake = []
 
 [dependencies]
 gqlitedb = { workspace = true, features = ["postgres", "redb", "sqlite"] }

data/ext/gqlparser/src/oc/ast.rs

@@ -378,11 +378,22 @@ pub struct OrderBy
 #[derive(Default, Debug)]
 pub struct Modifiers
 {
+  pub distinct: bool,
   pub skip: Option<Expression>,
   pub limit: Option<Expression>,
   pub order_by: Option<OrderBy>,
 }
 
+impl Modifiers
+{
+  /// Set the distinct field
+  pub(crate) fn set_distinct(mut self, distinct: bool) -> Self
+  {
+    self.distinct = distinct;
+    self
+  }
+}
+
 // Expressions
 
 #[derive(Debug, Clone, PartialEq)]
@@ -411,6 +422,10 @@ pub enum Expression
   RelationalIn(Box<RelationalIn>),
   RelationalNotIn(Box<RelationalNotIn>),
 
+  Contains(Box<Contains>),
+  EndsWith(Box<EndsWith>),
+  StartsWith(Box<StartsWith>),
+
   Addition(Box<Addition>),
   Subtraction(Box<Subtraction>),
   Multiplication(Box<Multiplication>),
@@ -435,12 +450,13 @@ pub struct OrderByExpression
 
 // Values: CreatePatterns
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Pattern
 {
   Node(NodePattern),
   Edge(EdgePattern),
   Path(PathPattern),
+  QuantifiedPath(QuantifiedPathPattern),
 }
 
 macro_rules! create_from_pattern {
@@ -455,6 +471,7 @@ pub struct NodePattern
   pub variable: Option<VariableIdentifier>,
   pub labels: LabelExpression,
   pub properties: Option<Expression>,
+  pub predicate: Option<Expression>,
 }
 
 create_from_pattern! {NodePattern, Node}
@@ -468,8 +485,7 @@ pub struct EdgePattern
   pub directivity: graphcore::EdgeDirectivity,
   pub labels: LabelExpression,
   pub properties: Option<Expression>,
-  /// Indicates the range for a recursive match.
-  pub recursive_range: Option<std::ops::Range<usize>>,
+  pub predicate: Option<Expression>,
 }
 
 create_from_pattern! {EdgePattern, Edge}
@@ -483,6 +499,54 @@ pub struct PathPattern
 
 create_from_pattern! {PathPattern, Path}
 
+#[derive(Debug, Clone)]
+pub struct QuantifiedPathPattern
+{
+  /// Path variable, if bound via `p = ...`. `None` for a bare quantified
+  /// relationship/group with no path variable.
+  pub variable: Option<VariableIdentifier>,
+  /// The fixed source node anchor outside the repeated group. For
+  /// `(a) ((n)-[r]->(m)){1,5} (b)`, this is `a` (the left outer anchor).
+  pub source: NodePattern,
+  /// The repeated unit. For the single-edge case (legacy `[*min..max]` or
+  /// new `{min,max}`/`*`/`+` syntax — the only case Milestone 2 produces),
+  /// this is always exactly one `Pattern::Edge`. Multi-element groups
+  /// (Milestone 3) populate more than one element here.
+  pub group: Vec<Pattern>,
+  /// Optional inline `WHERE` scoped to the group (Milestone 3). Always
+  /// `None` for anything Milestone 2 produces. Applied per repetition during
+  /// group expansion (genuine groups only, never present on wrapper-promoted patterns).
+  pub group_where: Option<Expression>,
+  /// Optional `WHERE` for the whole assembled path, from a selector-scoped wrapper.
+  /// Evaluated once when a candidate reaches `destination`, distinct from
+  /// `group_where`'s per-repetition timing. Only populated by wrapper resolution
+  /// in `planner::plan_pattern`; genuine groups never have `path_where`.
+  pub path_where: Option<Expression>,
+  /// `Some(min..max)` for a repeatable group (everything Milestone 2
+  /// produces). `None` is reserved for the pre-filter scoping-wrapper use
+  /// (Milestone 5, design §1d) — not constructible yet.
+  pub quantifier: Option<std::ops::Range<usize>>,
+  /// The fixed destination node anchor outside the repeated group. For
+  /// `(a) ((n)-[r]->(m)){1,5} (b)`, this is `b` (the right outer anchor).
+  pub destination: NodePattern,
+  /// Path selector (`SHORTEST`/`ALL SHORTEST`/etc., design's `PathSelector`
+  /// below). Always `PathSelector::All` for anything Milestone 2 produces
+  /// — no grammar exists yet to populate the other variants.
+  pub selector: PathSelector,
+}
+
+create_from_pattern! {QuantifiedPathPattern, QuantifiedPath}
+
+#[derive(Debug, Clone)]
+pub enum PathSelector
+{
+  All,
+  Any,
+  AllShortest,
+  Shortest(Expression),
+  ShortestGroups(Expression),
+}
+
 // Label Expression
 #[derive(Debug, Clone, PartialEq)]
 pub enum LabelExpression
@@ -601,6 +665,7 @@ pub struct FunctionCall
 {
   pub name: String,
   pub arguments: Vec<Expression>,
+  pub distinct: bool,
 }
 
 create_from_expr! {FunctionCall}
@@ -630,6 +695,10 @@ create_binary_op! {RelationalSuperiorEqual}
 create_binary_op! {RelationalIn}
 create_binary_op! {RelationalNotIn}
 
+create_binary_op! {Contains}
+create_binary_op! {EndsWith}
+create_binary_op! {StartsWith}
+
 create_binary_op! {Addition}
 create_binary_op! {Subtraction}
 create_binary_op! {Multiplication}

data/ext/gqlparser/src/oc/error.rs

@@ -27,6 +27,9 @@ pub enum ErrorKind
   NoSingleRelationshipType,
   MixedUnionOperators,
   VariableNotFound,
+  CreatingWithPredicate,
+  ConflictingQuantifiers,
+  EmptyQuantifiedGroup,
 }
 
 pub(crate) fn parse_int_error_to_error_kind(e: std::num::ParseIntError) -> ErrorKind
@@ -157,6 +160,21 @@ impl std::fmt::Display for Error
         "NoSingleRelationshipType: edge patterns must have exactly one relationship type at {}..{}.",
         self.span.start, self.span.end
       ),
+      ErrorKind::CreatingWithPredicate => write!(
+        f,
+        "CreatingWithPredicate: CREATE patterns cannot use an inline WHERE predicate at {}..{}.",
+        self.span.start, self.span.end
+      ),
+      ErrorKind::ConflictingQuantifiers => write!(
+        f,
+        "ConflictingQuantifiers: cannot specify both a legacy `[*min..max]` range and a `{{min,max}}`/`*`/`+` quantifier on the same relationship at {}..{}.",
+        self.span.start, self.span.end
+      ),
+      ErrorKind::EmptyQuantifiedGroup => write!(
+        f,
+        "EmptyQuantifiedGroup: a quantified group must contain at least one relationship at {}..{}.",
+        self.span.start, self.span.end
+      ),
       ErrorKind::MixedUnionOperators => write!(
         f,
         "MixedUnionOperators: cannot mix UNION and UNION ALL in the same query at {}..{}.",