MATCH

MATCH 子句允许您定义数据库将在其图结构中搜索的特定模式。MATCH 子句可以指定模式中的节点、关系和属性，从而允许查询遍历图以检索相关数据。

示例图

以下图用于下面的示例

要重新创建图，请对空 Neo4j 数据库运行以下查询

CREATE (charlie:Person:Actor {name: 'Charlie Sheen'}),
       (martin:Person:Actor {name: 'Martin Sheen'}),
       (michael:Person:Actor {name: 'Michael Douglas'}),
       (oliver:Person:Director {name: 'Oliver Stone'}),
       (rob:Person:Director {name: 'Rob Reiner'}),
       (wallStreet:Movie {title: 'Wall Street'}),
       (charlie)-[:ACTED_IN {role: 'Bud Fox'}]->(wallStreet),
       (martin)-[:ACTED_IN {role: 'Carl Fox'}]->(wallStreet),
       (michael)-[:ACTED_IN {role: 'Gordon Gekko'}]->(wallStreet),
       (oliver)-[:DIRECTED]->(wallStreet),
       (thePresident:Movie {title: 'The American President'}),
       (martin)-[:ACTED_IN {role: 'A.J. MacInerney'}]->(thePresident),
       (michael)-[:ACTED_IN {role: 'President Andrew Shepherd'}]->(thePresident),
       (rob)-[:DIRECTED]->(thePresident)

查找节点

MATCH 子句允许您指定不同复杂度的节点模式以从图中检索。有关查找节点模式的更多信息，请参阅模式 → 节点模式。

查找所有节点

通过指定一个不带标签的单节点模式，将返回图中的所有节点。

查找图中的所有节点

MATCH (n)
RETURN n

表 1. 结果
n
`(:Person {"name":"Charlie Sheen"})`
`(:Person {"name":"Martin Sheen"})`
`(:Person {"name":"Michael Douglas"})`
`(:Person {"name":"Oliver Stone"})`
`(:Person {"name":"Rob Reiner"})`
`(:Movie {"title":"Wall Street"})`
`(:Movie {"title":"The American President"})`
行数：7

查找具有特定标签的节点

查找所有带有 Movie 标签的节点

MATCH (movie:Movie)
RETURN movie.title

表 2. 结果
movie.title
`"Wall Street"`
`"The American President"`
行数：2

使用节点标签表达式的 MATCH

使用 OR (|) 标签表达式的节点模式

MATCH (n:Movie|Person)
RETURN n.name AS name, n.title AS title

表 3. 结果
name	title
`"Charlie Sheen"`	`<null>`
`"Martin Sheen"`	`<null>`
`"Michael Douglas"`	`<null>`
`"Oliver Stone"`	`<null>`
`"Rob Reiner"`	`<null>`
`<null>`	`"Wall Street"`
`<null>`	`"The American President"`
行数：7

使用否定 (!) 标签表达式的节点模式

MATCH (n:!Movie)
RETURN labels(n) AS label, count(n) AS labelCount

以上查询使用了 labels() 和 count() 函数。

表 4. 结果
label	labelCount
`["Person", "Actor"]`	`3`
`["Person", "Director"]`	`2`
行数：2

有关 Cypher^® 支持的所有标签表达式的列表，请参阅模式 → 标签表达式。

查找关系

MATCH 子句允许您指定不同复杂度的关系模式以从图中检索。与节点模式不同，关系模式不能在没有两端节点模式的情况下在 MATCH 子句中使用。有关关系模式的更多信息，请参阅模式 → 关系模式。

在一个模式中，关系只会被匹配一次。有关此行为的更多信息，请参阅关系唯一性部分。

空关系模式

通过应用 --，将匹配任意方向且不对关系类型或属性进行任何过滤的关系模式。

使用空关系模式查找连接的节点

MATCH (:Person {name: 'Oliver Stone'})--(n)
RETURN n AS connectedNodes

表 5. 结果
connectedNodes
`(:Movie {title: "Wall Street"})`
行数：1

有向关系模式

