谓词函数

简介

谓词是布尔函数，针对给定的非 null 输入返回 true 或 false。它们最常用于在查询的 WHERE 部分中过滤路径。

示例图

以下图表用于下方的示例

要重新创建它，请在空的 Neo4j 数据库中运行以下查询

CREATE
  (keanu:Person {name:'Keanu Reeves', age:58, nationality:'Canadian'}),
  (carrie:Person {name:'Carrie Anne Moss', age:55, nationality:'American'}),
  (liam:Person {name:'Liam Neeson', age:70, nationality:'Northern Irish'}),
  (guy:Person {name:'Guy Pearce', age:55, nationality:'Australian'}),
  (kathryn:Person {name:'Kathryn Bigelow', age:71, nationality:'American'}),
  (jessica:Person {name:'Jessica Chastain', age:45, address:''}),
  (theMatrix:Movie {title:'The Matrix'}),
  (keanu)-[:KNOWS {since: 1999}]->(carrie),
  (keanu)-[:KNOWS {since: 2005}]->(liam),
  (keanu)-[:KNOWS {since: 2010}]->(kathryn),
  (kathryn)-[:KNOWS {since: 2012}]->(jessica),
  (carrie)-[:KNOWS {since: 2008}]->(guy),
  (liam)-[:KNOWS {since: 2009}]->(guy),
  (keanu)-[:ACTED_IN]->(theMatrix),
  (carrie)-[:ACTED_IN]->(theMatrix)

all()

详细信息
语法	`all(variable IN list WHERE predicate)`
描述	如果谓词对给定 `LIST<ANY>` 中的所有元素成立，则返回 true。
参数	名称	类型	描述
	`variable`	`ANY`	可在 `WHERE` 子句中使用的变量。
	`list`	`LIST<ANY>`	此列表中的所有元素都必须满足谓词，函数才会返回 `true`。
	`predicate`	`ANY`	针对给定列表中所有项进行测试的谓词。
返回	`布尔值 (BOOLEAN)`

注意事项
`all()` 与大多数 Cypher® 函数不同，因为它会遍历列表并对每个元素求值表达式，而不是从单个求值中返回结果。
如果 `list` 为 `null`，或者 `predicate` 对至少一个元素求值为 `null` 且对任何其他元素均不求值为 false，则返回 `null`。
如果 `list` 为空，`all()` 返回 `true`，因为没有元素可以使 `predicate` 失效。

示例 1. all()

查找所有节点满足给定属性值的路径

MATCH p = (a:Person {name: 'Keanu Reeves'})-[]-{2,}()
WHERE all(x IN nodes(p) WHERE x.age < 60)
RETURN [n IN nodes(p) | n.name] AS actorsList

返回路径中的所有节点，其 age 属性均低于 60

结果
actorsList
`["基努·里维斯 (Keanu Reeves)", "凯瑞-安·莫斯 (Carrie Anne Moss)", "盖·皮尔斯 (Guy Pearce)"]`
行：2

对空 LIST 使用 all()

WITH [] as emptyList
RETURN all(i in emptyList WHERE true) as allTrue, all(i in emptyList WHERE false) as allFalse

结果
allTrue	allFalse
`TRUE`	`TRUE`
行：1

allReduce()
仅 Cypher 252025.08 引入

详细信息
语法	`allReduce(accumulator = initial, stepVariable IN list \| reductionFunction, predicate)`
描述	如果在给定 `LIST<ANY>` 元素的逐步求值过程中，累积结果在每一步都满足指定的谓词，则返回 true。如果该列表是量化路径模式中定义的组变量，则其谓词将在适用的地方进行内联。这种内联允许在谓词不满足时立即丢弃路径，从而提前修剪搜索空间。请注意，当在最短路径模式中使用 `allReduce()` 谓词时，它们不会被内联，因此无法从这种修剪中受益。
参数	名称	类型	描述
	`accumulator`	`ANY`	一个变量，在列表迭代时保存 `reductionFunction` 的结果。它使用 `initial` 的值进行初始化。
	`initial`	`ANY`	首次执行 `reductionFunction` 时 `accumulator` 的值。
	`stepVariable`	`ANY`	迭代期间保存 `list` 中每个元素值的变量。
	`list`	`LIST<ANY>`	正在迭代的列表。
	`reductionFunction`	`ANY`	一个表达式，其返回值将成为 `accumulator` 的下一个值。返回类型必须与 `initial` 的返回类型匹配。
	`predicate`	`布尔值 (BOOLEAN)`	在每次迭代中评估的谓词。它可以访问 `accumulator` 和 `stepVariable` 变量。
