flowquery 1.0.53 → 1.0.55

package/README.md

@@ -393,6 +393,29 @@ RETURN sum(n IN [1, 2, 3] | n) AS sum                // 6
 RETURN sum(n IN [1+2+3, 2, 3] | n^2) AS sum          // 49
 ```
 
+### Boolean Predicate Functions
+
+Test list elements against a condition. Follow standard Cypher syntax.
+
+```cypher
+// any — true if at least one element matches
+RETURN any(n IN [1, 2, 3] WHERE n > 2)               // true
+
+// all — true if every element matches
+RETURN all(n IN [2, 4, 6] WHERE n > 0)               // true
+
+// none — true if no element matches
+RETURN none(n IN [1, 2, 3] WHERE n > 5)              // true
+
+// single — true if exactly one element matches
+RETURN single(n IN [1, 2, 3] WHERE n > 2)            // true
+
+// In a WHERE clause
+UNWIND [[1,2,3], [4,5,6]] AS nums
+WITH nums WHERE any(n IN nums WHERE n > 4)
+RETURN nums                                          // [4, 5, 6]
+```
+
 ### Aggregate Functions
 
 Used in `RETURN` or `WITH` to group and reduce rows. Non-aggregated expressions define grouping keys. Aggregate functions cannot be nested.
@@ -552,6 +575,44 @@ MATCH (a:Person), (b:Person) WHERE (a)-[:KNOWS]->(b) RETURN a.name, b.name
 MATCH (a:Person) WHERE NOT (a)-[:KNOWS]->(:Person) RETURN a.name
 ```
 
+**Subquery Expressions:** `EXISTS`, `COUNT`, and `COLLECT` evaluate a full subquery as an expression. The subquery can reference outer-scope variables and supports the complete FlowQuery pipeline (MATCH, WITH, WHERE, UNWIND, LOAD, etc.).
+
+```cypher
+// EXISTS — returns true if the subquery produces any rows
+MATCH (p:Person)
+WHERE EXISTS {
+    MATCH (p)-[:KNOWS]->(friend:Person)
+    WHERE friend.age > 30
+}
+RETURN p.name
+
+// NOT EXISTS — negate with NOT
+MATCH (p:Person)
+WHERE NOT EXISTS { MATCH (p)-[:KNOWS]->(:Person) }
+RETURN p.name
+
+// COUNT — returns the number of rows the subquery produces
+MATCH (p:Person)
+WHERE COUNT { MATCH (p)-[:KNOWS]->(:Person) } > 2
+RETURN p.name
+
+// COUNT in RETURN
+MATCH (p:Person)
+RETURN p.name, COUNT { MATCH (p)-[:KNOWS]->(:Person) } AS friendCount
+
+// COLLECT — returns a list of single-column values from the subquery
+MATCH (p:Person)
+RETURN COLLECT {
+    MATCH (p)-[:KNOWS]->(friend:Person)
+    RETURN friend.name
+} AS friends
+
+// COLLECT with IN
+MATCH (p:Person)
+WHERE 'Alice' IN COLLECT { MATCH (p)-[:KNOWS]->(f:Person) RETURN f.name }
+RETURN p.name
+```
+
 **Node reference reuse across MATCH clauses:**
 
 ```cypher
@@ -674,6 +735,8 @@ RETURN f.name, f.description, f.category
 │  CONTAINS  ·  NOT CONTAINS                                  │
 │  STARTS WITH  ·  NOT STARTS WITH                            │
 │  ENDS WITH  ·  NOT ENDS WITH                                │
+│  EXISTS { subquery }  ·  NOT EXISTS { subquery }            │
+│  COUNT { subquery }  ·  COLLECT { subquery }                │
 ├─────────────────────────────────────────────────────────────┤
 │  EXPRESSIONS                                                │
 ├─────────────────────────────────────────────────────────────┤
@@ -698,6 +761,10 @@ RETURN f.name, f.description, f.category
 │  sum(x)  avg(x)  count(x)  min(x)  max(x)  collect(x)       │
 │  count(DISTINCT x)  ·  collect(DISTINCT x)                  │
 │  sum(v IN list | expr [WHERE cond])  -- inline predicate    │
+│  any(v IN list WHERE cond)            -- true if any match  │
+│  all(v IN list WHERE cond)            -- true if all match  │
+│  none(v IN list WHERE cond)           -- true if none match │
+│  single(v IN list WHERE cond)         -- true if one match  │
 ├─────────────────────────────────────────────────────────────┤
 │  SCALAR FUNCTIONS                                           │
 ├─────────────────────────────────────────────────────────────┤