模式中关系的方向由箭头指示：--> 或 <--。

查找通过传出关系连接到 Oliver Stone 的所有节点。

MATCH (:Person {name: 'Oliver Stone'})-->(movie:Movie)
RETURN movie.title AS movieTitle

表 6. 结果
movieTitle
`"Wall Street"`
行数：1

关系变量

可以在模式中引入变量，用于筛选关系属性或返回关系。

查找别名关系的类型

MATCH (:Person {name: 'Oliver Stone'})-[r]->()
RETURN type(r) AS relType

以上查询使用了 type() 函数。

表 7. 结果
relType
`"DIRECTED"`
行数：1

匹配无向关系

当模式中包含绑定关系且该关系模式未指定方向时，Cypher 将匹配双向关系。

无方向关系模式

MATCH (a)-[:ACTED_IN {role: 'Bud Fox'}]-(b)
RETURN a, b

表 8. 结果
a	b
`(:Movie {"title":"Wall Street"})`	`(:Person {"name":"Charlie Sheen"})`
`(:Person {"name":"Charlie Sheen"})`	`(:Movie {"title":"Wall Street"})`
行数：2

按关系类型筛选

可以通过在关系类型前使用冒号 (:) 来指定关系模式中的关系类型。

按 ACTED_IN 关系类型筛选的关系模式

MATCH (:Movie {title: 'Wall Street'})<-[:ACTED_IN]-(actor:Person)
RETURN actor.name AS actor

表 9. 结果
actor
`"Michael Douglas"`
`"Martin Sheen"`
`"Charlie Sheen"`
行数：3

使用关系类型表达式的 MATCH

可以使用 OR 符号 (|) 匹配包含多种关系类型之一的模式。

包含 ACTED_IN 或 DIRECTED 关系类型的关系模式

MATCH (:Movie {title: 'Wall Street'})<-[:ACTED_IN|DIRECTED]-(person:Person)
RETURN person.name AS person

表 10. 结果
person
`"Oliver Stone"`
`"Michael Douglas"`
`"Martin Sheen"`
`"Charlie Sheen"`
行数：4

由于每个关系只能有一种类型，因此 ()-[:A&B]→() 将永远不会匹配到任何关系。

有关 Cypher 支持的所有关系类型表达式的列表，请参阅模式 → 标签表达式。

查找多个关系

图模式可以包含多个关系模式。

包含多个关系模式的图模式

MATCH (:Person {name: 'Charlie Sheen'})-[:ACTED_IN]->(movie:Movie)<-[:DIRECTED]-(director:Person)
RETURN movie.title AS movieTitle, director.name AS director

表 11. 结果
movieTitle	director
`"Wall Street"`	`"Oliver Stone"`
行数：1

带有 WHERE 谓词的 MATCH

MATCH 子句通常与 WHERE 子句配对使用，后者添加谓词以细化模式，使其更具体。这些谓词是模式本身的一部分，而不仅仅是匹配后应用的过滤器。因此，始终将 WHERE 子句与其对应的 MATCH 子句放在一起。

简单 WHERE 谓词

MATCH (charlie:Person)-[:ACTED_IN]->(movie:Movie)
WHERE charlie.name = 'Charlie Sheen'
RETURN movie.title AS movieTitle

表 12. 结果
movieTitle
`"Wall Street"`
行数：1

更复杂的 WHERE 谓词

MATCH (martin:Person)-[:ACTED_IN]->(movie:Movie)
WHERE martin.name = 'Martin Sheen' AND NOT EXISTS {
    MATCH (movie)<-[:DIRECTED]-(director:Person {name: 'Oliver Stone'})
}
RETURN movie.title AS movieTitle

以上查询使用了 EXISTS 子查询。

表 13. 结果
movieTitle
`"The American President"`
行数：1

有关更多信息，请参阅WHERE 页面。

带有参数的 MATCH

MATCH 子句可以与参数一起使用。

参数

{
  "movieTitle": "Wall Street",
  "actorRole": "Fox"
}

使用参数查找节点

