Cypher 中的子查询

回顾我们的示例图

我们所有的代码示例都将继续使用我们之前的一个图示例，但会包含更多数据用于本页的查询。下面是新图的图像，一个由人员、他们工作的公司以及他们喜欢的技术组成的网络。

我们添加了一个额外的 Person 节点（蓝色），他 WORKS_FOR 一个 Company 节点（红色）并 LIKES 一个 Technology（绿色）节点：Ryan 在 Company Z 工作，喜欢 Python。您可以在图的右侧找到这些数据。

回顾一下，每个人还可能与其他人存在多个 IS_FRIENDS_WITH 关系。

您可以使用以下 Cypher^® 查询创建此数据集

CREATE (diana:Person {name: "Diana"})-[:LIKES]->(query:Technology {type: "Query Languages"})
CREATE (melissa:Person {name: "Melissa", twitter: "@melissa"})-[:LIKES]->(query)
CREATE (dan:Person {name: "Dan", twitter: "@dan", yearsExperience: 6})-[:LIKES]->(etl:Technology {type: "Data ETL"})<-[:LIKES]-(melissa)
CREATE (xyz:Company {name: "XYZ"})<-[:WORKS_FOR]-(sally:Person {name: "Sally", yearsExperience: 4})-[:LIKES]->(integrations:Technology {type: "Integrations"})<-[:LIKES]-(dan)
CREATE (sally)<-[:IS_FRIENDS_WITH]-(john:Person {name: "John", yearsExperience: 5, birthdate: "1985-04-04"})-[:LIKES]->(java:Technology {type: "Java"})
CREATE (john)<-[:IS_FRIENDS_WITH]-(jennifer:Person {name: "Jennifer", twitter: "@jennifer", yearsExperience: 5, birthdate: "1988-01-01"})-[:LIKES]->(java)
CREATE (john)-[:WORKS_FOR]->(xyz)
CREATE (sally)<-[:IS_FRIENDS_WITH]-(jennifer)-[:IS_FRIENDS_WITH]->(melissa)
CREATE (joe:Person {name: "Joe", birthdate: "1988-08-08"})-[:LIKES]->(query)
CREATE (mark:Person {name: "Mark", twitter: "@mark"})
CREATE (ann:Person {name: "Ann"})
CREATE (x:Company {name: "Company X"})<-[:WORKS_FOR]-(diana)<-[:IS_FRIENDS_WITH]-(joe)-[:IS_FRIENDS_WITH]->(mark)-[:LIKES]->(graphs:Technology {type: "Graphs"})<-[:LIKES]-(jennifer)-[:WORKS_FOR]->(:Company {name: "Neo4j"})
CREATE (ann)<-[:IS_FRIENDS_WITH]-(jennifer)-[:IS_FRIENDS_WITH]->(mark)
CREATE (john)-[:LIKES]->(:Technology {type: "Application Development"})<-[:LIKES]-(ann)-[:IS_FRIENDS_WITH]->(dan)-[:WORKS_FOR]->(abc:Company {name: "ABC"})
CREATE (ann)-[:WORKS_FOR]->(abc)
CREATE (a:Company {name: "Company A"})<-[:WORKS_FOR]-(melissa)-[:LIKES]->(graphs)<-[:LIKES]-(diana)
CREATE (:Technology {type: "Python"})<-[:LIKES]-(:Person {name: "Ryan"})-[:WORKS_FOR]->(:Company {name: "Company Z"})

子查询简介

子查询是在 Neo4j 4.0 中引入的。

有关如何使用子查询的详细信息，请参查阅 Cypher 手册 → 子查询。

Neo4j 中支持以下类型的子查询

本节将介绍 EXISTS、COUNT 和 CALL {…} 子查询。

要了解有关使用 CALL {…} IN TRANSACTIONS 的更多信息，请参阅以下关于如何将 CSV 数据导入 Neo4j 数据库的教程中的代码示例

COLLECT 子查询是在 Neo4j 5.6 中引入的。它是一种新的子查询类型，用于将子查询的结果收集到列表中，以便执行 DISTINCT、ORDER BY、LIMIT 和 SKIP 等后续操作。COLLECT 子查询与 COUNT 和 EXISTS 子查询的不同之处在于，最终的 RETURN 子句是强制性的。COLLECT 子查询中的 RETURN 子句必须只返回一列。

