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 浏览器中运行此查询，将返回以下图

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;

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

person	company
"Melissa"	"CompanyA"
"Diana"	"CompanyX"

person

company

"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;

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

person	dob
"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

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

person	dob
"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;

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

person	dob
"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;

person	dob	technologies	friends
"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"]

person

dob

technologies

friends

"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

oldest	youngest
1985-04-04	1988-08-08

oldest

youngest

1985-04-04

1988-08-08

总结

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