MATCH (:Movie {title: $movieTitle})<-[r:ACTED_IN]-(p:Person)
WHERE r.role CONTAINS $actorRole
RETURN p.name AS actor, r.role AS role

以上查询使用了 CONTAINS 运算符。

表 14. 结果
actor	role
`"Charlie Sheen"`	`"Bud Fox"`
`"Martin Sheen"`	`"Carl Fox"`
行数：2

有关如何设置参数的更多信息，请参阅语法 → 参数。

查找路径

MATCH 子句也可以用于将整个路径绑定到变量。

查找匹配模式的所有路径

MATCH path = ()-[:ACTED_IN]->(movie:Movie)
RETURN path

表 15. 结果
path
`(:Person {name: "Charlie Sheen"})-[:ACTED_IN {role: "Bud Fox"}]→(:Movie {title: "Wall Street"})`
`(:Person {name: "Martin Sheen"})-[:ACTED_IN {role: "Carl Fox"}]→(:Movie {title: "Wall Street"})`
`(:Person {name: "Martin Sheen"})-[:ACTED_IN {role: "A.J. MacInerney"}]→(:Movie {title: "The American President"})`
`(:Person {name: "Michael Douglas"})-[:ACTED_IN {role: "Gordon Gekko"}]→(:Movie {title: "Wall Street"})`
`(:Person {name: "Michael Douglas"})-[:ACTED_IN {role: "President Andrew Shepherd"}]→(:Movie {title: "The American President"})`
行数：5

查找包含 WHERE 谓词的匹配模式的路径

MATCH path = (:Person)-[:ACTED_IN]->(movie:Movie)<-[:DIRECTED]-(:Person)
WHERE movie.title = 'Wall Street'
RETURN path

表 16. 结果
path
`(:Person {name: "Charlie Sheen"})-[:ACTED_IN {role: "Bud Fox"}]→(:Movie {title: "Wall Street"})←[:DIRECTED]-(:Person {name: "Oliver Stone"})`
`(:Person {name: "Martin Sheen"})-[:ACTED_IN {role: "Carl Fox"}]→(:Movie {title: "Wall Street"})←[:DIRECTED]-(:Person {name: "Oliver Stone"})`
`(:Person {name: "Michael Douglas"})-[:ACTED_IN {role: "Gordon Gekko"}]→(:Movie {title: "Wall Street"})←[:DIRECTED]-(:Person {name: "Oliver Stone"})`
行数：3

有关如何使用 MATCH 查找不同复杂度的模式（包括量化路径模式、量化关系以及节点之间的最短路径）的更多信息，请参阅模式部分。

多个 MATCH 子句、WITH 子句和子句构成

在 Cypher 中，查询的行为由其子句定义。每个子句获取当前图状态和中间结果表，处理它们，然后将更新后的图状态和结果传递给下一个子句。第一个子句以图的初始状态和空表开始，而最后一个子句生成查询结果。

链接连续的 MATCH 子句

MATCH (:Person {name: 'Martin Sheen'})-[:ACTED_IN]->(movie:Movie) (1)
MATCH (director:Person)-[:DIRECTED]->(movie) (2)
RETURN director.name AS director, movie.title AS movieTitle

1	第一个 `MATCH` 子句的结果是变量 `movie`，它包含 `Martin Sheen` `ACTED_IN` 的所有 `Movie`。
2	第二个 `MATCH` 子句使用 `movie` 变量来查找与 `Martin Sheen` `ACTED_IN` 的那些 `Movie` 节点具有 `DIRECTED` 关系的任何 `Person` 节点。

表 17. 结果
director	movieTitle
`"Oliver Stone"`	`"Wall Street"`
`"Rob Reiner"`	`"The American President"`
行数：2

通过在另一个操作中引用变量，可以隐式地将其传递给后续子句。也可以使用 WITH 子句将变量显式地传递给后续子句。如果变量既没有隐式也没有显式地传递给后续子句，它将被丢弃，并且在查询后期不可用作引用。

使用 WITH 和多个 MATCH 子句

