Merge pull request #95 from microsoft/functionality_improvements

Functionality improvements

Author: niclasko

README.md

@@ -854,6 +854,23 @@ WHERE 'Alice' IN COLLECT { MATCH (p)-[:KNOWS]->(f:Person) RETURN f.name }
 RETURN p.name
 ```
 
+**Bare-pattern shorthand:** `EXISTS` and `COUNT` also accept a graph pattern directly, without the `MATCH` keyword (with an optional trailing `WHERE`). `COLLECT` does not support this form because it needs a `RETURN` to know which value to collect.
+
+```cypher
+// EXISTS with a bare pattern
+MATCH (p:Person)
+WHERE EXISTS { (p)-[:KNOWS]->(:Person) }
+RETURN p.name
+
+// COUNT with a bare pattern, in RETURN
+MATCH (p:Person)
+RETURN p.name, COUNT { (p)-[:KNOWS]->(:Person) } AS friendCount
+
+// COUNT with a bare pattern and inner WHERE
+MATCH (p:Person)
+RETURN p.name, COUNT { (p)-[:KNOWS]->(f:Person) WHERE f.age > 30 } AS closeFriends
+```
+
 **Node reference reuse across MATCH clauses:**
 
 ```cypher
@@ -992,6 +1009,7 @@ RETURN f.name, f.description, f.category
 │  ENDS WITH  ·  NOT ENDS WITH                                │
 │  EXISTS { subquery }  ·  NOT EXISTS { subquery }            │
 │  COUNT { subquery }  ·  COLLECT { subquery }                │
+│  EXISTS { pattern }  ·  COUNT { pattern }   -- bare pattern │
 ├─────────────────────────────────────────────────────────────┤
 │  EXPRESSIONS                                                │
 ├─────────────────────────────────────────────────────────────┤

flowquery-py/src/parsing/parser.py

@@ -1911,11 +1911,9 @@ def _parse_case(self) -> Optional[Case]:
             self._expect_and_skip_whitespace_and_comments()
             parts += 1
         else_ = self._parse_else()
-        if else_ is None:
-            raise ValueError("Expected ELSE")
-        else:
+        if else_ is not None:
             case.add_child(else_)
-        self._expect_and_skip_whitespace_and_comments()
+            self._expect_and_skip_whitespace_and_comments()
         if not self.token.is_end():
             raise ValueError("Expected END")
         self.set_next_token()
@@ -2323,8 +2321,39 @@ def _parse_subquery_expression(self) -> Optional[SubqueryExpression]:
         outer_state = self._state
         self._state = ParserState()
         self._state.inherit_variables_from(outer_state)
-        subquery_ast = self._parse_sub_query()
+        # Bare-pattern shorthand: EXISTS/COUNT accept a graph pattern
+        # directly (no MATCH keyword), e.g. COUNT { (a)-[:R]->(b) }.
+        # COLLECT is excluded: it needs a RETURN to know what to collect.
+        if self.token.is_opening_brace() and self.next_significant_token().is_left_parenthesis():
+            if mode == SubqueryMode.COLLECT:
+                self._state = outer_state
+                raise ValueError("COLLECT subquery must contain a RETURN clause")
+            subquery_ast: Optional[ASTNode] = self._parse_pattern_sub_query()
+        else:
+            subquery_ast = self._parse_sub_query()
         self._state = outer_state
         if subquery_ast is None:
             raise ValueError(f"Expected opening brace after {keyword}")
         return SubqueryExpression(mode, subquery_ast)
+
+    def _parse_pattern_sub_query(self) -> ASTNode:
+        """Parse a bare graph pattern (with optional trailing WHERE) inside
+        an EXISTS/COUNT subquery into a MATCH-only sub-query body,
+        equivalent to ``{ MATCH <pattern> [WHERE ...] }``.
+        """
+        self.set_next_token()  # consume '{'
+        self._skip_whitespace_and_comments()
+        patterns = list(self._parse_patterns())
+        if len(patterns) == 0:
+            raise ValueError("Expected graph pattern")
+        root = ASTNode()
+        match = Match(patterns, False)
+        root.add_child(match)
+        where = self._parse_where()
+        if where is not None:
+            match.add_sibling(where)
+        self._skip_whitespace_and_comments()
+        if not self.token.is_closing_brace():
+            raise ValueError("Expected closing brace for sub-query")
+        self.set_next_token()
+        return root

flowquery-py/tests/compute/test_runner.py