Cypher 子查询

子查询是一组在自己的作用域内执行的 Cypher 语句。子查询通常从外部包围查询中调用。

以下是关于子查询的一些重要注意事项

子查询返回 RETURN 子句中变量引用的值。
子查询不能返回与包围查询中使用的变量同名的变量。
您必须将包围查询中的变量显式传递给子查询。

子查询由大括号 ({ }) 界定。

在获取正确的结果章节的 基于模式进行过滤 部分，您学习了如何根据模式进行过滤。例如，您可以编写以下查询来查找为 Neo4j 工作的人的朋友

MATCH (p:Person)-[r:IS_FRIENDS_WITH]->(friend:Person)
WHERE exists((p)-[:WORKS_FOR]->(:Company {name: 'Neo4j'}))
RETURN p, r, friend

如果您在 Neo4j Browser 中运行此查询，将返回以下图

Cypher 子查询实现了更强大的模式过滤。您可以使用 EXISTS 子查询，而不是在 WHERE 子句中使用 exists 函数。您可以使用以下查询重现之前的示例

MATCH (p:Person)-[r:IS_FRIENDS_WITH]->(friend:Person)
WHERE EXISTS {
  MATCH (p)-[:WORKS_FOR]->(:Company {name: 'Neo4j'})
}
RETURN p, r, friend

您将得到相同的结果，这很好，但到目前为止，您所做的一切只是用更多的代码实现了相同的功能！

接下来，让我们编写一个子查询，其过滤能力比单独使用 WHERE 子句或 exists 函数所能达到的更强大。

假设

您想找到为名称以“Company”开头的公司工作，并且喜欢至少一种被三个人或更多人喜欢的技术的人。
您对这些技术是什么不感兴趣。

您可能会尝试用以下查询来回答这个问题

MATCH (person:Person)-[:WORKS_FOR]->(company)
WHERE company.name STARTS WITH "Company"
AND (person)-[:LIKES]->(t:Technology)
AND COUNT { (t)<-[:LIKES]-() } >= 3
RETURN person.name as person, company.name AS company;

如果您运行此查询，您将看到以下输出

Variable `t` not defined (line 4, column 25 (offset: 112))
"AND (person)-[:LIKES]->(t:Technology)"
                         ^

您可以找到喜欢某种技术的人，但无法检查是否有至少三个人也喜欢该技术，因为变量 t 不在 WHERE 子句的作用域内。相反，让我们将两个 AND 语句移入 EXISTS 子查询块，结果就是以下查询

MATCH (person:Person)-[:WORKS_FOR]->(company)
WHERE company.name STARTS WITH "Company"
AND EXISTS {
  MATCH (person)-[:LIKES]->(t:Technology)
  WHERE COUNT { (t)<-[:LIKES]-() } >= 3
}
RETURN person.name as person, company.name AS company;

现在您可以成功运行查询，它将返回以下结果

人物	公司
"Melissa"	"CompanyA"
"Diana"	"CompanyX"

人物

公司

"Melissa"

"CompanyA"

"Diana"

"CompanyX"

如果您回顾本指南开头的图可视化，Ryan 是唯一一个为名称以“Company”开头的公司工作的其他人。他在此查询中被过滤掉了，因为他唯一喜欢的 Technology 是 Python，并且没有其他三个人喜欢 Python。

返回结果的子查询

到目前为止，您已经学习了如何使用子查询来过滤结果，但这并未完全展示其强大功能。您还可以使用子查询来返回结果。

假设您想编写一个查询，查找喜欢 Java 或拥有多个朋友的人。除此之外，您还想按出生日期降序返回结果。这可以使用 UNION 子句和 COUNT 子查询部分实现

MATCH (p:Person)-[:LIKES]->(:Technology {type: "Java"})
RETURN p.name AS person, p.birthdate AS dob
ORDER BY dob DESC

UNION

MATCH (p:Person)
WHERE COUNT { (p)-[:IS_FRIENDS_WITH]->() } > 1
RETURN p.name AS person, p.birthdate AS dob
ORDER BY dob DESC;

如果您运行该查询，您将看到以下输出

