gqlite 1.8.1 → 1.8.2

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

@@ -450,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 {
@@ -470,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}
@@ -483,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}
@@ -498,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

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 {}..{}.",

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

@@ -13,6 +13,8 @@ pub(crate) enum Token
   And,
   #[token("all", ignore(case))]
   All,
+  #[token("any", ignore(case))]
+  Any,
   #[token("as", ignore(case))]
   As,
   #[token("asc", ignore(case))]
@@ -47,6 +49,10 @@ pub(crate) enum Token
   False,
   #[token("graph", ignore(case))]
   Graph,
+  #[token("group", ignore(case))]
+  Group,
+  #[token("groups", ignore(case))]
+  Groups,
   #[token("if", ignore(case))]
   If,
   #[token("index", ignore(case))]
@@ -71,6 +77,8 @@ pub(crate) enum Token
   Search,
   #[token("set", ignore(case))]
   Set,
+  #[token("shortest", ignore(case))]
+  Shortest,
   #[token("starts", ignore(case))]
   Starts,
   #[token("not", ignore(case))]
@@ -191,6 +199,7 @@ impl Token
     matches!(
       self,
       Token::And
+        | Token::Any
         | Token::As
         | Token::Asc
         | Token::By
@@ -205,6 +214,8 @@ impl Token
         | Token::For
         | Token::False
         | Token::Graph
+        | Token::Group
+        | Token::Groups
         | Token::If
         | Token::Index
         | Token::In
@@ -223,6 +234,7 @@ impl Token
         | Token::Score
         | Token::Search
         | Token::Set
+        | Token::Shortest
         | Token::Skip
         | Token::True
         | Token::Union
@@ -435,4 +447,138 @@ mod tests
       ]
     );
   }
+
+  #[test]
+  fn test_oc_lexer_new_keywords()
+  {
+    // Test 'any' keyword in different cases
+    assert_eq!(
+      tokenize("any").unwrap(),
+      vec![Spanned {
+        value: Token::Any,
+        span: 0..3
+      }]
+    );
+    assert_eq!(
+      tokenize("ANY").unwrap(),
+      vec![Spanned {
+        value: Token::Any,
+        span: 0..3
+      }]
+    );
+    assert_eq!(
+      tokenize("Any").unwrap(),
+      vec![Spanned {
+        value: Token::Any,
+        span: 0..3
+      }]
+    );
+
+    // Test 'group' keyword in different cases
+    assert_eq!(
+      tokenize("group").unwrap(),
+      vec![Spanned {
+        value: Token::Group,
+        span: 0..5
+      }]
+    );
+    assert_eq!(
+      tokenize("GROUP").unwrap(),
+      vec![Spanned {
+        value: Token::Group,
+        span: 0..5
+      }]
+    );
+    assert_eq!(
+      tokenize("Group").unwrap(),
+      vec![Spanned {
+        value: Token::Group,
+        span: 0..5
+      }]
+    );
+
+    // Test 'groups' keyword in different cases
+    assert_eq!(
+      tokenize("groups").unwrap(),
+      vec![Spanned {
+        value: Token::Groups,
+        span: 0..6
+      }]
+    );
+    assert_eq!(
+      tokenize("GROUPS").unwrap(),
+      vec![Spanned {
+        value: Token::Groups,
+        span: 0..6
+      }]
+    );
+    assert_eq!(
+      tokenize("Groups").unwrap(),
+      vec![Spanned {
+        value: Token::Groups,
+        span: 0..6
+      }]
+    );
+
+    // Test 'shortest' keyword in different cases
+    assert_eq!(
+      tokenize("shortest").unwrap(),
+      vec![Spanned {
+        value: Token::Shortest,
+        span: 0..8
+      }]
+    );
+    assert_eq!(
+      tokenize("SHORTEST").unwrap(),
+      vec![Spanned {
+        value: Token::Shortest,
+        span: 0..8
+      }]
+    );
+    assert_eq!(
+      tokenize("Shortest").unwrap(),
+      vec![Spanned {
+        value: Token::Shortest,
+        span: 0..8
+      }]
+    );
+  }
+
+  #[test]
+  fn test_oc_lexer_reserved_keywords_compatibility()
+  {
+    // These keywords are now reserved and cannot be used as identifiers.
+    // This test demonstrates the compatibility cost: queries that previously
+    // worked with these as variable names will now fail.
+
+    // Before fix: 'any' would be tokenized as Identifier
+    // After fix: 'any' is tokenized as Token::Any (keyword)
+    let tokens = tokenize("any").unwrap();
+    assert_eq!(
+      tokens[0].value,
+      Token::Any,
+      "Expected 'any' to be reserved keyword, not identifier"
+    );
+
+    let tokens = tokenize("group").unwrap();
+    assert_eq!(
+      tokens[0].value,
+      Token::Group,
+      "Expected 'group' to be reserved keyword, not identifier"
+    );
+
+    let tokens = tokenize("groups").unwrap();
+    assert_eq!(
+      tokens[0].value,
+      Token::Groups,
+      "Expected 'groups' to be reserved keyword, not identifier"
+    );
+
+    let tokens = tokenize("shortest").unwrap();
+    assert_eq!(
+      tokens[0].value,
+      Token::Shortest,
+      "Expected 'shortest' to be reserved keyword, not identifier"
+    );
+  }
 }