@@ -569,6 +569,19 @@ async def test_range_function_with_unwind_and_case(self):
         assert results[1] == {"ret": 2}
         assert results[2] == {"ret": 3}
 
+    @pytest.mark.asyncio
+    async def test_case_without_else_returns_null_when_no_match(self):
+        """Test case without else returns null when no branch matches."""
+        runner = Runner(
+            "unwind range(1, 3) as num return case when num > 1 then num end as ret"
+        )
+        await runner.run()
+        results = runner.results
+        assert len(results) == 3
+        assert results[0] == {"ret": None}
+        assert results[1] == {"ret": 2}
+        assert results[2] == {"ret": 3}
+
     @pytest.mark.asyncio
     async def test_size_function(self):
         """Test size function."""
@@ -7420,6 +7433,89 @@ async def test_exists_as_return_expression(self):
         assert results[1] == {"name": "Bob", "hasFriends": False}
         assert results[2] == {"name": "Charlie", "hasFriends": False}
 
+    @pytest.mark.asyncio
+    async def test_count_subquery_with_bare_pattern(self):
+        await Runner("""
+            CREATE VIRTUAL (:Person) AS {
+                unwind [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}] as record
+                RETURN record.id as id, record.name as name
+            }
+        """).run()
+        await Runner("""
+            CREATE VIRTUAL (:Person)-[:KNOWS]-(:Person) AS {
+                unwind [{left_id: 1, right_id: 2}, {left_id: 1, right_id: 3}, {left_id: 2, right_id: 3}] as record
+                RETURN record.left_id as left_id, record.right_id as right_id
+            }
+        """).run()
+        runner = Runner("""
+            MATCH (p:Person)
+            RETURN p.name AS name, COUNT { (p)-[:KNOWS]->(:Person) } AS friendCount
+        """)
+        await runner.run()
+        results = runner.results
+        assert len(results) == 3
+        assert results[0] == {"name": "Alice", "friendCount": 2}
+        assert results[1] == {"name": "Bob", "friendCount": 1}
+        assert results[2] == {"name": "Charlie", "friendCount": 0}
+
+    @pytest.mark.asyncio
+    async def test_exists_subquery_with_bare_pattern(self):
+        await Runner("""
+            CREATE VIRTUAL (:Person) AS {
+                unwind [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}] as record
+                RETURN record.id as id, record.name as name
+            }
+        """).run()
+        await Runner("""
+            CREATE VIRTUAL (:Person)-[:KNOWS]-(:Person) AS {
+                unwind [{left_id: 1, right_id: 2}, {left_id: 2, right_id: 3}] as record
+                RETURN record.left_id as left_id, record.right_id as right_id
+            }
+        """).run()
+        runner = Runner("""
+            MATCH (p:Person)
+            WHERE EXISTS { (p)-[:KNOWS]->(:Person) }
+            RETURN p.name AS name
+        """)
+        await runner.run()
+        results = runner.results
+        assert len(results) == 2
+        assert results[0] == {"name": "Alice"}
+        assert results[1] == {"name": "Bob"}
+
+    @pytest.mark.asyncio
+    async def test_count_bare_pattern_with_inner_where(self):
+        await Runner("""
+            CREATE VIRTUAL (:Person) AS {
+                unwind [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}] as record
+                RETURN record.id as id, record.name as name
+            }
+        """).run()
+        await Runner("""
+            CREATE VIRTUAL (:Person)-[:KNOWS]-(:Person) AS {
+                unwind [{left_id: 1, right_id: 2}, {left_id: 1, right_id: 3}, {left_id: 2, right_id: 3}] as record
+                RETURN record.left_id as left_id, record.right_id as right_id
+            }
+        """).run()
+        runner = Runner("""
+            MATCH (p:Person)
+            RETURN p.name AS name,
+                   COUNT { (p)-[:KNOWS]->(friend:Person) WHERE friend.id > 2 } AS cnt
+        """)
+        await runner.run()
+        results = runner.results
+        assert len(results) == 3
+        assert results[0] == {"name": "Alice", "cnt": 1}
+        assert results[1] == {"name": "Bob", "cnt": 1}
+        assert results[2] == {"name": "Charlie", "cnt": 0}
+
+    def test_collect_rejects_bare_pattern(self):
+        with pytest.raises(ValueError, match="COLLECT subquery must contain a RETURN clause"):
+            Runner("""
+                MATCH (p:Person)
+                RETURN COLLECT { (p)-[:KNOWS]->(:Person) } AS friends
+            """)
+
 
 class TestPredicateFunctions:
     """Test cases for any, all, none, single predicate functions."""