返回	`布尔值 (BOOLEAN)`

注意事项
`allReduce()` 与大多数 Cypher 函数不同，因为它会遍历列表并对每个元素求值表达式，而不是从单个求值中返回结果。
`allReduce()` 结合了 `all()` 和 `reduce()` 函数的功能。
如果 `predicate` 的所有求值结果均为 `true`，则 `allReduce()` 返回 `true`。
如果 `predicate` 的任何求值结果为 `false`，则 `allReduce()` 返回 `false`。
如果 `list` 为空，`allReduce()` 返回 `true`，因为没有元素可以使 `predicate` 失效。
如果 `list` 为 `null`，或者 `predicate` 对至少一个元素求值为 `null` 且对任何其他元素均不求值为 `false`，则返回 `null`。

示例 2. allReduce()

以下查询查找长度为 3 的 KNOWS 路径，其中 accumulator 以第一个节点的 age 开始，且路径中所有节点的累计 age 值从未超过 230。不满足此要求的路径将被排除，例如序列为 ["Keanu Reeves (58)", "Carrie Anne Moss (55)", "Guy Pearce (55)", "Liam Neeson (70)"] 的路径，其累计 age 值为 238。

在边界内查找累计年龄

MATCH (s) (()-[:KNOWS]-(n)){3}
WHERE allReduce(
  acc = s.age,
  node IN n | acc + node.age,
  acc < 230
)
RETURN [i IN [s] + n | i.name || " (" + toString(i.age) || ")"] AS ageSequence,
      reduce(acc = 0, node IN [s] + n | acc + node.age) AS aggregatedAges
ORDER BY aggregatedAges

结果
ageSequence	aggregatedAges
`["Carrie Anne Moss (55)", "Keanu Reeves (58)", "Kathryn Bigelow (71)", "Jessica Chastain (45)"]`	`229`
`["Jessica Chastain (45)", "Kathryn Bigelow (71)", "Keanu Reeves (58)", "Carrie Anne Moss (55)"]`	`229`
行：2

下一个查询使用 allReduce() 比较相邻关系。它查找长度至少为 3 的 KNOWS 路径，其中每个关系的 since 值都大于前一个值且高于 2000。

查找关系属性必须高于某值并沿路径递增的路径

MATCH path = ()-[r:KNOWS]-{3,}()
WHERE allReduce(
  span = {},
  rel IN r | { previous: span.current, current: rel.since },
  (span.previous IS NULL OR span.previous < span.current) AND span.current > 2000
)
LET people = nodes(path)
RETURN [actor IN people | actor.name] AS connectedActors,
       [rel IN r | rel.since] AS sinceYears
ORDER BY sinceYears

结果
connectedActors	sinceYears
`["Liam Neeson", "Keanu Reeves", "Kathryn Bigelow", "Jessica Chastain"]`	`[2005, 2010, 2012]`
行：1

any()

详细信息
语法	`any(variable IN list WHERE predicate)`
描述	如果谓词对给定 `LIST<ANY>` 中的至少一个元素成立，则返回 true。
参数	名称	类型	描述
	`variable`	`ANY`	可在 `WHERE` 子句中使用的变量。
	`list`	`LIST<ANY>`	此列表中的所有元素都必须满足谓词，函数才会返回 `true`。
	`predicate`	`ANY`	针对给定列表中所有项进行测试的谓词。
