Filtering¶
The WHERE clause filters results based on conditions.
Comparison Operators¶
// Equality
WHERE p.name = 'Alix'
// Inequality
WHERE p.age <> 30
// Greater/less than
WHERE p.age > 25
WHERE p.age < 40
WHERE p.age >= 25
WHERE p.age <= 40
Boolean Logic¶
// AND
WHERE p.age > 25 AND p.active = true
// OR
WHERE p.city = 'NYC' OR p.city = 'LA'
// NOT
WHERE NOT p.archived
// Combined
WHERE (p.age > 25 AND p.active) OR p.role = 'admin'
String Operations¶
// Starts with
WHERE p.name STARTS WITH 'Al'
// Ends with
WHERE p.email ENDS WITH '@company.com'
// Contains
WHERE p.bio CONTAINS 'engineer'
// Regular expression
WHERE p.email =~ '.*@gmail\\.com'
List Operations¶
// IN list
WHERE p.status IN ['active', 'pending']
// Element in property list
WHERE 'admin' IN p.roles
Null Checks¶
Property Existence¶
// Check if property exists
WHERE exists(p.email)
// Combined with value check
WHERE p.age IS NOT NULL AND p.age > 18
Relationship WHERE¶
Inline predicates directly on relationship patterns:
// Inline predicate on relationship
MATCH (a)-[r:KNOWS WHERE r.since > 2020]->(b)
RETURN a.name, b.name
// Equivalent to separate WHERE
MATCH (a)-[r:KNOWS]->(b)
WHERE r.since > 2020
RETURN a.name, b.name
EXISTS Subqueries¶
Check for the existence of a pattern:
// People who manage at least one team
MATCH (p:Person)
WHERE EXISTS {
MATCH (p)-[:MANAGES]->(:Team)
}
RETURN p.name
// NOT EXISTS
MATCH (p:Person)
WHERE NOT EXISTS {
MATCH (p)-[:ORDERED]->(:Order)
}
RETURN p.name AS no_orders
List Predicate Functions¶
// any(): at least one element matches
MATCH (p:Person)
WHERE any(role IN p.roles WHERE role = 'admin')
RETURN p.name
// all(): every element matches
MATCH path = (a)-[:KNOWS*]->(b)
WHERE all(n IN nodes(path) WHERE n.active = true)
RETURN path
// none(): no element matches
MATCH (p:Person)
WHERE none(tag IN p.tags WHERE tag = 'inactive')
RETURN p.name
// single(): exactly one element matches
MATCH (p:Person)
WHERE single(role IN p.roles WHERE role = 'lead')
RETURN p.name
reduce()¶
Fold a list into a single value:
// Sum a list
RETURN reduce(acc = 0, x IN [1, 2, 3, 4, 5] | acc + x) AS total
// String concatenation
MATCH (p:Person)-[:KNOWS]->(f:Person)
WITH p, collect(f.name) AS friends
RETURN p.name, reduce(s = '', name IN friends | s + name + ', ') AS friend_list