flowquery 1.0.32 → 1.0.34

package/src/parsing/parser.ts

@@ -58,9 +58,12 @@ import Load from "./operations/load";
 import Match from "./operations/match";
 import Operation from "./operations/operation";
 import Return from "./operations/return";
+import Union from "./operations/union";
+import UnionAll from "./operations/union_all";
 import Unwind from "./operations/unwind";
 import Where from "./operations/where";
 import With from "./operations/with";
+import ParserState from "./parser_state";
 
 /**
  * Main parser for FlowQuery statements.
@@ -76,9 +79,7 @@ import With from "./operations/with";
  * ```
  */
 class Parser extends BaseParser {
-    private variables: Map<string, ASTNode> = new Map();
-    private context: Context = new Context();
-    private _returns: number = 0;
+    private _state: ParserState = new ParserState();
 
     /**
      * Parses a FlowQuery statement into an Abstract Syntax Tree.
@@ -107,13 +108,17 @@ class Parser extends BaseParser {
             } else {
                 this.skipWhitespaceAndComments();
             }
+            // UNION separates two query pipelines — break and handle after the loop
+            if (this.token.isUnion()) {
+                break;
+            }
             operation = this.parseOperation();
             if (operation === null && !isSubQuery) {
                 throw new Error("Expected one of WITH, UNWIND, RETURN, LOAD, OR CALL");
             } else if (operation === null && isSubQuery) {
                 return root;
             }
-            if (this._returns > 1) {
+            if (this._state.returns > 1) {
                 throw new Error("Only one RETURN statement is allowed");
             }
             if (previous instanceof Call && !previous.hasYield) {
@@ -142,6 +147,24 @@ class Parser extends BaseParser {
             }
             previous = operation;
         }
+        // Handle UNION: wrap left and right pipelines into a Union node
+        if (!this.token.isEOF() && this.token.isUnion()) {
+            if (!(operation instanceof Return) && !(operation instanceof Call)) {
+                throw new Error("Each side of UNION must end with a RETURN or CALL statement");
+            }
+            const union = this.parseUnion()!;
+            union.left = root.firstChild() as Operation;
+            // Save and reset parser state for right-side scope
+            const state = this._state;
+            this._state = new ParserState();
+            const right = this._parseTokenized(isSubQuery);
+            union.right = right.firstChild() as Operation;
+            // Restore parser state
+            this._state = state;
+            const newRoot = new ASTNode();
+            newRoot.addChild(union);
+            return newRoot;
+        }
         if (
             !(operation instanceof Return) &&
             !(operation instanceof Call) &&
@@ -216,7 +239,7 @@ class Parser extends BaseParser {
             throw new Error("Expected alias");
         }
         const unwind = new Unwind(expression);
-        this.variables.set(alias.getAlias(), unwind);
+        this._state.variables.set(alias.getAlias(), unwind);
         return unwind;
     }
 
@@ -239,7 +262,7 @@ class Parser extends BaseParser {
         if (distinct || expressions.some((expression: Expression) => expression.has_reducers())) {
             return new AggregatedReturn(expressions);
         }
-        this._returns++;
+        this._state.incrementReturns();
         return new Return(expressions);
     }
 
@@ -322,7 +345,7 @@ class Parser extends BaseParser {
         const alias = this.parseAlias();
         if (alias !== null) {
             load.addChild(alias);
-            this.variables.set(alias.getAlias(), load);
+            this._state.variables.set(alias.getAlias(), load);
         } else {
             throw new Error("Expected alias");
         }
@@ -418,7 +441,16 @@ class Parser extends BaseParser {
     }
 
     private parseMatch(): Match | null {
+        let optional = false;
+        if (this.token.isOptional()) {
+            optional = true;
+            this.setNextToken();
+            this.expectAndSkipWhitespaceAndComments();
+        }
         if (!this.token.isMatch()) {
+            if (optional) {
+                throw new Error("Expected MATCH after OPTIONAL");
+            }
             return null;
         }
         this.setNextToken();
@@ -427,7 +459,7 @@ class Parser extends BaseParser {
         if (patterns.length === 0) {
             throw new Error("Expected graph pattern");
         }
-        return new Match(patterns);
+        return new Match(patterns, optional);
     }
 
     private parseNode(): Node | null {
@@ -458,8 +490,8 @@ class Parser extends BaseParser {
         let node = new Node();
         node.properties = new Map(this.parseProperties());
         node.label = label!;
-        if (identifier !== null && this.variables.has(identifier)) {
-            let reference = this.variables.get(identifier);
+        if (identifier !== null && this._state.variables.has(identifier)) {
+            let reference = this._state.variables.get(identifier);
             // Resolve through Expression -> Reference -> Node (e.g., after WITH)
             if (reference instanceof Expression && reference.firstChild() instanceof Reference) {
                 const inner = (reference.firstChild() as Reference).referred;
@@ -476,7 +508,7 @@ class Parser extends BaseParser {
             node = new NodeReference(node, reference);
         } else if (identifier !== null) {
             node.identifier = identifier;
-            this.variables.set(identifier, node);
+            this._state.variables.set(identifier, node);
         }
         if (!this.token.isRightParenthesis()) {
             throw new Error("Expected closing parenthesis for node definition");
@@ -543,7 +575,7 @@ class Parser extends BaseParser {
             if (pattern !== null) {
                 if (identifier !== null) {
                     pattern.identifier = identifier;
-                    this.variables.set(identifier, pattern);
+                    this._state.variables.set(identifier, pattern);
                 }
                 yield pattern;
             } else {
@@ -659,8 +691,8 @@ class Parser extends BaseParser {
         let relationship = new Relationship();
         relationship.direction = direction;
         relationship.properties = properties;
-        if (variable !== null && this.variables.has(variable)) {
-            let reference = this.variables.get(variable);
+        if (variable !== null && this._state.variables.has(variable)) {
+            let reference = this._state.variables.get(variable);
             // Resolve through Expression -> Reference -> Relationship (e.g., after WITH)
             if (reference instanceof Expression && reference.firstChild() instanceof Reference) {
                 const inner = (reference.firstChild() as Reference).referred;
@@ -674,7 +706,7 @@ class Parser extends BaseParser {
             relationship = new RelationshipReference(relationship, reference);
         } else if (variable !== null) {
             relationship.identifier = variable;
-            this.variables.set(variable, relationship);
+            this._state.variables.set(variable, relationship);
         }
         if (hops !== null) {
             relationship.hops = hops;
@@ -753,7 +785,7 @@ class Parser extends BaseParser {
                 if (expression.firstChild() instanceof Reference && alias === null) {
                     const reference: Reference = expression.firstChild() as Reference;
                     expression.setAlias(reference.identifier);
-                    this.variables.set(reference.identifier, expression);
+                    this._state.variables.set(reference.identifier, expression);
                 } else if (
                     alias_option === AliasOption.REQUIRED &&
                     alias === null &&
@@ -767,7 +799,7 @@ class Parser extends BaseParser {
                     alias !== null
                 ) {
                     expression.setAlias(alias.getAlias());
-                    this.variables.set(alias.getAlias(), expression);
+                    this._state.variables.set(alias.getAlias(), expression);
                 }
                 yield expression;
             } else {
@@ -789,7 +821,7 @@ class Parser extends BaseParser {
         this.skipWhitespaceAndComments();
         if (this.token.isIdentifierOrKeyword() && !this.peek()?.isLeftParenthesis()) {
             const identifier: string = this.token.value || "";
-            const reference = new Reference(identifier, this.variables.get(identifier));
+            const reference = new Reference(identifier, this._state.variables.get(identifier));
             this.setNextToken();
             const lookup = this.parseLookup(reference);
             expression.addNode(lookup);
@@ -1185,10 +1217,13 @@ class Parser extends BaseParser {
             return null;
         }
         const func = FunctionFactory.create(this.token.value);
-        if (func instanceof AggregateFunction && this.context.containsType(AggregateFunction)) {
+        if (
+            func instanceof AggregateFunction &&
+            this._state.context.containsType(AggregateFunction)
+        ) {
             throw new Error("Aggregate functions cannot be nested");
         }
-        this.context.push(func);
+        this._state.context.push(func);
         this.setNextToken();
         this.setNextToken();
         this.skipWhitespaceAndComments();
@@ -1203,7 +1238,7 @@ class Parser extends BaseParser {
             throw new Error("Expected right parenthesis");
         }
         this.setNextToken();
-        this.context.pop();
+        this._state.context.pop();
         return func;
     }
 
@@ -1265,7 +1300,7 @@ class Parser extends BaseParser {
             throw new Error("Expected identifier");
         }
         const reference = new Reference(this.token.value);
-        this.variables.set(reference.identifier, reference);
+        this._state.variables.set(reference.identifier, reference);
         func.addChild(reference);
         this.setNextToken();
         this.expectAndSkipWhitespaceAndComments();
@@ -1308,7 +1343,7 @@ class Parser extends BaseParser {
             throw new Error("Expected right parenthesis");
         }
         this.setNextToken();
-        this.variables.delete(reference.identifier);
+        this._state.variables.delete(reference.identifier);
         return func;
     }
 
@@ -1421,6 +1456,22 @@ class Parser extends BaseParser {
         return array;
     }
 
+    private parseUnion(): Union | UnionAll | null {
+        if (!this.token.isUnion()) {
+            return null;
+        }
+        this.setNextToken();
+        this.skipWhitespaceAndComments();
+        let union: Union | UnionAll;
+        if (this.token.isAll()) {
+            union = new UnionAll();
+            this.setNextToken();
+        } else {
+            union = new Union();
+        }
+        return union;
+    }
+
     private expectAndSkipWhitespaceAndComments(): void {
         const skipped = this.skipWhitespaceAndComments();
         if (!skipped) {

package/src/parsing/parser_state.ts

@@ -0,0 +1,25 @@
+import ASTNode from "./ast_node";
+import Context from "./context";
+
+class ParserState {
+    private _variables: Map<string, ASTNode> = new Map();
+    private _context: Context = new Context();
+    private _returns: number = 0;
+
+    public get variables(): Map<string, ASTNode> {
+        return this._variables;
+    }
+
+    public get context(): Context {
+        return this._context;
+    }
+
+    public get returns(): number {
+        return this._returns;
+    }
+    public incrementReturns(): void {
+        this._returns++;
+    }
+}
+
+export default ParserState;

package/src/tokenization/keyword.ts

@@ -1,6 +1,7 @@
 enum Keyword {
     RETURN = "RETURN",
     MATCH = "MATCH",
+    OPTIONAL = "OPTIONAL",
     WHERE = "WHERE",
     CREATE = "CREATE",
     VIRTUAL = "VIRTUAL",
@@ -42,6 +43,8 @@ enum Keyword {
     CONTAINS = "CONTAINS",
     STARTS = "STARTS",
     ENDS = "ENDS",
+    UNION = "UNION",
+    ALL = "ALL",
 }
 
 export default Keyword;

package/src/tokenization/token.ts

@@ -507,6 +507,14 @@ class Token {
         return this._type === TokenType.KEYWORD && this._value === Keyword.MATCH;
     }
 
+    public static get OPTIONAL(): Token {
+        return new Token(TokenType.KEYWORD, Keyword.OPTIONAL);
+    }
+
+    public isOptional(): boolean {
+        return this._type === TokenType.KEYWORD && this._value === Keyword.OPTIONAL;
+    }
+
     public static get AS(): Token {
         return new Token(TokenType.KEYWORD, Keyword.AS);
     }
@@ -675,6 +683,22 @@ class Token {
         return this._type === TokenType.KEYWORD && this._value === Keyword.LIMIT;
     }
 
+    public static get UNION(): Token {
+        return new Token(TokenType.KEYWORD, Keyword.UNION);
+    }
+
+    public isUnion(): boolean {
+        return this._type === TokenType.KEYWORD && this._value === Keyword.UNION;
+    }
+
+    public static get ALL(): Token {
+        return new Token(TokenType.KEYWORD, Keyword.ALL);
+    }
+
+    public isAll(): boolean {
+        return this._type === TokenType.KEYWORD && this._value === Keyword.ALL;
+    }
+
     // End of file token
 
     public static get EOF(): Token {