Match
Syntax
MatchStatement: MATCH PathPatthern (',' PathPatthern)* [WHERE boolExpr]
PathPatthern: Node ([Edge] Node)*
Node: '(' Identifier [ ':' StringLiteral ] [ WHERE boolExpr]
Edge: '-' '[' Identifier [ ':' StringLiteral ] [ WHERE boolExpr] ']' '-'
| '-' '[' Identifier [ ':' StringLiteral ] [ WHERE boolExpr] ']' '->'
| '<-' '[' Identifier [ ':' StringLiteral ] [ WHERE boolExpr] ']' '-'
Node
Match a vertex in the graph.
Edge
Match an edge in the graph. You can defined three kinds of edge direction: In, Out and Both.
Edge Direction
In Edge | Out Edge | Both Edge |
---|---|---|
<-[edge]- | -[edge]-> | -[edge]- |
Example
- Basic Mathch
-- Match all node
MATCH (a)
-- Match all person node
MATCH (a:person)
-- Match node where id = 1
MATCH (a:person where id = 1)
-- One hop match
MATCH (a:person where id = 1)-[e:knows where e.weight > 0.4]->(b:person)
-- Tow hop match
MATCH (a:person)-(b:person) <- (c)
-- Match in-vertex for node a
MATCH (a:person)<-[e:knows]-(b)
- Match With Filter
MATCH (a:person)<-[e:knows]-(b) Where a.id = b.id
- Match Join Match two path pattern and join them with the common label. e.g.
MATCH (a) -> (b), (a) -> (c)
The output is p1 = (a, b) join p2 = (a, c) on p1.a = p2.a.
Regex-Match
Syntax
PathPatthern: Node Edge '{' minHop ',' [ maxHop] '}' Node
Example
MATCH (a) -[e]->{1,5} (b)
MATCH (a) -[e]->{1,} (b)
Return
Syntax
RETURN expr {',' expr}*
[ GROUP BY expr {',' expr}* ]
[ ORDER BY expr [ASC|DESC] {',' expr [ASC|DESC]} ]
[ LIMIT number ]
Example
MATCH (a:person WHERE a.id = '1')-[e:knows]->(b:person)
RETURN a.name as name, b.id as b_id
MATCH (a:person WHERE a.id = '1')-[e:knows]->(b:person)
RETURN a, b
-- GROUP BY
MATCH (a:person)-[e:knows where e.weight > 0.4]->(b:person)
RETURN a.id, SUM(e.weight) * 10 as amt GROUP BY a.id
-- ORDER BY
MATCH (a:person WHERE a.id = '1')-[e:knows]->(b:person)
RETURN a, b order by a.age DESC, b.age ASC
-- LIMIT
MATCH (a:person WHERE a.id = '1')-[e:knows]->(b:person)
RETURN a, b order by a.age DESC, b.age ASC LIMIT 10
Let
Let statement is used to modify the attribute for the vertex or edge on the path.
Syntax
LET Identifier '.' Identifier = expr
Example
MATCH (a:person where a.id = 1) -[e:knows]->(b:person)
LET a.weight = a.age / cast(100.0 as double),
LET b.weight = b.age / cast(100.0 as double)
MATCH (a:person where a.id = 1) -[e:knows]->(b:person)
LET a.weight = a.age / cast(100.0 as double),
LET a.weight = a.weight * 2,
LET b.weight = 1.0,
LET b.age = 20
SubQuery
Syntax
Scalar Query
AggregateFunction '(' PathPatthern '=>' expr ')'
Exists Query
EXISTS PathPatthern
Example
Scalar Query Example
MATCH (a:person WHERE id = 1)-[e]->(b)
Where COUNT((b) ->(c) => c) >= 1
RETURN a, e, b
MATCH (a:person WHERE id = 1)-[e]->(b)
Let b.out_cnt = COUNT((b) ->(c) => c),
Let b.out_weight = SUM((b) -[e1]-> (c) => e1.weight)
RETURN a, e, b
Exists Query Example
MATCH (a:person WHERE id = 1)-[e]->(b)
Where EXISTS (b) -> (c)
And SUM((b) -[e1]-> (c) => e1.weight) > 1
RETURN a, e, b
Continue-Match
You can write a match follow another match. The return path will be the join of the two match.
Syntax
MatchStatement
MatchStatement
Example
MATCH (a:person where a.id = 1) -[e:knows]->(b:person)
LET a.weight = a.age / cast(100.0 as double),
LET a.weight = a.weight * 2
MATCH(b) -[]->(c)
RETURN a.id as a_id, a.weight as a_weight, b.id as b_id, c.id as c_id
MATCH (a) -> (b) where b.id > 0 and a.lang is null
MATCH (a) <- (c) where label(c) = 'person'
Let c.kind = 'k' || cast(c.age / 10 as varchar)
MATCH (c) -> (d) where d != b
Let d.type = if (label(d) = 'person', 1, 0)
RETURN a, b, c, d