返回	`布尔值 (BOOLEAN)`

注意事项
`any()` 与大多数 Cypher 函数不同，因为它会遍历列表并对每个元素求值表达式，而不是从单个求值中返回结果。
如果 `list` 为 `null`，或者 `predicate` 对至少一个元素求值为 `null` 且对任何其他元素均不求值为 false，则返回 `null`。
如果 `list` 为空，`any()` 返回 `false`，因为没有元素可以满足 `predicate`。

示例 3. any()

查找至少有一个关系属性高于给定阈值的路径

MATCH p = (n:Person {name: 'Keanu Reeves'})-[:KNOWS]-{3}()
WHERE any(rel IN relationships(p) WHERE rel.since < 2000)
RETURN [person IN nodes(p) | person.name] AS connectedActors,
       [rel IN relationships(p) | rel.since] AS sinceYears

结果
connectedActors	sinceYears
`["Keanu Reeves", "Carrie Anne Moss", "Guy Pearce", "Liam Neeson"]`	`[1999, 2008, 2009]`
行：1

对空 LIST 使用 any()

WITH [] as emptyList
RETURN any(i IN emptyList WHERE true) as anyTrue, any(i IN emptyList WHERE false) as anyFalse

结果
anyTrue	anyFalse
`false`	`false`
行：1

exists()

详细信息
语法	`exists(input)`
描述	如果图中存在与模式的匹配项，则返回 true。
参数	名称	类型	描述
	`input`	`ANY`	要验证其存在的模式。
返回	`布尔值 (BOOLEAN)`

注意事项
如果 `input` 为 `null`，则返回 `null`。

要检查属性是否不为 null，请使用 IS NOT NULL 谓词。

示例 4. exists()

查询

MATCH (p:Person)
RETURN p.name AS name,
       exists((p)-[:ACTED_IN]->()) AS has_acted_in_rel

此查询返回每个 Person 节点的 name 属性，以及一个布尔值（true 或 false），指示这些节点在图中是否具有 ACTED_IN 关系。

结果
名称 (name)	has_acted_in_rel
`"Carrie Anne Moss"`	`true`
`"Keanu Reeves"`	`true`
`"Liam Neeson"`	`false`
`"Guy Pearce"`	`false`
`"Kathryn Bigelow"`	`false`
`"Jessica Chastain"`	`false`
行数: 6

有关比 exists() 函数更通用的 EXISTS 子查询的信息，请参阅 EXISTS 子查询。

isEmpty()

详细信息
语法	`isEmpty(input)`
描述	检查 `STRING`、`MAP` 或 `LIST<ANY>` 是否为空。
参数	名称	类型	描述
	`input`	`STRING \| MAP \| LIST<ANY>`	要检查是否为空的值。
返回	`布尔值 (BOOLEAN)`

示例 5. isEmpty(list)

查询

MATCH (p:Person)
WHERE NOT isEmpty(p.nationality)
RETURN p.name, p.nationality

此查询返回图中设置了 nationality 属性值的每个 Person 节点（即除 Jessica Chastain 之外的所有 Person 节点）

结果
p.name	p.nationality
`"Keanu Reeves"`	`"Canadian"`
`"Carrie Anne Moss"`	`"American"`
`"Liam Neeson"`	`"Northern Irish"`
`"Guy Pearce"`	`"Australian"`
`"Kathryn Bigelow"`	`"American"`
行：5

示例 6. isEmpty(map)

查询

MATCH (n)
WHERE isEmpty(properties(n))
RETURN n

因为示例图中不包含空节点，所以没有返回任何内容

结果

(no changes, no records)

示例 7. isEmpty(string)

查询

MATCH (p:Person)
WHERE isEmpty(p.address)
RETURN p.name AS name

返回每个具有空 STRING address 属性的节点的 name 属性

结果
名称 (name)
`"Jessica Chastain"`
行：1