MATCH (actors:Person)-[:ACTED_IN]->(movies:Movie) (1)
WITH actors, count(movies) AS movieCount (2)
ORDER BY movieCount DESC
LIMIT 1 (3)
MATCH (actors)-[:ACTED_IN]->(movies) (4)
RETURN actors.name AS actor, movieCount, collect(movies.title) AS movies

1	此步骤中匹配的 `Person` 和 `Movie` 节点存储在变量中，然后传递给查询的第二行。
2	`movies` 变量通过其在 `count()` 函数中的出现而隐式导入。`WITH` 子句显式导入 `actors` 变量。
3	一个 `ORDER BY` 子句按 `movieCount` 降序排列结果，确保电影数量最多的 `Person` 出现在顶部，并且 `LIMIT` `1` 确保所有其他 `Person` 节点被丢弃。
4	第二个 `MATCH` 子句查找与当前绑定到 `actors` 变量的 `Person` 节点相关联的所有 `Movie` 节点。

以上查询使用了 collect() 函数。

表 18. 结果
actor	movieCount	movies
`"Martin Sheen"`	`2`	`["Wall Street", "The American President"]`
行数：1

有关 Cypher 查询如何工作的更多信息，请参阅子句构成。

使用动态节点标签和关系类型的 MATCH

在匹配节点和关系时，节点标签和关系类型可以在表达式、参数和变量中动态引用。这允许更灵活的查询，并降低 Cypher 注入的风险。(有关 Cypher 注入的更多信息，请参阅Neo4j 知识库 → 防止 Cypher 注入)。

动态匹配节点标签的语法

MATCH (n:$(<expr>))
MATCH (n:$any(<expr>))
MATCH (n:$all(<expr>))

MATCH (n:$all(<expr>)) 在功能上等同于 MATCH (n:$(<expr>))。

动态匹配关系类型的语法

MATCH ()-[r:$(<expr>))]->()
MATCH ()-[r:$any(<expr>)]->()
MATCH ()-[r:$all(<expr>))]->()

表达式必须评估为 STRING NOT NULL | LIST<STRING NOT NULL> NOT NULL 值。如果在具有动态关系类型的关系模式中使用包含多个项的 LIST<STRING>，则不会返回任何结果。这是因为关系只能有一种类型。

动态匹配标签

WITH ["Person", "Director"] AS labels
MATCH (directors:$(labels))
RETURN directors

表 19. 结果
directors
`(:Person:Director {name: "Oliver Stone"})`
`(:Person:Director {name: "Rob Reiner"})`
行数：2

使用 any() 动态匹配节点

MATCH (n:$any(["Movie", "Actor"]))
RETURN n AS nodes

表 20. 结果
nodes
`(:Person:Actor {name: "Charlie Sheen"})`
`(:Person:Actor {name: "Martin Sheen"})`
`(:Person:Actor {name: "Michael Douglas"})`
`(:Movie {title: "Wall Street"})`
`(:Movie {title: "The American President"})`
行数：5

参数

{
  "label": "Movie"
}

使用参数动态匹配节点

MATCH (movie:$($label))
RETURN movie.title AS movieTitle

表 21. 结果
movieTitle
`"Wall Street"`
`"The American President"`
行数：2

使用变量动态匹配关系

CALL db.relationshipTypes()
YIELD relationshipType
MATCH ()-[r:$(relationshipType)]->()
RETURN relationshipType, count(r) AS relationshipCount

表 22. 结果
relationshipType	relationshipCount
`"ACTED_IN"`	`5`
`"DIRECTED"`	`2`
行数：2

性能注意事项

使用动态值的 MATCH 查询可能不如使用静态值的查询那样高效。这是因为 Cypher 规划器在规划查询时使用静态可用信息来确定是否使用索引，而在使用动态值时无法实现这一点。

因此，使用动态值的 MATCH 查询无法利用索引扫描或查找，而必须使用 AllNodesScan 运算符，该运算符从节点存储中读取所有节点，因此成本更高。

延伸阅读

Neo4j 开发者博客：Cypher 动态性：迈向更简单、更安全的查询