人物	出生日期
"Jennifer"	1988-01-01
"John"	1985-04-04
"Joe"	1988-08-08

您已获得了正确的人员。但 UNION 方法只允许我们按每个 UNION 子句对结果进行排序，而不是对所有行进行排序。

您可以尝试另一种方法，单独执行每个子查询，并使用 collect() 函数从每个部分收集人员。有些人喜欢 Java 并且拥有多个朋友，因此您需要在 RETURN 子句中使用 DISTINCT 运算符来去除重复项

// Find people who like Java
MATCH (p:Person)-[:LIKES]->(:Technology {type: "Java"})
WITH collect(p) AS peopleWhoLikeJava

// Find people with more than one friend
MATCH (p:Person)
WHERE COUNT { (p)-[:IS_FRIENDS_WITH]->() } > 1
WITH collect(p) AS popularPeople, peopleWhoLikeJava
WITH popularPeople + peopleWhoLikeJava AS people

// Unpack the collection of people and order by birthdate
UNWIND people AS p
RETURN DISTINCT p.name AS person, p.birthdate AS dob
ORDER BY dob DESC

如果您运行该查询，您将获得以下输出

人物	出生日期
"Joe"	1988-08-08
"Jennifer"	1988-01-01
"John"	1985-04-04

这种方法可行，但编写起来更困难，因为您必须不断地将查询的一部分传递到下一部分。

CALL {…} 子句为您提供了两全其美的优势

您可以使用 UNION 方法运行单个查询并删除重复项。
您可以在之后对结果进行排序。

我们使用 CALL {…} 子句的查询如下所示

CALL {
	MATCH (p:Person)-[:LIKES]->(:Technology {type: "Java"})
	RETURN p

	UNION

	MATCH (p:Person)
	WHERE COUNT { (p)-[:IS_FRIENDS_WITH]->() } > 1
	RETURN p
}
RETURN p.name AS person, p.birthdate AS dob
ORDER BY dob DESC;

如果您运行该查询，您将获得以下输出

人物	出生日期
"Joe"	1988-08-08
"Jennifer"	1988-01-01
"John"	1985-04-04

您可以进一步扩展查询，以返回这些人喜欢的技术以及他们的朋友。以下查询展示了如何做到这一点

CALL {
	MATCH (p:Person)-[:LIKES]->(:Technology {type: "Java"})
	RETURN p

	UNION

	MATCH (p:Person)
	WHERE COUNT { (p)-[:IS_FRIENDS_WITH]->() } > 1
	RETURN p
}
WITH p,
     [(p)-[:LIKES]->(t) | t.type] AS technologies,
     [(p)-[:IS_FRIENDS_WITH]->(f) | f.name] AS friends

RETURN p.name AS person, p.birthdate AS dob, technologies, friends
ORDER BY dob DESC;

人物	出生日期	技术	朋友
"Joe"	1988-08-08	["Query Languages"]	["Mark", "Diana"]
"Jennifer"	1988-01-01	["Graphs", "Java"]	["Sally", "Mark", "John", "Ann", "Melissa"]
"John"	1985-04-04	["Java", "Application Development"]	["Sally"]

人物

出生日期

技术

朋友

"Joe"

1988-08-08

["Query Languages"]

["Mark", "Diana"]

"Jennifer"

1988-01-01

["Graphs", "Java"]

["Sally", "Mark", "John", "Ann", "Melissa"]

"John"

1985-04-04

["Java", "Application Development"]

["Sally"]

您还可以将聚合函数应用于子查询的结果。以下查询返回喜欢 Java 或拥有多个朋友的人中最年轻和最年长的。

CALL {
	MATCH (p:Person)-[:LIKES]->(:Technology {type: "Java"})
	RETURN p

	UNION

	MATCH (p:Person)
	WHERE COUNT { (p)-[:IS_FRIENDS_WITH]->() } > 1
	RETURN p
}
RETURN min(p.birthdate) AS oldest, max(p.birthdate) AS youngest

最年长	最年轻
1985-04-04	1988-08-08

最年长

最年轻

1985-04-04

1988-08-08

总结

您已经了解了如何使用 EXISTS {} 子查询编写复杂的过滤模式，以及如何使用 CALL {} 子句执行返回结果的子查询。