isEmpty() 函数与大多数其他 Cypher 函数一样，如果传入 null，则返回 null。这意味着谓词 isEmpty(n.address) 将过滤掉所有未设置 address 属性的节点。因此，isEmpty() 不适合测试 null 值。应为此目的使用 IS NULL 或 IS NOT NULL。

none()

详细信息
语法	`none(variable IN list WHERE predicate)`
描述	如果谓词对给定 `LIST<ANY>` 中的任何元素都不成立，则返回 true。
参数	名称	类型	描述
	`variable`	`ANY`	可在 `WHERE` 子句中使用的变量。
	`list`	`LIST<ANY>`	此列表中的所有元素都必须满足谓词，函数才会返回 `true`。
	`predicate`	`ANY`	针对给定列表中所有项进行测试的谓词。
返回	`布尔值 (BOOLEAN)`

注意事项
`none()` 与大多数 Cypher 函数不同，因为它会遍历列表并对每个元素求值表达式，而不是从单个求值中返回结果。
如果 `list` 为 `null`，或者 `predicate` 对至少一个元素求值为 `null` 且对任何其他元素均不求值为 `true`，则返回 `null`。
如果 `list` 为空，`none()` 返回 `true`，因为没有元素可以违反 `predicate`。

示例 8. none()

查找没有节点超过给定属性值的路径

MATCH p = (n:Person {name: 'Keanu Reeves'})-[]-{2}()
WHERE none(x IN nodes(p) WHERE x.age > 60)
RETURN [x IN nodes(p) | x.name] AS connectedActors

返回路径中的所有节点，其 age 属性均不大于 60

结果
connectedActors
`["基努·里维斯 (Keanu Reeves)", "凯瑞-安·莫斯 (Carrie Anne Moss)", "盖·皮尔斯 (Guy Pearce)"]`
行：1

对空 LIST 使用 none()

WITH [] as emptyList
RETURN none(i IN emptyList WHERE true) as noneTrue, none(i IN emptyList WHERE false) as noneFalse

结果
noneTrue	noneFalse
`TRUE`	`TRUE`
行：1

single()

详细信息
语法	`single(variable IN list WHERE predicate)`
描述	如果谓词对给定 `LIST<ANY>` 中的恰好一个元素成立，则返回 true。
参数	名称	类型	描述
	`variable`	`ANY`	可在 `WHERE` 子句中使用的变量。
	`list`	`LIST<ANY>`	此列表中的所有元素都必须满足谓词，函数才会返回 `true`。
	`predicate`	`ANY`	针对给定列表中所有项进行测试的谓词。
返回	`布尔值 (BOOLEAN)`

注意事项
`single()` 与大多数 Cypher 函数不同，因为它会遍历列表并对每个元素求值表达式，而不是从单个求值中返回结果。
如果 `list` 为 `null`，或者 `predicate` 对至少一个元素求值为 `null` 且对任何其他元素均不求值为 `true`，则返回 `null`。
如果 `list` 为空，`single()` 返回 `false`，因为没有恰好一个元素满足 `predicate`。

示例 9. single()

查找恰好有一个节点满足给定属性值的路径

MATCH p = (n:Person {name: 'Keanu Reeves'})-[:KNOWS]-+(b)
WHERE single(x IN [b] WHERE x.nationality = 'Northern Irish')
RETURN [person IN nodes(p) | person.name + " (" + person.nationality + ")"] AS northernIrishPaths
ORDER BY length(p)

结果
northernIrishPaths
`["Keanu Reeves (Canadian)", "Liam Neeson (Northern Irish)"]`
`["Keanu Reeves (Canadian)", "Carrie Anne Moss (American)", "Guy Pearce (Australian)", "Liam Neeson (Northern Irish)"]`
行：2

对空 LIST 使用 single()

WITH [] as emptyList
RETURN single(i IN emptyList WHERE true) as singleTrue, single(i IN emptyList WHERE false) as singleFalse

结果
singleTrue	singleFalse
`false`	`false`
行：1