flowquery-py/tests/parsing/test_parser.py

@@ -516,6 +516,24 @@ def test_case_statement(self):
         )
         assert ast.print() == expected
 
+    def test_case_statement_without_else(self):
+        """Test case statement without an else clause."""
+        parser = Parser()
+        ast = parser.parse("RETURN CASE WHEN 1 THEN 2 END")
+        expected = (
+            "ASTNode\n"
+            "- Return\n"
+            "-- Expression\n"
+            "--- Case\n"
+            "---- When\n"
+            "----- Expression\n"
+            "------ Number (1)\n"
+            "---- Then\n"
+            "----- Expression\n"
+            "------ Number (2)"
+        )
+        assert ast.print() == expected
+
     def test_functions_with_wrong_number_of_arguments(self):
         """Test functions with wrong number of arguments."""
         parser = Parser()

src/parsing/logic/case.ts

@@ -1,7 +1,7 @@
 import ASTNode from "../ast_node";
 import Else from "./else";
-import When from "./when";
 import Then from "./then";
+import When from "./when";
 
 class Case extends ASTNode {
     constructor() {
@@ -12,15 +12,18 @@ class Case extends ASTNode {
         let i = 0;
         let child = this.getChildren()[i];
         while (child instanceof When) {
-            const then = (this.getChildren()[i+1] as Then);
+            const then = this.getChildren()[i + 1] as Then;
             if (child.value()) {
                 return then.value();
             }
             i += 2;
             child = this.getChildren()[i];
         }
-        return (child as Else).value();
+        if (child instanceof Else) {
+            return child.value();
+        }
+        return null;
     }
 }
 
-export default Case;
+export default Case;

src/parsing/parser.ts

@@ -2226,12 +2226,10 @@ class Parser extends BaseParser {
             parts++;
         }
         const _else = this.parseElse();
-        if (_else === null) {
-            throw new Error("Expected ELSE");
-        } else {
+        if (_else !== null) {
             _case.addChild(_else);
+            this.expectAndSkipWhitespaceAndComments();
         }
-        this.expectAndSkipWhitespaceAndComments();
         if (!this.token.isEnd()) {
             throw new Error("Expected END");
         }
@@ -2749,13 +2747,52 @@ class Parser extends BaseParser {
         const outerState = this._state;
         this._state = new ParserState();
         this._state.inheritVariablesFrom(outerState);
-        const subqueryAST = this.parseSubQuery();
+        // Bare-pattern shorthand: EXISTS/COUNT accept a graph pattern
+        // directly (no MATCH keyword), e.g. COUNT { (a)-[:R]->(b) }.
+        // COLLECT is excluded: it needs a RETURN to know what to collect.
+        let subqueryAST: ASTNode | null;
+        if (this.token.isOpeningBrace() && this.nextSignificantToken().isLeftParenthesis()) {
+            if (mode === SubqueryMode.COLLECT) {
+                this._state = outerState;
+                throw new Error("COLLECT subquery must contain a RETURN clause");
+            }
+            subqueryAST = this.parsePatternSubQuery();
+        } else {
+            subqueryAST = this.parseSubQuery();
+        }
         this._state = outerState;
         if (subqueryAST === null) {
             throw new Error(`Expected opening brace after ${keyword}`);
         }
         return new SubqueryExpression(mode, subqueryAST);
     }
+
+    /**
+     * Parses a bare graph pattern (with optional trailing WHERE) inside
+     * an EXISTS/COUNT subquery into a MATCH-only sub-query body,
+     * equivalent to `{ MATCH <pattern> [WHERE ...] }`.
+     */
+    private parsePatternSubQuery(): ASTNode {
+        this.setNextToken(); // consume '{'
+        this.skipWhitespaceAndComments();
+        const patterns: Pattern[] = Array.from(this.parsePatterns());
+        if (patterns.length === 0) {
+            throw new Error("Expected graph pattern");
+        }
+        const root = new ASTNode();
+        const match = new Match(patterns, false);
+        root.addChild(match);
+        const where = this.parseWhere();
+        if (where !== null) {
+            match.addSibling(where);
+        }
+        this.skipWhitespaceAndComments();
+        if (!this.token.isClosingBrace()) {
+            throw new Error("Expected closing brace for sub-query");
+        }
+        this.setNextToken();
+        return root;
+    }
 }
 
 export default Parser;