Cypher 速查表

读取查询

读取查询结构

[USE]
[MATCH [WHERE]]
[OPTIONAL MATCH [WHERE]]
[WITH [ORDER BY] [SKIP] [LIMIT] [WHERE]]
RETURN [ORDER BY] [SKIP] [LIMIT]

模式搜索操作的基础。

  • USE 子句。

  • MATCH 子句。

  • OPTIONAL MATCH 子句。

  • WITH 子句。

  • RETURN 子句。

  • Cypher 关键字不区分大小写。

  • Cypher 对变量区分大小写。

MATCH

MATCH (n)
RETURN n AS node

匹配所有节点并返回所有节点。

MATCH (n:Person)-[:OWNS]->(:Car)
RETURN n.name AS carOwners

匹配所有具有 OWNS 关系并连接到 Car 节点的 Person 节点，并返回 carOwners 的 name。

MATCH p=(:Person)-[:OWNS]->(:Car)
RETURN p AS path

将路径模式绑定到路径变量，并返回路径模式。

OPTIONAL MATCH

OPTIONAL MATCH (n:Person)-[r]->(m:Person {name: 'Alice'})
RETURN n, r, m

OPTIONAL MATCH 与 MATCH 一样，将模式与图形数据库进行匹配。不同之处在于，如果找不到匹配项，OPTIONAL MATCH 将对模式中缺少的部分使用 null。

MATCH (n:Person {name: 'Neo'})
OPTIONAL MATCH (n)-[r]->(m {name: 'Alice'})
RETURN n, r, m

MATCH 应该用于查找模式中必须存在的实体。OPTIONAL MATCH 应该用于查找模式中可能不存在的实体。

WHERE

MATCH (n:Label)-->(m:Label)
WHERE n.property <> $value
RETURN n, m

WHERE 可以出现在 MATCH 或 OPTIONAL MATCH 子句中。它还可以过滤 WITH 子句的结果。

MATCH (n)
WHERE n:A|B
RETURN n.name AS name

标签表达式可用作 WHERE 子句中的谓词。

MATCH (n:Label)-[r]->(m:Label)
WHERE r:R1|R2
RETURN r.name AS name

关系类型表达式可用作 WHERE 子句中的谓词。

WITH 30 AS minAge
MATCH (a:Person WHERE a.name = 'Andy')-[:KNOWS]->(b:Person WHERE b.age > minAge)
RETURN b.name

WHERE 可以出现在 MATCH 子句中。

MATCH (a:Person {name: 'Andy'})
RETURN [(a)-->(b WHERE b:Person) | b.name] AS friends

WHERE 可以出现在模式推导语句中。

WITH 2000 AS minYear
MATCH (a:Person)-[r:KNOWS WHERE r.since < minYear]->(b:Person)
RETURN r.since

关系类型表达式可用作 WHERE 子句中的谓词。

WITH 2000 AS minYear
MATCH (a:Person {name: 'Andy'})
RETURN [(a)-[r:KNOWS WHERE r.since < minYear]->(b:Person) | r.since] AS years

关系模式谓词可以在模式推导中使用。

RETURN

MATCH (n:Label)-[r]->(m:Label)
RETURN *

返回所有变量的值。

MATCH (n:Label)-[r]->(m:Label)
RETURN n AS node, r AS rel

使用别名作为结果列名。

MATCH (n:Person)-[r:KNOWS]-(m:Person)
RETURN DISTINCT n AS node

返回唯一行。

MATCH (n:Label)-[r]->(m:Label)
RETURN n AS node, r AS rel
ORDER BY n.name

对结果进行排序。默认顺序为 ASCENDING。

MATCH (n:Label)-[r]->(m:Label)
RETURN n AS node, r AS rel
ORDER BY n.name DESC

以 DESCENDING 顺序对结果进行排序。

MATCH (n:Label)-[r]->(m:Label)
RETURN n AS node, r AS rel
SKIP 10

跳过结果集的前 10 行。

MATCH (n:Label)-[r]->(m:Label)
RETURN n AS node, r AS rel
LIMIT 10

将结果集的行数限制为最多 10 行。

MATCH (n:Label)-[r]->(m:Label)
RETURN count(*) AS nbr

匹配行的数量。有关更多信息，请参阅 聚合函数。

MATCH (n)
RETURN n:A&B

标签表达式可以在 WITH 或 RETURN 语句中使用。

MATCH (n:Label)-[r]->(m:Label)
RETURN r:R1|R2 AS result

关系类型表达式可用作 WITH 或 RETURN 语句中的谓词。

WITH

MATCH (user)-[:FRIEND]-(friend)
WHERE user.name = $name
WITH user, count(friend) AS friends
WHERE friends > 10
RETURN user

WITH 语法类似于 RETURN。它明确地分隔查询部分，允许用户声明要传递到查询下一部分的变量。

MATCH (user)-[:FRIEND]-(friend)
WITH user, count(friend) AS friends
ORDER BY friends DESC
SKIP 1
LIMIT 3
WHERE friends > 10
RETURN user

WITH 子句可以使用

  • ORDER BY

  • SKIP

  • LIMIT

  • WHERE

UNION

MATCH (a:Person)-[:KNOWS]->(b:Person)
RETURN b.name AS name
UNION
MATCH (a:Person)-[:LOVES]->(b:Person)
RETURN b.name AS name

返回所有查询结果的唯一联合。结果列类型和名称必须匹配。

MATCH (a:Person)-[:KNOWS]->(b:Person)
RETURN b.name AS name
UNION ALL
MATCH (a:Person)-[:LOVES]->(b:Person)
RETURN b.name AS name

返回所有查询结果的联合，包括重复行。

写入查询

仅写入查询结构

[USE]
[CREATE]
[MERGE [ON CREATE ...] [ON MATCH ...]]
[WITH [ORDER BY] [SKIP] [LIMIT] [WHERE]]
[SET]
[DELETE]
[REMOVE]
[RETURN [ORDER BY] [SKIP] [LIMIT]]

写入操作的基础。

读写查询结构

[USE]
[MATCH [WHERE]]
[OPTIONAL MATCH [WHERE]]
[WITH [ORDER BY] [SKIP] [LIMIT] [WHERE]]
[CREATE]
[MERGE [ON CREATE ...] [ON MATCH ...]]
[WITH [ORDER BY] [SKIP] [LIMIT] [WHERE]]
[SET]
[DELETE]
[REMOVE]
[RETURN [ORDER BY] [SKIP] [LIMIT]]

模式搜索和写入操作的基础。

CREATE

CREATE (n:Label {name: $value})

创建具有给定标签和属性的节点。

CREATE (n:Label $map)

创建具有给定标签和属性的节点。

CREATE (n:Label)-[r:TYPE]->(m:Label)

创建具有给定关系类型和方向的关系；将其绑定到变量 r。

CREATE (n:Label)-[:TYPE {name: $value}]->(m:Label)

创建具有给定类型、方向和属性的关系。

SET

SET e.property1 = $value1

更新或创建属性。

SET
  e.property1 = $value1,
  e.property2 = $value2

更新或创建多个属性。

MATCH (n)
SET n[$key] = value

动态设置或更新节点属性。

MATCH (n)
SET n:$($label)

动态设置节点标签。

SET e = $map

设置所有属性。这将删除所有现有属性。

SET e = {}

使用空映射 ({}) 删除所有现有属性。

SET e += $map

添加和更新属性，同时保留现有属性。

MATCH (n:Label)
WHERE n.id = 123
SET n:Person

向节点添加标签。此示例向节点添加 Person 标签。

MERGE

MERGE (n:Label {name: $value})
ON CREATE SET n.created = timestamp()
ON MATCH SET
  n.counter = coalesce(n.counter, 0) + 1,
  n.accessTime = timestamp()

匹配模式或在它不存在时创建它。使用 ON CREATE 和 ON MATCH 进行条件更新。

MATCH
  (a:Person {name: $value1}),
  (b:Person {name: $value2})
MERGE (a)-[r:LOVES]->(b)

MERGE 查找或创建节点之间的关系。

MATCH (a:Person {name: $value1})

MERGE 查找或创建附加到节点的路径。

DELETE

MATCH (n:Label)-[r]->(m:Label)
WHERE r.id = 123
DELETE r

删除关系。

MATCH ()-[r]->()
DELETE r

删除所有关系。

MATCH (n:Label)
WHERE n.id = 123
DETACH DELETE n

删除节点及其连接的所有关系。

MATCH (n:Label)-[r]-()
WHERE r.id = 123 AND n.id = 'abc'
DELETE n, r

删除节点和关系。如果给定节点附加到多个关系，则会抛出错误。

MATCH (n1:Label)-[r {id: 123}]->(n2:Label)
CALL (n1) {
  MATCH (n1)-[r1]-()
  RETURN count(r1) AS rels1
}
CALL (n2) {
  MATCH (n2)-[r2]-()
  RETURN count(r2) AS rels2
}
DELETE r
RETURN
  n1.name AS node1, rels1 - 1 AS relationships1,
  n2.name AS node2, rels2 - 1 AS relationships2

删除关系并返回删除后每个节点的关系数量。此示例使用 变量作用域子句（在 Neo4j 5.23 中引入）将变量导入 CALL 子查询。如果您使用的是旧版本的 Neo4j，请改用 导入 WITH 子句。

MATCH (n)
DETACH DELETE n

删除数据库中的所有节点和关系。

REMOVE

MATCH (n:Label)
WHERE n.id = 123
REMOVE n:Label

从节点中删除标签。

MATCH (n {name: 'Peter'})
REMOVE n:$($label)
RETURN n.name

动态删除节点标签。

MATCH (n:Label)
WHERE n.id = 123
REMOVE n.alias

从节点中删除属性。

MATCH (n)
REMOVE n[$key]

动态删除节点的属性。

MATCH (n:Label)
WHERE n.id = 123
SET n = {} # REMOVE ALL properties

REMOVE 不能用于从节点或关系中删除所有现有属性。可以通过使用 SET 子句，以及属性替换运算符 (=) 和空映射 ({}) 作为右操作数来删除节点或关系的所有现有属性。

模式

节点模式

(n)

将匹配的节点绑定到变量 n。

(n:Person)

匹配具有 Person 标签的节点。

(n:Person&Employee)

同时具有 Person 标签和 Employee 标签的节点。

(n:Person|Company)

具有 Person 标签或 Company 标签（或两者）的节点。

(n:!Person)

没有 Person 标签的节点。

(n:%)

至少具有一个标签的节点。

(n:(!Person&!Employee)|Company)

既没有 Person 标签也没有 Employee 标签，或者具有 Company 标签的节点。

(n:Person {name: 'Alice'})

匹配属性 name 等于 'Alice' 的节点。

(n:Person WHERE n.name STARTS WITH 'Al')

带有 WHERE 谓词的节点模式。

关系模式

(n:Person)--(m:Person)

没有指定方向的关系。

(n:Person)-->(m:Person)

具有指定方向的关系。

(n:Person)-[r]->(m:Person)

声明关系变量 r 的关系。

(n:Person)-[r:KNOWS]->(m:Person)

类型为 KNOWS 的关系。

(n:Person)-[r:KNOWS|LIKES]->(m:Person)

类型为 KNOWS 或 LIKES 的关系。

(n:Person)-[r:!FRIEND_OF]->(m:Person)

类型不为 FRIEND_OF 的关系。

(n:Person)-[r:(!FRIEND_OF&!LIKES)|KNOWS]->(m:Person)

类型既不为 FRIEND_OF 也不为 LIKES，或者类型为 KNOWS 的关系。

(n:Person)-[r:KNOWS {since: 1999}]->(m:Person)

属性 since 等于 1999 的关系

(n:Person)-[r:KNOWS WHERE r.metIn STARTS WITH 'Sto']->(m:Person)

属性 metIn 以 'Sto' 开头的关系。

路径模式

(n:Person)

路径模式必须至少具有一个节点模式。

(n:Person)-[r:KNOWS]->(m:Person)

路径模式必须以节点模式开头和结尾。

(n:Person {name: 'Alice'})-[r:KNOWS]->(m:Person)<-[r2:OWNS]-(c:Car {type: 'Volvo'})

路径模式必须在节点和关系之间交替。

等值连接

(n:Person {name: 'Alice'})-[:KNOWS]->(:Person)<-[:KNOWS]-(:Person)-[:KNOWS]-(n)

等值连接是对路径的操作，它要求路径的一个或多个节点或关系相同。节点或关系之间的相等性通过多次声明节点变量或关系变量来指定。节点上的等值连接允许在路径模式中指定循环。由于 关系唯一性，关系上的等值连接不会产生任何解决方案。

限定路径模式

((m:Person)-[:KNOWS]->(n:Person) WHERE m.born < n.born){1,5}

Person 知道另一个比他们年轻的 Person，其路径跳数在 1 到 5 之间。

(n:Person {name: "Alice"})-[:KNOWS]-{1,3}(m:Person)

从名为 Alice 的 Person 到另一个 Person，类型为 KNOWS 的关系，其路径跳数在 1 到 3 之间。

(n:Person {name: "Christina Ricci"}) (()-[:ACTED_IN]->(:Movie)<-[:ACTED_IN]-(:Person)){1,3} (m:Person)

连接Christina Ricci到Person的路径，遍历每个由两个Person节点组成的1到3个节点对，这两个节点与同一个Movie具有ACTED_IN关系。

(n:Person)-[:KNOWS]-{,4}(m:Person)-[:ACTED_IN]->(:Movie)<-[:ACTED_IN]-(:Person {name: "Christina Ricci"})

从与Christina Ricci出演同一Movie的Person节点出发，在最多4跳的KNOWS关系内查找Person节点的路径。

图模式

(n:Person {name: 'ALICE'})-[r:KNOWS]->(m:Person {name: 'Bob'})<--(o), (m)<-[:FRIEND_OF]-(p)

多个路径模式可以组合成逗号分隔的列表，形成一个图模式。在图模式中，每个路径模式分别匹配，并且当节点变量在不同的路径模式中重复出现时，解决方案通过等值连接进行缩减。

最短路径

MATCH p = SHORTEST 1 (wos:Station)-[:LINK]-+(bmv:Station)
WHERE wos.name = "Worcester Shrub Hill" AND bmv.name = "Bromsgrove"
RETURN length(p) AS result

SHORTEST k查找节点之间最短的路径（按跳数计算），其中k是要匹配的路径数量。

MATCH p = ALL SHORTEST (wos:Station)-[:LINK]-+(bmv:Station)
WHERE wos.name = "Worcester Shrub Hill" AND bmv.name = "Bromsgrove"
RETURN [n in nodes(p) | n.name] AS stops

查找两个节点之间所有最短路径。

MATCH p = SHORTEST 2 GROUPS (wos:Station)-[:LINK]-+(bmv:Station)
WHERE wos.name = "Worcester Shrub Hill" AND bmv.name = "Bromsgrove"
RETURN [n in nodes(p) | n.name] AS stops, length(p) AS pathLength

SHORTEST k GROUPS返回所有与第一、第二等最短长度相同的路径，直到第k个最短长度。此示例查找两个节点之间具有第一和第二最短长度的所有路径。

MATCH p = ANY (:Station {name: 'Pershore'})-[l:LINK WHERE l.distance < 10]-+(b:Station {name: 'Bromsgrove'})
RETURN [r IN relationships(p) | r.distance] AS distances

ANY关键字可用于测试从给定节点到达其他节点的可达性。它返回与SHORTEST 1相同的结果，但使用ANY关键字可以使查询的意图更加清晰。

可变长度关系

(n:Label)-[*0..]->(m:Label)

两个节点之间0跳或更多跳的可变长度路径。

(n:Label)-[*3]->(m:Label)

两个节点之间正好3跳的可变长度路径。

(n:Label)-[*..3]->(m:Label)

两个节点之间1到3跳的可变长度路径。

(n:Label)-[*1..5]->(m:Label)

两个节点之间1到5跳的可变长度路径。

(n:Label)-[*]->(m:Label)

一个或多个关系的可变长度路径（有关更多信息，请参见关于性能的部分）。

子句

CALL 过程

CALL db.labels() YIELD label

独立调用过程db.labels以列出数据库中使用的所有标签。请注意，必需的过程参数在过程名称后的括号中明确给出。

MATCH (n)
OPTIONAL CALL apoc.neighbors.tohop(n, "KNOWS>", 1)
YIELD node
RETURN n.name AS name, collect(node.name) AS connections

可选地CALL一个过程。类似于OPTIONAL MATCH，OPTIONAL CALL生成的任何空行都将返回null，并且不会影响过程评估的其余部分。

CALL db.labels() YIELD *

独立调用可以使用YIELD *返回所有列。

CALL java.stored.procedureWithArgs

独立调用可以省略YIELD，也可以通过语句参数隐式提供参数，例如，需要一个参数输入的独立调用可以通过传递参数映射{input: 'foo'}来运行。

CALL db.labels() YIELD label
RETURN count(label) AS db_labels

在更大的查询中调用内置过程db.labels以计算数据库中使用的所有标签。在更大的查询中进行调用始终需要传递参数并使用YIELD显式命名结果。

FOREACH

WITH ['Alice', 'Neo'] AS names
FOREACH ( value IN names | CREATE (:Person {name: value}) )

对列表中的每个元素运行一个修改操作。

FOREACH ( r IN relationships(path) | SET r.marked = true )

对路径中的每个关系运行一个修改操作。

LIMIT

MATCH (n)
RETURN n.name
ORDER BY n.name
LIMIT 3

LIMIT限制返回行的数量。它可以与ORDER BY和SKIP结合使用。

MATCH (n)
LIMIT 2
RETURN collect(n.name) AS names

LIMIT可以用作独立子句。

LOAD CSV

LOAD CSV FROM
'https://neo4j.ac.cn/docs/cypher-cheat-sheet/5/csv/artists.csv'
AS line
CREATE (:Artist {name: line[1], year: toInteger(line[2])})

从CSV文件加载数据并创建节点。

LOAD CSV WITH HEADERS FROM
'https://neo4j.ac.cn/docs/cypher-cheat-sheet/5/csv/artists-with-headers.csv'
AS line
CREATE (:Artist {name: line.Name, year: toInteger(line.Year)})

加载具有标题的CSV数据。

LOAD CSV WITH HEADERS FROM
'https://neo4j.ac.cn/docs/cypher-cheat-sheet/5/csv/artists-with-headers.csv'
AS line
CALL (line) {
  CREATE (:Artist {name: line.Name, year: toInteger(line.Year)})
} IN TRANSACTIONS OF 500 ROWS

子查询可以在单独的内部事务中执行，生成中间提交。此示例使用变量范围子句（在Neo4j 5.23中引入）将变量导入CALL子查询。如果您使用的是旧版本的Neo4j，请改用导入WITH子句。

要指示Neo4j Browser将查询作为隐式（自动提交）事务提交，请在查询前加上:auto。

LOAD CSV FROM
'https://neo4j.ac.cn/docs/cypher-cheat-sheet/5/csv/artists-fieldterminator.csv'
AS line FIELDTERMINATOR ';'
CREATE (:Artist {name: line[1], year: toInteger(line[2])})

使用不同的字段分隔符，而不是默认的逗号（周围没有空格）。

file()

file()函数返回一个字符串（LOAD CSV正在处理的文件的绝对路径）。如果在LOAD CSV上下文之外调用，则返回null。

linenumber()

linenumber函数返回一个整数（LOAD CSV当前正在处理的行号）。如果在LOAD CSV上下文之外调用，则返回null。

ORDER BY

MATCH (n)
ORDER BY n.name DESC
SKIP 1
LIMIT 1
RETURN n.name AS name

ORDER BY指定子句输出的排序方式。它可以用作RETURN或WITH后面的子句，或者与ORDER BY和SKIP结合使用。

除非使用ORDER BY，否则Neo4j不保证查询结果的行顺序。

MATCH (n)
ORDER BY n.name
RETURN collect(n.name) AS names

ORDER BY可以用作独立子句。

SHOW FUNCTIONS

SHOW FUNCTIONS

列出所有可用的函数，仅返回默认输出（name、category和description）。

SHOW BUILT IN FUNCTIONS YIELD *

列出内置函数，还可以根据ALL或USER-DEFINED进行过滤。

SHOW FUNCTIONS EXECUTABLE BY CURRENT USER YIELD *

过滤当前用户可用的函数。

SHOW FUNCTIONS EXECUTABLE BY user_name

过滤指定用户可用的函数。

SHOW PROCEDURES

SHOW PROCEDURES

列出所有可用的过程，仅返回默认输出（name、description、mode和worksOnSystem）。

SHOW PROCEDURES YIELD *

列出所有可用的过程。

SHOW PROCEDURES EXECUTABLE YIELD name

列出当前用户可以执行的所有过程，并且仅返回过程的名称。

SHOW SETTINGS

SHOW SETTINGS

列出配置设置（在实例中），仅返回默认输出（name、value、isDynamic、defaultValue和description）。

SHOW SETTINGS YIELD *

列出配置设置（在实例中）。

SHOW SETTINGS 'server.bolt.advertised_address', 'server.bolt.listen_address' YIELD *

列出名为server.bolt.advertised_address和server.bolt.listen_address的配置设置（在实例中）。只要设置名称在运行时计算为字符串或字符串列表，它们就可以是任何表达式。

SHOW TRANSACTIONS

SHOW TRANSACTIONS

列出正在运行的事务（在实例中），仅返回默认输出（database、transactionId、currentQueryId、connectionId、clientAddress、username、currentQuery、startTime、status和elapsedTime）。

SHOW TRANSACTIONS YIELD *

列出正在运行的事务（在实例中）。

SHOW TRANSACTIONS 'transaction_id' YIELD *

列出具有特定transaction_id的正在运行的事务（在实例中）。只要事务ID在运行时计算为字符串或字符串列表，它们就可以是任何表达式。

SKIP

MATCH (n)
ORDER BY n.name
SKIP 2
LIMIT 2
RETURN collect(n.name) AS names

SKIP定义从哪一行开始包含输出中的行。它可以与LIMIT和ORDER BY结合使用。

MATCH (n)
SKIP 2
RETURN collect(n.name) AS names

SKIP可以用作独立子句。

MATCH (n)
RETURN n.name
ORDER BY n.name
OFFSET 3

OFFSET可以用作SKIP的同义词。

TERMINATE TRANSACTIONS

TERMINATE TRANSACTIONS 'transaction_id'

终止特定事务，返回输出：transactionId、username、message。

TERMINATE TRANSACTIONS $value
  YIELD transactionId, message
  RETURN transactionId, message

终端事务允许使用YIELD子句。只要事务ID在运行时计算为字符串或字符串列表，它们就可以是任何表达式。

 SHOW TRANSACTIONS
  YIELD transactionId AS txId, username
  WHERE username = 'user_name'
TERMINATE TRANSACTIONS txId
  YIELD message
  WHERE NOT message = 'Transaction terminated.'
  RETURN txId

列出指定用户的所有事务并终止它们。返回未能成功终止的事务的事务ID。

UNWIND

UNWIND [1, 2, 3] AS ix
RETURN ix + 1 AS item

UNWIND子句将列表扩展为一系列行。

返回三行。

WITH [[1, 2], [3, 4], 5] AS nested
UNWIND nested AS ix
UNWIND ix AS iy
RETURN iy AS number

多个UNWIND子句可以链接起来展开嵌套列表元素。

返回五行。

UNWIND $list_of_maps AS properties
CREATE (n:Label)
SET n = properties

为列表中的每个映射创建一个节点并设置给定的属性。

UNWIND $names AS name
MATCH (n:Label {name: $value})
RETURN avg(n.age) AS average

使用UNWIND，任何列表都可以转换回单个行。此示例匹配名称列表中的所有名称。

USE

USE myDatabase

选择myDatabase以针对其执行查询或查询部分。

USE neo4j
MATCH (n:Person)-[:KNOWS]->(m:Person)
WHERE n.name = 'Alice'

针对neo4j数据库执行MATCH查询。

子查询

CALL

UNWIND [0, 1, 2] AS x
CALL () {
  RETURN 'hello' AS innerReturn
}
RETURN innerReturn

CALL子查询为每一行执行一次。在此示例中，CALL子查询执行三次。

MATCH (t:Team)
CALL (t) {
  MATCH (p:Player)-[:PLAYS_FOR]->(t)
  RETURN collect(p) as players
}
RETURN t AS team, players

使用变量范围子句CALL (<variable>)或导入WITH子句（已弃用）将变量导入CALL子查询。在此示例中，子查询将一次处理每个Team，并collect所有Player节点的列表。

MATCH (t:Team)
OPTIONAL CALL (t) {
  MATCH (p:Player)-[:PLAYS_FOR]->(t)
  RETURN collect(p) as players
}
RETURN t AS team, players

可选地CALL一个子查询。类似于OPTIONAL MATCH，OPTIONAL CALL生成的任何空行都将返回null，并且不会影响子查询评估的其余部分。

CALL () {
  MATCH (p:Player)
  RETURN p
  ORDER BY p.age ASC
  LIMIT 1
UNION
  MATCH (p:Player)
  RETURN p
  ORDER BY p.age DESC
  LIMIT 1
}
RETURN p.name AS name, p.age AS age

CALL子查询可用于进一步处理UNION查询的结果。此示例查找图中最年轻和最年长的Player。

CALL 子查询在事务中

LOAD CSV WITH HEADERS FROM 'https://data.neo4j.com/importing-cypher/books.csv' AS row
CALL (row) {
  MERGE (b:Book {id: row.id, title: row.title})
  MERGE (a:Author {name: row.author});
} IN TRANSACTIONS

CALL子查询可以在单独的内部事务中执行，生成中间提交。

LOAD CSV FROM 'https://data.neo4j.com/bands/artists.csv' AS line
CALL (line) {
  MERGE (:Person {name: line[1], age: toInteger(line[2])})
} IN TRANSACTIONS OF 2 ROWS

指定每个事务中处理的行数。

UNWIND [1, 0, 2, 4] AS i
CALL (i) {
  CREATE (n:Person {num: 100/i})
  RETURN n
} IN TRANSACTIONS OF 1 ROW ON ERROR CONTINUE
RETURN n.num

有三个不同的选项标志用于控制在任何内部事务中发生错误时的行为

  • ON ERROR CONTINUE - 忽略可恢复的错误并继续执行后续的内部事务。外部事务成功。

  • ON ERROR BREAK - 忽略可恢复的错误并停止执行后续的内部事务。外部事务成功。

  • ON ERROR FAIL - 确认可恢复的错误并停止执行后续的内部事务。外部事务失败。

LOAD CSV WITH HEADERS FROM 'https://data.neo4j.com/importing-cypher/persons.csv' AS row
CALL (row) {
  MERGE (p:Person {tmdbId: row.person_tmdbId})
  SET p.name = row.name, p.born = row.born
} IN 3 CONCURRENT TRANSACTIONS OF 10 ROWS
RETURN count(*) AS personNodes

CALL 子查询可以通过追加 IN [n] CONCURRENT TRANSACTIONS 来并行执行批处理，其中 n 是一个可选的并发值，用于设置可以并行执行的事务的最大数量。

COUNT、COLLECT 和 EXISTS

MATCH (person:Person)
WHERE COUNT { (person)-[:HAS_DOG]->(:Dog) } > 1
RETURN person.name AS name

COUNT 子查询计算子查询返回的行数。与 CALL 子查询不同，外部作用域引入的变量可以在 EXISTS、COLLECT 和 COUNT 子查询中使用。

MATCH (person:Person)
WHERE EXISTS {
  MATCH (person)-[:HAS_DOG]->(dog:Dog)
  WHERE person.name = dog.name
}
RETURN person.name AS name

EXISTS 子查询确定指定的模式在图中是否存在至少一次。可以在 COLLECT、COUNT 和 EXISTS 模式内部使用 WHERE 子句。

MATCH (person:Person) WHERE person.name = "Peter"
SET person.dogNames = COLLECT { MATCH (person)-[:HAS_DOG]->(d:Dog) RETURN d.name }
RETURN person.dogNames as dogNames

COLLECT 子查询创建一个包含子查询返回行的列表。COLLECT、COUNT 和 EXISTS 子查询可以在其他子句中使用。

常规

运算符

DISTINCT, ., []

常规

+, -, *, /, %, ^

数学运算

=, <>, <, >, <=, >=, IS NULL, IS NOT NULL

比较运算

AND, OR, XOR, NOT

布尔运算

+

字符串运算

+, IN, [x], [x .. y]

列表运算

=~

正则表达式运算

STARTS WITH, ENDS WITH, CONTAINS

字符串匹配

null

null 用于表示缺失/未定义的值。

null 不等于 null。不知道两个值并不意味着它们是相同的值。因此，表达式 null = null 返回 null 而不是 true。要检查表达式是否为 null，请使用 IS NULL。

如果任何参数为 null，则算术表达式、比较和函数调用（除了 coalesce）将返回 null。

尝试访问列表中缺失的元素或不存在的属性将产生 null。

在 OPTIONAL MATCH 子句中，将使用 null 来表示模式中缺失的部分。

标签

CREATE (n:Person {name: $value})

创建一个带有标签和属性的节点。

MERGE (n:Person {name: $value})

匹配或创建具有标签和属性的唯一节点。

MATCH (n:Person)
RETURN n AS person

匹配标记为 Person 的节点。

MATCH (n)
WHERE (n:Person)

检查节点上是否存在标签 Person。

MATCH (n:Person)
WHERE n.name = $value

匹配标记为 Person 且具有给定属性 name 的节点。

MATCH (n:Person {id: 123})
SET n:Spouse:Parent:Employee

向节点添加标签。

MATCH (n {id: 123})
RETURN labels(n) AS labels

labels 函数返回节点的标签。

MATCH (n {id: 123})
REMOVE n:Person

从节点中删除标签 :Person。

属性

MATCH (n {name: 'Alice'})
SET n += {
  a: 1,
  b: 'example',
  c: true,
  d: date('2022-05-04'),
  e: point({x: 2, y: 3}),
  f: [1, 2, 3],
  g: ['abc', 'example'],
  h: [true, false, false],
  i: [date('2022-05-04'), date()],
  j: [point({x: 2, y: 3}), point({x: 5, y: 5})],
  k: null
}

Neo4j 仅支持 Cypher 类型的一个子集作为单例或数组属性进行存储。属性可以是数字、字符串、布尔值、时间或空间的列表。

{a: 123, b: 'example'}

不允许将映射作为属性。

[{a: 1, b: 2}, {c: 3, d: 4}]

不允许将映射列表作为属性。

[[1,2,3], [4,5,6]]

包含集合的集合不能存储在属性中。

[1, 2, null]

包含 null 值的集合不能存储在属性中。

列表

RETURN ['a', 'b', 'c'] AS x

文字列表在方括号中声明。

WITH ['Alice', 'Neo', 'Cypher'] AS names
RETURN names

文字列表在方括号中声明。

RETURN size($my_list) AS len

列表可以作为 参数 传递。

RETURN $my_list[0] AS value

列表可以作为 参数 传递。

RETURN range($firstNum, $lastNum, $step) AS list

range() 创建一个数字列表（步长是可选的），其他返回列表的函数有：labels()、nodes() 和 relationships()。

MATCH p = (a)-[:KNOWS*]->()
RETURN relationships(p) AS r

可以使用命名路径和 relationships() 返回构成可变长度路径的关系列表。

RETURN list[$idx] AS value

列表元素可以使用方括号中的 idx 下标访问。无效索引返回 null。

RETURN list[$startIdx..$endIdx] AS slice

可以使用从 start_idx 到 end_idx 的区间检索切片，每个区间都可以省略或为负数。超出范围的元素将被忽略。

MATCH (a:Person)
RETURN [(a:Person)-->(b:Person) WHERE b.name = 'Alice' | b.age] AS list

模式推导可用于从匹配项直接到列表进行自定义投影。

MATCH (n:Person)
RETURN n {.name, .age}

可以轻松地从节点、关系和其他映射值构建映射投影。

映射

RETURN {name: 'Alice', age: 20, address: {city: 'London', residential: true}} AS alice

文字映射在花括号中声明，类似于属性映射。支持列表。

WITH {name: 'Alice', age: 20, colors: ['blue', 'green']} AS map
RETURN map.name, map.age, map.colors[0]

映射条目可以通过其键访问。无效键会导致错误。

WITH {person: {name: 'Anne', age: 25}} AS p
RETURN p.person.name AS name

访问嵌套映射的属性。

MERGE (p:Person {name: $map.name})
ON CREATE SET p = $map

映射可以作为参数传递，并用作映射或通过访问键来使用。

MATCH (matchedNode:Person)
RETURN matchedNode

节点和关系作为其数据的映射返回。

谓词

n.property <> $value

使用比较运算符。

toString(n.property) = $value

使用函数。

n.number >= 1 AND n.number <= 10

使用布尔运算符组合谓词。

n:Person

检查节点标签。

variable IS NOT NULL

检查某物是否不为 null，例如属性是否存在。

n.property IS NULL OR n.property = $value

属性不存在或谓词为 true。

n.property = $value

不存在的属性返回 null，它不等于任何东西。

n['property'] = $value

也可以使用动态计算的属性名称访问属性。

n.property STARTS WITH 'Neo'

以指定字符串开头的字符串匹配。

n.property ENDS WITH '4j'

以指定字符串结尾的字符串匹配。

n.property CONTAINS 'cypher'

包含指定字符串的字符串匹配。

n.property =~ '(?i)neo.*'

与指定的 正则表达式 匹配的字符串匹配。通过在正则表达式前面添加 (?i)，整个表达式将不区分大小写。

(n:Person)-[:KNOWS]->(m:Person)

确保模式至少有一个匹配项。

NOT (n:Person)-[:KNOWS]->(m:Person)

从结果中排除与 (n:Person)-[:KNOWS]→(m:Person) 匹配的结果。

n.property IN [$value1, $value2]

检查列表中是否存在元素。

列表表达式

[x IN list | x.prop]

原始列表中每个元素的表达式的值的列表。

[x IN list WHERE x.prop <> $value]

谓词为 true 的元素的过滤列表。

[x IN list WHERE x.prop <> $value | x.prop]

一个列表推导，它过滤一个列表并为该列表中的每个元素提取表达式的值。

表达式

CASE 表达式

CASE n.eyes
  WHEN 'blue' THEN 1
  WHEN 'brown' THEN 2
  ELSE 3
END

CASE 表达式可以在表达式位置使用，例如作为 WITH 或 RETURN 子句的一部分。

返回与匹配的 WHEN 值对应的 THEN 值。ELSE 值是可选的，如果缺少则替换为 null。

CASE
  WHEN n.eyes = 'blue' THEN 1
  WHEN n.age < 40 THEN 2
  ELSE 3
END

返回第一个计算结果为 true 的 WHEN 谓词的 THEN 值。谓词按顺序计算。

MATCH (n)-[r]->(m)
RETURN
CASE
  WHEN n:A&B THEN 1
  WHEN r:!R1&!R2 THEN 2
  ELSE -1
END AS result

关系类型表达式和标签表达式可以在 CASE 表达式中使用。

类型谓词表达式

n.property IS :: INTEGER

验证 property 是否为特定类型。

n.property IS :: INTEGER NOT NULL

验证 property 是否为特定类型，并且它不为 null。

n.property IS :: INTEGER!

在值类型后添加感叹号是 NOT NULL 的同义词。它还可以用于验证 property 是否为特定类型，并且它不为 null。

variable IS NOT :: STRING

验证 variable 是否不为特定类型。

函数

聚合函数

MATCH (p:Person)
RETURN avg(p.age)

avg 函数返回一组 INTEGER 或 FLOAT 值的平均值。

UNWIND [duration('P2DT3H'), duration('PT1H45S')] AS dur
RETURN avg(dur)

avg duration 函数返回一组 DURATION 值的平均值。

MATCH (p:Person)
RETURN collect(p.age)

collect 函数返回一个包含表达式返回的非 null 值的单个聚合列表。

MATCH (p:Person {name: 'Keanu Reeves'})-->(x)
RETURN labels(p), p.age, count(*)

count 函数返回值或行的数量。当使用 count(*) 时，该函数返回匹配行的数量。

MATCH (p:Person)
RETURN count(p.age)

count 函数也可以传递一个表达式。如果是这样，它将返回给定表达式返回的非 null 值的数量。

MATCH (p:Person)
RETURN max(p.age)

max 函数返回一组值中的最大值。

MATCH (p:Person)
RETURN min(p.age)

min 函数返回一组值中的最小值。

MATCH (p:Person)
RETURN percentileCont(p.age, 0.4)

percentileCont 函数返回给定值在一组数据中的百分位数，百分位数范围为 0.0 到 1.0。它使用线性插值方法，如果所需的百分位数位于两个值之间，则计算这两个值的加权平均值。

MATCH (p:Person)
RETURN percentileDisc(p.age, 0.5)

percentileDisc 函数返回给定值在一组数据中的百分位数，百分位数范围为 0.0 到 1.0。它使用舍入方法并计算最接近百分位数的值。

MATCH (p:Person)
WHERE p.name IN ['Keanu Reeves', 'Liam Neeson', 'Carrie Anne Moss']
RETURN stDev(p.age)

stDev 函数返回给定值在一组数据中的标准差。它使用标准的双通方法，分母为 N - 1，当对总体进行抽样以获得无偏估计时应使用。

MATCH (p:Person)
RETURN stDevP(p.age)

stDevP 函数返回给定值在一组数据中的标准差。它使用标准的双通方法，分母为 N，当计算整个总体的标准差时应使用。

MATCH (p:Person)
RETURN sum(p.age)

sum 函数返回一组数值的总和。

UNWIND [duration('P2DT3H'), duration('PT1H45S')] AS dur
RETURN sum(dur)

sum duration 函数返回一组持续时间的总和。

数据库函数

WITH "2:efc7577d-022a-107c-a736-dbcdfc189c03:0" AS eid
RETURN db.nameFromElementId(eid) AS name

db.nameFromElementId 函数返回元素 ID 所属的数据库的名称。只有当提供的元素 ID 属于 DBMS 中的标准数据库时，才能返回数据库的名称。

持续时间函数

UNWIND [
duration({days: 14, hours:16, minutes: 12}),
duration({months: 0.75}),
duration({weeks: 2.5}),
duration({minutes: 1.5, seconds: 1, milliseconds: 123, microseconds: 456, nanoseconds: 789}),
] AS aDuration
RETURN aDuration

duration 函数可以从其组件的 MAP 构造一个 DURATION。

RETURN duration('P1Y2M10DT12H45M30.25S') AS duration

从字符串创建 duration 函数返回通过解析时间量 STRING 表示形式获得的 DURATION 值。

UNWIND [
duration.between(date("1984-10-11"), date("1985-11-25")),
duration.between(date("1984-10-11"), datetime("1984-10-12T21:40:32.142+0100")),
duration.between(date("2015-06-24"), localtime("14:30")),
duration.between(localtime("14:30"), time("16:30+0100")),
duration.between(localdatetime("2015-07-21T21:40:32.142"), localdatetime("2016-07-21T21:45:22.142"))
] AS aDuration
RETURN aDuration

duration.between 函数返回等于两个给定时刻之间差值的 DURATION 值。

UNWIND [
duration.inDays(date("1984-10-11"), date("1985-11-25")),
duration.inDays(date("1984-10-11"), datetime("1984-10-12T21:40:32.142+0100")),
duration.inDays(date("2015-06-24"), localtime("14:30")),
duration.inDays(localdatetime("2015-07-21T21:40:32.142"), localdatetime("2016-07-21T21:45:22.142"))
] AS aDuration
RETURN aDuration

duration.inDays 函数返回等于两个给定时刻之间整日或整周差值的 DURATION 值。

UNWIND [
duration.inMonths(date("1984-10-11"), date("1985-11-25")),
duration.inMonths(date("1984-10-11"), datetime("1984-10-12T21:40:32.142+0100")),
duration.inMonths(date("2015-06-24"), localtime("14:30")),
duration.inMonths(localdatetime("2015-07-21T21:40:32.142"), localdatetime("2016-07-21T21:45:22.142"))
] AS aDuration
RETURN aDuration

duration.inMonths 函数返回等于两个给定时刻之间整月差值的 DURATION 值。

UNWIND [
duration.inSeconds(date("1984-10-11"), date("1984-10-12")),
duration.inSeconds(date("1984-10-11"), datetime("1984-10-12T01:00:32.142+0100")),
duration.inSeconds(date("2015-06-24"), localtime("14:30"))
] AS aDuration
RETURN aDuration

duration.inSeconds 函数返回等于两个给定时刻之间秒和纳秒差值的 DURATION 值。

图函数

RETURN graph.names() AS name

graph.names 函数返回一个包含当前复合数据库上所有图的名称的列表。它仅在 复合数据库 上支持。

RETURN graph.propertiesByNames() AS name

graph.propertiesByNames 函数返回一个包含给定图关联属性的映射。这些属性设置在将图作为复合数据库组成部分添加的 别名 上。它仅在 复合数据库 中受支持。

UNWIND graph.names() AS graphName
CALL {
  USE graph.byName(graphName)
  MATCH (n)
  RETURN n
}
RETURN n

graph.byName 函数通过名称解析组成图。它仅在 复合数据库 上的 USE 子句中受支持。

USE graph.byElementId("4:c0a65d96-4993-4b0c-b036-e7ebd9174905:0")
MATCH (n)
RETURN n

graph.byElementId 函数用于 USE 子句中，以解析给定元素 ID 所属的组成图。如果组成数据库不是 DBMS 中的标准数据库，则会抛出错误。

列表函数

MATCH (a) WHERE a.name = 'Alice'
RETURN keys(a)

keys 函数返回一个 LIST<STRING>，其中包含 NODE、RELATIONSHIP 或 MAP 所有属性名称的 STRING 表示形式。

MATCH (a) WHERE a.name = 'Alice'
RETURN labels(a)

labels 函数返回一个 LIST<STRING>，其中包含 NODE 所有标签的 STRING 表示形式。

MATCH p = (a)-->(b)-->(c)
WHERE a.name = 'Alice' AND c.name = 'Eskil'
RETURN nodes(p)

nodes 函数返回一个 LIST<NODE>，其中包含 PATH 中的所有 NODE 值。

RETURN range(0, 10), range(2, 18, 3), range(0, 5, -1)

range 函数返回一个 LIST<INTEGER>，其中包含起始值和结束值限定范围内的所有 INTEGER 值，其中任意两个连续值之间的差分步长是恒定的；即算术级数。

MATCH p = (a)-->(b)-->(c)
WHERE a.name = 'Alice' AND b.name = 'Bob' AND c.name = 'Daniel'
RETURN reduce(totalAge = 0, n IN nodes(p) | totalAge + n.age) AS reduction

reduce 函数返回将表达式应用于列表中每个连续元素以及迄今为止计算结果所产生的值。

MATCH p = (a)-->(b)-->(c)
WHERE a.name = 'Alice' AND c.name = 'Eskil'
RETURN relationships(p)

relationships 函数返回一个 LIST<RELATIONSHIP>，其中包含 PATH 中的所有 RELATIONSHIP 值。

WITH [4923,'abc',521, null, 487] AS ids
RETURN reverse(ids)

reverse 函数返回一个 LIST<ANY>，其中给定 LIST<ANY> 中所有元素的顺序已反转。

MATCH (a) WHERE a.name = 'Eskil'
RETURN a.array, tail(a.array)

tail 函数返回一个 LIST<ANY>，其中包含给定 LIST<ANY> 中除第一个元素之外的所有元素。

RETURN toBooleanList([null, null]) as nullsInList,
toBooleanList(['a string', true, 'false', null, ['A','B']]) as mixedList

toBooleanList 转换 LIST<ANY> 并返回 LIST<BOOLEAN>。如果任何值无法转换为 BOOLEAN，则它们在返回的 LIST<BOOLEAN> 中将为 null。

RETURN toFloatList(null) as noList,
toFloatList([null, null]) as nullsInList,
toFloatList(['a string', 2.5, '3.14159', null, ['A','B']]) as mixedList

toFloatList 转换值的 LIST<ANY> 并返回 LIST<FLOAT>。如果任何值无法转换为 FLOAT，则它们在返回的 LIST<FLOAT> 中将为 null。

RETURN toIntegerList(null) as noList,
toIntegerList([null, null]) as nullsInList,
toIntegerList(['a string', 2, '5', null, ['A','B']]) as mixedList

toIntegerList 转换值的 LIST<ANY> 并返回 LIST<INTEGER>。如果任何值无法转换为 INTEGER，则它们在返回的 LIST<INTEGER> 中将为 null。

RETURN toStringList(null) as noList,
toStringList([null, null]) as nullsInList,
toStringList(['already a string', 2, date({year:1955, month:11, day:5}), null, ['A','B']]) as mixedList

toStringList 转换值的 LIST<ANY> 并返回 LIST<STRING>。如果任何值无法转换为 STRING，则它们在返回的 LIST<STRING> 中将为 null。

数学函数 - 数值

MATCH (a), (e)
WHERE a.name = 'Alice' AND e.name = 'Eskil'
RETURN a.age, e.age, abs(a.age - e.age)

abs 函数返回给定数字的绝对值。

RETURN ceil(0.1)

ceil 函数返回大于或等于给定数字且等于 INTEGER 的最小 FLOAT。

RETURN floor(0.9)

floor 函数返回小于或等于给定数字且等于 INTEGER 的最大 FLOAT。

RETURN isNaN(0/0.0)

isNan 函数如果给定的数值为 NaN（非数字），则返回 true。

RETURN rand() AS random

rand 函数返回范围从 0（包含）到 1（不包含）的随机 FLOAT。返回的数字遵循近似均匀分布。

RETURN round(3.141592)

round 函数返回给定数字四舍五入到最接近的 INTEGER 的值，其中所有舍入都始终向正无穷大舍入。

RETURN round(3.141592, 3)

带精度的 round 函数返回给定数字四舍五入到给定精度的最接近值的数值，其中所有舍入都始终远离零（使用舍入模式 HALF_UP）。对于精度 0，例外情况是舍入始终向正无穷大舍入，以与不带精度的 round() 保持一致。

RETURN round(1.249, 1, 'UP') AS positive,
round(-1.251, 1, 'UP') AS negative,
round(1.25, 1, 'DOWN') AS positiveTie,
round(-1.35, 1, 'DOWN') AS negativeTie

带精度和舍入模式的 round 函数返回使用指定的精度和指定的舍入模式四舍五入的给定数字的值。

RETURN sign(-17), sign(0.1)

sign 函数返回给定数字的符号：如果数字为 0，则返回 0，对于任何负数返回 -1，对于任何正数返回 1。

数学函数 - 对数

RETURN e()

e 函数返回自然对数的底数 e。

RETURN exp(2)

exp 函数返回 en，其中 e 是自然对数的底数，n 是参数表达式的值。

RETURN log(27)

log 函数返回数字的自然对数。

RETURN log10(27)

log10 函数返回数字的常用对数（以 10 为底）。

RETURN sqrt(256)

sqrt 函数返回数字的平方根。

数学函数 - 三角函数

RETURN acos(0.5)

acos 函数返回 FLOAT 以弧度表示的反余弦。

RETURN asin(0.5)

asin 函数返回 FLOAT 以弧度表示的反正弦。

RETURN atan(0.5)

atan 函数返回 FLOAT 以弧度表示的反正切。

RETURN atan2(0.5, 0.6)

atan2 函数返回一组坐标以弧度表示的反正切 2。

RETURN cos(0.5)

cos 函数返回 FLOAT 的余弦。

RETURN cot(0.5)

cot 函数返回 FLOAT 的余切。

RETURN degrees(3.14159)

degrees 函数将弧度转换为度。

RETURN haversin(0.5)

haversin 函数转换数字的半正矢。

RETURN pi()

pi 函数返回数学常数 pi。

RETURN radians(180)

radians 函数将度转换为弧度。

RETURN sin(0.5)

sin 函数返回数字的正弦。

RETURN tan(0.5)

tan 函数返回数字的正切。

谓词函数

MATCH p = (a)-[*]->(b)
WHERE
  a.name = 'Keanu Reeves'
  AND b.name = 'Guy Pearce'
  AND all(x IN nodes(p) WHERE x.age < 60)
RETURN p

all 函数如果谓词对给定 LIST<ANY> 中的所有元素都成立，则返回 true。

MATCH (p:Person)
WHERE any(nationality IN p.nationality WHERE nationality = 'American')
RETURN p

any 函数如果谓词对给定 LIST<ANY> 中至少一个元素成立，则返回 true。

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

exists 函数如果图中存在给定模式的匹配项，则返回 true。

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

isEmpty 函数如果给定的 LIST<ANY> 或 MAP 不包含任何元素，或者如果给定的 STRING 不包含任何字符，则返回 true。

MATCH p = (n)-[*]->(b)
WHERE
  n.name = 'Keanu Reeves'
  AND none(x IN nodes(p) WHERE x.age > 60)
RETURN p

none 函数如果谓词对给定 LIST<ANY> 中的任何元素都不成立，则返回 true。

MATCH p = (n)-->(b)
WHERE
  n.name = 'Keanu Reeves'
  AND single(x IN nodes(p) WHERE x.nationality = 'Northern Irish')
RETURN p

single 函数如果谓词对给定 LIST<ANY> 中的恰好 一个 元素成立，则返回 true。

标量函数

RETURN char_length('Alice')

char_length 函数返回 STRING 中 Unicode 字符的数量。此函数是 size 函数的别名。

RETURN character_length('Alice')

character_length 函数返回 STRING 中 Unicode 字符的数量。此函数是 size 函数的别名。

MATCH (a)
WHERE a.name = 'Alice'
RETURN coalesce(a.hairColor, a.eyes)

coalesce 函数返回第一个给定的非空参数。

MATCH (a)
RETURN elementId(a)

函数 elementId 返回节点或关系标识符的 STRING 表示形式，在特定事务和DBMS中唯一。

MATCH (x:Developer)-[r]-()
RETURN endNode(r)

函数 endNode 返回 RELATIONSHIP 的结束 NODE。

MATCH (a)
WHERE a.name = 'Eskil'
RETURN a.liked_colors, head(a.liked_colors)

函数 head 返回列表的第一个元素。对于空列表返回 null。等价于列表索引 $list[0]。

MATCH (a)
RETURN id(a)

函数 id 返回一个 INTEGER（节点或关系的内部 ID）。不要依赖于业务领域的内部 ID；内部 ID 可能会在事务之间发生变化。id 函数将在下一个主要版本中移除。建议使用 elementId 代替。

MATCH (a)
WHERE a.name = 'Eskil'
RETURN a.liked_colors, last(a.liked_colors)

函数 last 返回列表的最后一个元素。对于空列表返回 null。等价于列表索引 $list[-1]。

MATCH p = (a)-->(b)-->(c)
WHERE a.name = 'Alice'
RETURN length(p)

函数 length 返回 PATH 的长度。

RETURN nullIf("abc", "def")

函数 nullIf 如果两个给定的参数等价，则返回 null，否则返回第一个参数的值。

CREATE (p:Person {name: 'Stefan', city: 'Berlin'})
RETURN properties(p)

函数 properties 返回一个包含节点或关系所有属性的 MAP。

RETURN randomUUID() AS uuid

函数 randomUUID 返回一个 STRING；一个随机生成的通用唯一标识符 (UUID)。

RETURN size(['Alice', 'Bob'])

函数 size 返回列表中元素的数量。

MATCH (x:Developer)-[r]-()
RETURN startNode(r)

函数 startNode 返回 RELATIONSHIP 的起始 NODE。

RETURN timestamp()

函数 timestamp 返回自 1970年1月1日午夜UTC 以来以毫秒为单位的时间和当前时间。

RETURN toBoolean('true'), toBoolean('not a boolean'), toBoolean(0)

函数 toBoolean 将 STRING、INTEGER 或 BOOLEAN 值转换为 BOOLEAN 值。

RETURN toBooleanOrNull('true'), toBooleanOrNull('not a boolean'), toBooleanOrNull(0), toBooleanOrNull(1.5)

函数 toBooleanOrNull 将 STRING、INTEGER 或 BOOLEAN 值转换为 BOOLEAN 值。对于任何其他输入值，将返回 null。

RETURN toFloat('11.5'), toFloat('not a number')

函数 toFloat 将 INTEGER、FLOAT 或 STRING 值转换为 FLOAT。

RETURN toFloatOrNull('11.5'), toFloatOrNull('not a number'), toFloatOrNull(true)

函数 toFloatOrNull 将 INTEGER、FLOAT 或 STRING 值转换为 FLOAT。对于任何其他输入值，将返回 null。

RETURN toInteger('42'), toInteger('not a number'), toInteger(true)

函数 toInteger 将 BOOLEAN、INTEGER、FLOAT 或 STRING 值转换为 INTEGER 值。

RETURN toIntegerOrNull('42'), toIntegerOrNull('not a number'), toIntegerOrNull(true), toIntegerOrNull(['A', 'B', 'C'])

函数 toIntegerOrNull 将 BOOLEAN、INTEGER、FLOAT 或 STRING 值转换为 INTEGER 值。对于任何其他输入值，将返回 null。

MATCH (n)-[r]->()
WHERE n.name = 'Alice'
RETURN type(r)

函数 type 返回 RELATIONSHIP 类型的 STRING 表示形式。

UNWIND ["abc", 1, 2.0, true, [date()]] AS value
RETURN valueType(value) AS result

函数 valueType 返回给定表达式计算结果的最精确值类型的 STRING 表示形式。

字符串函数

RETURN btrim('   hello    '), btrim('xxyyhelloxyxy', 'xy')

函数 btrim 返回原始 STRING，其中已删除开头和结尾的 trimCharacterString 字符。如果未指定 trimCharacterString，则将删除所有开头和结尾的空格。

RETURN left('hello', 3)

函数 left 返回一个 STRING，其中包含给定 STRING 最左侧指定数量的字符。

RETURN ltrim('   hello'), ltrim('xxyyhelloxyxy', 'xy')

函数 ltrim 返回原始 STRING，其中已删除开头 trimCharacterString 字符。如果未指定 trimCharacterString，则将删除所有开头空格。

RETURN replace("hello", "l", "w")

函数 replace 返回一个 STRING，其中给定 STRING 中所有指定的 STRING 出现都被另一个（指定的）替换 STRING 替换。

RETURN reverse('palindrome')

函数 reverse 返回一个 STRING，其中给定 STRING 中所有字符的顺序都已反转。

RETURN right('hello', 3)

函数 right 返回一个 STRING，其中包含给定 STRING 最右侧指定数量的字符。

RETURN rtrim('hello   '), rtrim('xxyyhelloxyxy', 'xy')

函数 rtrim 返回给定 STRING，其中已删除结尾 trimCharacterString 字符。如果未指定 trimCharacterString，则将删除所有结尾空格。

RETURN split('one,two', ',')

函数 split 返回一个 LIST<STRING>，该列表是通过在给定分隔符匹配周围拆分给定 STRING 而产生的。

RETURN substring('hello', 1, 3), substring('hello', 2)

函数 substring 返回给定 STRING 的子字符串，以基于零的索引开始和长度。

RETURN toLower('HELLO')

函数 toLower 返回给定 STRING 的小写形式。

RETURN
  toString(11.5),
  toString('already a string'),
  toString(true),
  toString(date({year: 1984, month: 10, day: 11})) AS dateString,
  toString(datetime({year: 1984, month: 10, day: 11, hour: 12, minute: 31, second: 14, millisecond: 341, timezone: 'Europe/Stockholm'})) AS datetimeString,
  toString(duration({minutes: 12, seconds: -60})) AS durationString

函数 toString 将 INTEGER、FLOAT、BOOLEAN、STRING、POINT、DURATION、DATE、ZONED TIME、LOCAL TIME、LOCAL DATETIME 或 ZONED DATETIME 值转换为 STRING。

RETURN
  toString(11.5),
  toString('already a string'),
  toString(true),
  toString(date({year: 1984, month: 10, day: 11})) AS dateString,
  toString(datetime({year: 1984, month: 10, day: 11, hour: 12, minute: 31, second: 14, millisecond: 341, timezone: 'Europe/Stockholm'})) AS datetimeString,
  toString(duration({minutes: 12, seconds: -60})) AS durationString

函数 toStringOrNull 将 INTEGER、FLOAT、BOOLEAN、STRING、POINT、DURATION、DATE、ZONED TIME、LOCAL TIME、LOCAL DATETIME 或 ZONED DATETIME 值转换为 STRING。对于任何其他输入值，将返回 null。

RETURN toUpper('hello')

函数 toUpper 返回给定 STRING 的大写形式。

RETURN trim('   hello   ')

函数 trim 返回给定 STRING，其中已删除开头和结尾的空格。

空间函数

RETURN point({x: 2.3, y: 4.5}) AS point

函数 point笛卡尔二维 返回对应于给定坐标值的笛卡尔 CRS 中的二维 POINT。

RETURN point({x: 2.3, y: 4.5, z: 2}) AS point

函数 point笛卡尔三维 返回对应于给定坐标值的笛卡尔 CRS 中的三维 POINT。

MATCH (p:Office)
RETURN point({longitude: p.longitude, latitude: p.latitude}) AS officePoint

函数 pointWGS 84 二维 返回对应于给定坐标值的WGS 84 CRS 中的二维 POINT。

RETURN point({longitude: 56.7, latitude: 12.78, height: 8}) AS point

函数 pointWGS 84 三维 返回对应于给定坐标值的WGS 84 CRS 中的三维 POINT。

MATCH (t:TrainStation)-[:TRAVEL_ROUTE]->(o:Office)
WITH
  point({longitude: t.longitude, latitude: t.latitude}) AS trainPoint,
  point({longitude: o.longitude, latitude: o.latitude}) AS officePoint
RETURN round(point.distance(trainPoint, officePoint)) AS travelDistance

函数 point.distance 返回表示同一坐标参考系统 (CRS) 中两点之间测地线距离的 FLOAT。

WITH
  point({longitude: 12.53, latitude: 55.66}) AS lowerLeft,
  point({longitude: 12.614, latitude: 55.70}) AS upperRight
MATCH (t:TrainStation)
WHERE point.withinBBox(point({longitude: t.longitude, latitude: t.latitude}), lowerLeft, upperRight)
RETURN count(t)

函数 point.withinBBox 采用以下参数：要检查的 POINT，边界框的左下角（西南）POINT 以及边界框的右上角（或东北）POINT。如果提供的点包含在边界框中（包括边界），则返回值为真，否则返回值为假。

时间函数

RETURN date() AS currentDate

函数 date 返回当前 DATE 值。如果未指定时区参数，则将使用本地时区。

RETURN date.transaction() AS currentDate

函数 date.transaction 使用 transaction 时钟返回当前 DATE 值。此值在同一事务中的每次调用中都将相同。但是，对于不同的事务，可能会产生不同的值。

RETURN date.statement() AS currentDate

函数 date.statement 使用语句时钟返回当前 DATE 值。此值在同一语句中的每次调用中都将相同。但是，对于同一事务中的不同语句，可能会产生不同的值。

RETURN date.realtime() AS currentDate

函数 date.realtime 使用 realtime 时钟返回当前 DATE 值。此值将是系统的实时时钟。

RETURN datetime() AS currentDateTime

函数 datetime 返回当前 ZONED DATETIME 值。如果未指定时区参数，则将使用默认时区。

RETURN datetime.transaction() AS currentDateTime

函数 datetime.transaction 使用 transaction 时钟返回当前 ZONED DATETIME 值。此值在同一事务中的每次调用中都将相同。但是，对于不同的事务，可能会产生不同的值。

RETURN datetime.statement() AS currentDateTime

函数 datetime.statement 使用 transaction 时钟返回当前 ZONED DATETIME 值。此值在同一事务中的每次调用中都将相同。但是，对于不同的事务，可能会产生不同的值。

RETURN datetime.realtime() AS currentDateTime

函数 datetime.realtime 使用 realtime 时钟返回当前 ZONED DATETIME 值。此值将是系统的实时时钟。

RETURN localdatetime() AS now

函数 localdatetime 返回当前 LOCAL DATETIME 值。如果未指定时区参数，则将使用本地时区。

RETURN localdatetime.transaction() AS now

函数 localdatetime.transaction 使用 transaction 时钟返回当前 LOCAL DATETIME 值。在同一事务中的每次调用中，此值都将相同。但是，对于不同的事务，可能会产生不同的值。

RETURN localdatetime.statement() AS now

函数 localdatetime.statement 使用 statement 时钟返回当前 LOCAL DATETIME 值。在同一语句中的每次调用中，此值都将相同。但是，在同一事务中的不同语句中，可能会产生不同的值。

RETURN localdatetime.realtime() AS now

函数 localdatetime.realtime 使用 realtime 时钟返回当前 LOCAL DATETIME 值。此值将是系统的实时时钟。

RETURN localtime() AS now

函数 localtime 返回当前 LOCAL TIME 值。如果未指定时区参数，则将使用本地时区。

RETURN localtime.transaction() AS now

函数 localtime.transaction 使用 transaction 时钟返回当前 LOCAL TIME 值。在同一事务中的每次调用中，此值都将相同。但是，对于不同的事务，可能会产生不同的值。

RETURN localtime.statement() AS now

函数 localtime.statement 使用 statement 时钟返回当前 LOCAL TIME 值。在同一语句中的每次调用中，此值都将相同。但是，在同一事务中的不同语句中，可能会产生不同的值。

RETURN localtime.realtime() AS now

函数 localtime.realtime 使用 realtime 时钟返回当前 LOCAL TIME 值。此值将是系统的实时时钟。

RETURN time() AS now

函数 time 返回当前 ZONED TIME 值。如果未指定时区参数，则将使用本地时区。

RETURN time.transaction() AS now

函数 time.transaction 使用 transaction 时钟返回当前 ZONED TIME 值。在同一事务中的每次调用中，此值都将相同。但是，对于不同的事务，可能会产生不同的值。

RETURN time.statement() AS now

函数 time.statement 使用 statement 时钟返回当前 ZONED TIME 值。在同一语句中的每次调用中，此值都将相同。但是，在同一事务中的不同语句中，可能会产生不同的值。

RETURN time.realtime() AS now

函数 time.realtime 使用 realtime 时钟返回当前 ZONED TIME 值。此值将是系统的实时时钟。

向量函数

MATCH (n:Label)
WITH n, vector.similarity.euclidean($query, n.vector) AS score
RETURN n, score

函数 vector.similarity.euclidean 返回一个 FLOAT，表示基于参数向量的欧几里得距离的相似度。

MATCH (n:Label)
WITH n, vector.similarity.cosine($query, n.vector) AS score
RETURN n, score

函数 vector.similarity.cosine 返回一个 FLOAT，表示基于参数向量的余弦的相似度。

模式

搜索性能索引

Cypher 包含四种搜索性能索引：范围（默认）、文本、点和标记查找。

CREATE INDEX index_name
FOR (p:Person) ON (p.name)

在具有标签 Person 和属性 name 的节点上创建名为 index_name 的范围索引。

如果未指定 index_name，则可以省略它，索引名称将由 DBMS 决定。最佳实践是在创建索引时始终指定一个有意义的名称。

创建语法为 CREATE [RANGE|TEXT|POINT|LOOKUP|FULLTEXT|VECTOR] INDEX …​。如果未明确说明，则默认为范围。

CREATE RANGE INDEX index_name
FOR ()-[k:KNOWS]-() ON (k.since)

在具有类型 KNOWS 和属性 since 的关系上创建名为 index_name 的范围索引。

CREATE INDEX $nameParam
FOR (p:Person) ON (p.name, p.age)

在具有标签 Person 和属性 name 和 age 的节点上创建名为参数 nameParam 指定的复合范围索引，如果索引已存在则抛出错误。

CREATE INDEX index_name IF NOT EXISTS
FOR (p:Person) ON (p.name, p.age)

在具有标签 Person 和属性 name 和 age 的节点上创建名为 index_name 的复合范围索引，如果它不存在则创建，如果已存在则不执行任何操作。

CREATE TEXT INDEX index_name
FOR (p:Person) ON (p.name)

在具有标签 Person 和属性 name 的节点上创建文本索引。文本索引仅解决涉及 STRING 属性值的谓词。

CREATE TEXT INDEX index_name
FOR ()-[r:KNOWS]-() ON (r.city)

在具有类型 KNOWS 和属性 city 的关系上创建文本索引。文本索引仅解决涉及 STRING 属性值的谓词。

CREATE POINT INDEX index_name
FOR (p:Person) ON (p.location)
OPTIONS {
  indexConfig: {
    `spatial.cartesian.min`: [-100.0, -100.0],
    `spatial.cartesian.max`: [100.0, 100.0]
  }
}

在具有标签 Person 和属性 location 的节点上创建名为 index_name 并使用给定的 spatial.cartesian 设置的点索引。其他索引设置将具有其默认值。点索引仅解决涉及 POINT 属性值的谓词。

CREATE POINT INDEX $nameParam
FOR ()-[h:STREET]-() ON (h.intersection)

在具有类型 STREET 和属性 intersection 的关系上创建名为参数 nameParam 指定的点索引。点索引仅解决涉及 POINT 属性值的谓词。

CREATE LOOKUP INDEX index_name
FOR (n) ON EACH labels(n)

在具有任何标签的节点上创建标记查找索引。

CREATE LOOKUP INDEX index_name
FOR ()-[r]-() ON EACH type(r)

在具有任何关系类型的关系上创建标记查找索引。

SHOW INDEXES

列出所有索引，仅返回默认输出（id、name、state、populationPercent、type、entityType、labelsOrTypes、properties、indexProvider、owningConstraint、lastRead 和 readCount）。

SHOW INDEXES YIELD *

列出所有索引并返回所有列。

SHOW INDEX YIELD name, type, entityType, labelsOrTypes, properties

列出所有索引并仅返回特定列。

SHOW INDEXES
YIELD name, type, options, createStatement
RETURN name, type, options.indexConfig AS config, createStatement

使用 RETURN 子句列出所有索引并仅返回特定列。请注意，如果使用 RETURN，则 YIELD 是强制性的。

SHOW RANGE INDEXES

列出范围索引，也可以根据 ALL、FULLTEXT、LOOKUP、POINT、TEXT 和 VECTOR 进行过滤。

DROP INDEX index_name

删除名为 index_name 的索引，如果索引不存在则抛出错误。

DROP INDEX index_name IF EXISTS

如果存在则删除名为 index_name 的索引，如果不存在则不执行任何操作。

DROP INDEX $nameParam

使用参数删除索引。

MATCH (n:Person)
USING INDEX n:Person(name)
WHERE n.name = $value

当 Cypher 使用次优索引或应使用多个索引时，可以强制执行索引使用。

全文索引

CREATE FULLTEXT INDEX node_fulltext_index
FOR (n:Friend) ON EACH [n.name]
OPTIONS {
  indexConfig: {
    `fulltext.analyzer`: 'swedish'
  }
}

在节点上创建名为 index_name 并使用分析器 swedish 的全文索引。其他索引设置将具有其默认值。

CREATE FULLTEXT INDEX relationship_fulltext_index
FOR ()-[r:KNOWS]-() ON EACH [r.info, r.note]
OPTIONS {
  indexConfig: {
    `fulltext.analyzer`: 'english'
  }
}

在关系上创建名为 index_name 并使用分析器 english 的全文索引。其他索引设置将具有其默认值。

CALL db.index.fulltext.queryNodes("node_fulltext_index", "Alice") YIELD node, score

查询节点上的全文索引。

CALL db.index.fulltext.queryRelationships("relationship_fulltext_index", "Alice") YIELD relationship, score

查询关系上的全文索引。

SHOW FULLTEXT INDEXES

列出所有全文索引。

DROP INDEX node_fulltext_index

删除全文索引。

向量索引

CREATE VECTOR INDEX `abstract-embeddings`
FOR (a:Abstract) ON (a.embedding)
OPTIONS {
  indexConfig: {
    `vector.dimensions`: 1536,
    `vector.similarity_function`: 'cosine'
  }
}

在标签为 Abstract、属性为 embedding 且向量维度为 1536 的节点上创建向量索引，使用 cosine 相似度函数和名称 abstract-embeddings。请注意，由于必须设置向量维度和相似度函数才能创建向量索引，因此 OPTIONS 映射是强制性的。

CREATE VECTOR INDEX `review-embeddings`
FOR ()-[r:REVIEWED]-() ON (r.embedding)
OPTIONS {
  indexConfig: {
    `vector.dimensions`: 256,
    `vector.similarity_function`: 'cosine'
  }
}

在关系类型为 REVIEWED、属性为 embedding 且向量维度为 256 的关系上创建向量索引，使用 cosine 相似度函数和名称 review-embeddings。请注意，由于必须设置向量维度和相似度函数才能创建向量索引，因此 OPTIONS 映射是强制性的。

CALL db.index.vector.queryNodes('abstract-embeddings', 10, abstract.embedding)

查询节点向量索引 abstract-embeddings 以获取 10 个相似摘要的邻域。

CALL db.index.vector.queryRelationships('review-embeddings', 10, $query)

查询关系向量索引 review-embeddings 以获取 10 个与参数 query 指定的向量相似的评论的邻域。

MATCH (n:Node {id: $id})
CALL db.create.setNodeVectorProperty(n, 'propertyKey', $vector)

使用 db.create.setNodeVectorProperty 设置节点的向量属性。

MATCH ()-[r:Relationship {id: $id}]->()
CALL db.create.setRelationshipVectorProperty(r, 'propertyKey', $vector)

使用 db.create.setRelationshipVectorProperty 设置关系的向量属性。

SHOW VECTOR INDEXES

列出所有向量索引。

DROP INDEX `abstract-embeddings`

删除向量索引。

约束

SHOW ALL CONSTRAINTS

列出所有约束，仅返回默认输出（id、name、type、entityType、labelsOrTypes、properties、ownedIndex 和 propertyType）。也可以根据 NODE UNIQUENESS、RELATIONSHIP UNIQUENESS、UNIQUENESS、NODE EXISTENCE、RELATIONSHIP EXISTENCE、EXISTENCE、NODE PROPERTY TYPE、RELATIONSHIP PROPERTY TYPE、PROPERTY TYPE、NODE KEY、RELATIONSHIP KEY 和 KEY 进行过滤。有关更多信息，请参阅 约束 → 语法 → SHOW CONSTRAINTS。

SHOW CONSTRAINTS YIELD *

列出所有约束。有关更多信息，请参阅 约束 → 创建、显示和删除约束 → SHOW CONSTRAINTS。

DROP CONSTRAINT constraint_name

删除名为 constraint_name 的约束，如果约束不存在则抛出错误。

DROP CONSTRAINT $nameParam IF EXISTS

如果存在则删除名为参数 nameParam 指定的约束，如果不存在则不执行任何操作。

CREATE CONSTRAINT constraint_name IF NOT EXISTS
FOR (p:Person)
REQUIRE p.name IS UNIQUE

在标签 Person 和属性 name 上创建节点属性唯一性约束。使用关键字 IF NOT EXISTS 使命令幂等，如果尝试创建相同的约束两次，则不会抛出错误。如果具有该标签的任何其他节点使用已存在的名称进行更新或创建，则写入操作将失败。

最佳实践是在创建约束时始终指定一个有意义的名称。

CREATE CONSTRAINT constraint_name
FOR (p:Person)
REQUIRE (p.name, p.age) IS UNIQUE

在标签 Person 和属性 name 和 age 上创建节点属性唯一性约束。如果尝试创建相同的约束两次，则会抛出错误。如果具有该标签的任何节点使用已存在的名称和年龄组合进行更新或创建，则写入操作将失败。

CREATE CONSTRAINT constraint_name
FOR (p:Person)
REQUIRE p.surname IS UNIQUE
OPTIONS {
  indexProvider: 'range-1.0'
}

在标签 Person 和属性 surname 上创建节点属性唯一性约束，并为随附的索引使用索引提供程序 range-1.0。

CREATE CONSTRAINT constraint_name
FOR ()-[r:LIKED]-()
REQUIRE r.when IS UNIQUE

在关系类型 LIKED 和属性 when 上创建关系属性唯一性约束。如果具有该关系类型的任何其他关系使用已存在的 when 属性值进行更新或创建，则写入操作将失败。

最佳实践是在创建约束时始终指定一个有意义的名称。

CREATE CONSTRAINT $nameParam
FOR (p:Person)
REQUIRE p.name IS NOT NULL

在标签 Person 和属性 name 上创建名为参数 nameParam 指定的节点属性存在约束。如果创建具有该标签的节点时没有 name 属性，或者如果从具有标签 Person 的现有节点中删除 name 属性，则写入操作将失败。

CREATE CONSTRAINT constraint_name
FOR ()-[r:LIKED]-()
REQUIRE r.when IS NOT NULL

在类型 LIKED 和属性 when 上创建关系属性存在约束。如果创建具有该类型的关系时没有 when 属性，或者如果从具有类型 LIKED 的现有关系中删除属性 when，则写入操作将失败。

CREATE CONSTRAINT constraint_name
FOR (p:Person)
REQUIRE p.name IS :: STRING

在标签Person和属性name上创建节点属性类型约束，将属性限制为STRING类型。如果创建具有该标签的节点时，其name属性使用了不同的Cypher类型，则写入操作将失败。

CREATE CONSTRAINT constraint_name
FOR ()-[r:LIKED]-()
REQUIRE r.when IS :: DATE

在关系类型LIKED和属性when上创建关系属性类型约束，将属性限制为DATE类型。如果创建具有该类型的关系时，其when属性使用了不同的Cypher类型，则写入操作将失败。

CREATE CONSTRAINT constraint_name
FOR (p:Person)
REQUIRE (p.name, p.surname) IS NODE KEY

在标签Person和属性name和surname上创建节点键约束，约束名称为constraint_name。如果创建具有该标签的节点时，没有同时包含name和surname属性，或者这两个属性的组合不唯一，或者修改具有标签Person的现有节点上的name和/或surname属性导致违反这些约束，则写入操作将失败。

CREATE CONSTRAINT constraint_name
FOR (p:Person)
REQUIRE (p.name, p.age) IS NODE KEY
OPTIONS {
  indexProvider: 'range-1.0'
}

在标签Person和属性name和age上创建节点键约束，约束名称为constraint_name，并为相应的范围索引指定索引提供程序。

CREATE CONSTRAINT constraint_name
FOR ()-[r:KNOWS]-()
REQUIRE (r.since, r.isFriend) IS RELATIONSHIP KEY

在关系类型KNOWS和属性since和isFriend上创建关系键约束，约束名称为constraint_name。如果创建具有该关系类型的关系时，没有同时包含since和isFriend属性，或者这两个属性的组合不唯一，则写入操作将失败。如果修改具有关系类型KNOWS的现有关系上的since和/或isFriend属性导致违反这些约束，则写入操作也将失败。

性能

性能

尽可能使用参数代替字面量。这允许Neo4j DBMS缓存您的查询，而不是每次都解析并构建新的执行计划。

始终为可变长度模式设置上限。错误地使用查询可能会导致其无限制地遍历图中的所有节点。

仅返回您需要的数据。避免返回整个节点和关系；而是选择您需要的数据并仅返回这些数据。

使用PROFILE / EXPLAIN分析查询的性能。有关这些主题和其他主题（例如计划器提示）的更多信息，请参阅查询调优。

数据库管理

数据库管理

dba
`db1`
`database-name`
`database-name-123`
`database.name`
`database.name.123`

数据库的命名规则

  • 数据库名称的字符长度必须至少为3个字符；且不超过63个字符。

  • 数据库名称的第一个字符必须是ASCII字母字符。

  • 后续字符必须是ASCII字母或数字字符、点或短划线；[a..z][0..9].-。

  • 数据库名称不区分大小写，并规范化为小写。

  • 以下划线（_）或前缀system开头的数据库名称保留供内部使用。

点（.）和短划线（-）等非字母字符，包括数字，都可以在数据库名称中使用，但必须使用反引号（`）转义。最佳实践是在使用点时始终进行转义。已弃用的行为：数据库名称是唯一不需要转义点（.）的标识符。

SHOW DATABASES

列出Neo4j DBMS中的所有数据库及其信息，仅返回默认输出（name、type、aliases、access、address、role、writer、requestedStatus、currentStatus、statusMessage、default、home和constituents）。

SHOW DATABASES YIELD *

列出Neo4j DBMS中的所有数据库及其信息。

SHOW DATABASES
YIELD name, currentStatus
WHERE name CONTAINS 'my'
  AND currentStatus = 'online'

列出数据库信息，按name和currentStatus过滤，并根据这些条件进一步细化。

SHOW DATABASE `database-name` YIELD *

列出数据库database-name的信息。

SHOW DEFAULT DATABASE

列出Neo4j DBMS的默认数据库的信息。

SHOW HOME DATABASE

列出当前用户的主数据库的信息。

DROP DATABASE `database-name` IF EXISTS

删除数据库database-name（如果存在）。此命令可以删除标准数据库和复合数据库。

DROP COMPOSITE DATABASE `composite-database-name`

删除名为composite-database-name的数据库。如果给定的数据库名称不存在或不是复合数据库，则会抛出错误。

DROP DATABASE `database-name` CASCADE ALIASES

删除数据库database-name和任何引用该数据库的数据库别名。此命令可以删除标准数据库和复合数据库。对于标准数据库，将删除的数据库别名是任何指向该数据库的本地数据库别名。对于复合数据库，将删除的数据库别名是属于复合数据库的任何组成数据库别名。

CREATE DATABASE `database-name` IF NOT EXISTS

如果标准数据库名为database-name不存在，则创建它。

CREATE OR REPLACE DATABASE `database-name`

创建标准数据库名为database-name。如果存在同名数据库，则删除现有数据库并创建一个新的。

CREATE DATABASE `topology-example` IF NOT EXISTS
TOPOLOGY 1 PRIMARY 0 SECONDARIES

在集群环境中创建名为topology-example的标准数据库，使用1个主服务器和0个辅助服务器。

CREATE COMPOSITE DATABASE `composite-database-name`

创建名为composite-database-name的复合数据库。

STOP DATABASE `database-name`

停止名为database-name的数据库。

START DATABASE `database-name`

启动名为database-name的数据库。

ALTER DATABASE `database-name` IF EXISTS
SET ACCESS READ ONLY

修改名为database-name的标准数据库，使其仅接受读取查询。

ALTER DATABASE `database-name` IF EXISTS
SET ACCESS READ WRITE

修改名为database-name的标准数据库，使其接受写入和读取查询。

ALTER DATABASE `topology-example`
SET TOPOLOGY 1 PRIMARY 0 SECONDARIES

在集群环境中修改名为topology-example的标准数据库，使用1个主服务器和0个辅助服务器。

ALTER DATABASE `topology-example`
SET TOPOLOGY 1 PRIMARY
SET ACCESS READ ONLY

在集群环境中修改名为topology-example的标准数据库，使用1个主服务器和0个辅助服务器，并且仅接受读取查询。

别名管理

SHOW ALIASES FOR DATABASE

列出Neo4j DBMS中的所有数据库别名及其信息，仅返回默认输出（name、composite、database、location、url和user）。

SHOW ALIASES `database-alias` FOR DATABASE

列出名为database-alias的数据库别名及其信息。仅返回默认输出（name、composite、database、location、url和user）。

SHOW ALIASES FOR DATABASE YIELD *

列出Neo4j DBMS中的所有数据库别名及其信息。

CREATE ALIAS `database-alias` IF NOT EXISTS
FOR DATABASE `database-name`

为名为database-name的数据库创建一个名为database-alias的本地别名。

CREATE OR REPLACE ALIAS `database-alias`
FOR DATABASE `database-name`

为名为database-name的数据库创建或替换名为database-alias的本地别名。

CREATE ALIAS `database-alias`
FOR DATABASE `database-name`
PROPERTIES { property = $value }

数据库别名可以被赋予属性。

CREATE ALIAS `database-alias`
FOR DATABASE `database-name`
AT $url
USER user_name
PASSWORD $password

为名为database-name的数据库创建一个名为database-alias的远程别名。

CREATE ALIAS `composite-database-name`.`alias-in-composite-name`
FOR DATABASE `database-name`
AT $url
USER user_name
PASSWORD $password

在名为composite-database-name的复合数据库中，创建一个名为alias-in-composite-name的远程别名作为组成别名，用于名为database-name的数据库。

ALTER ALIAS `database-alias` IF EXISTS
SET DATABASE TARGET `database-name`

更改名为database-alias的别名以指向名为database-name的数据库。

ALTER ALIAS `remote-database-alias` IF EXISTS
SET DATABASE
USER user_name
PASSWORD $password

更改名为remote-database-alias的远程别名，设置用户名（user_name）和密码。

ALTER ALIAS `database-alias`
SET DATABASE PROPERTIES { key: value }

更新名为database-alias的数据库别名的属性。

DROP ALIAS `database-alias` IF EXISTS FOR DATABASE

删除名为database-alias的别名。

服务器管理

SHOW SERVERS

显示集群中运行的所有服务器，包括尚未启用以及已删除的服务器。默认输出为：name、address、state、health和hosting。

ENABLE SERVER 'serverId'

使ID为serverId的服务器成为集群的活动成员。

RENAME SERVER 'oldName' TO 'newName'

更改服务器的名称。

ALTER SERVER 'name' SET OPTIONS {modeConstraint: 'PRIMARY'}

仅允许指定的服务器以主模式托管数据库。

REALLOCATE DATABASES

在集群中的服务器之间重新平衡数据库。

DEALLOCATE DATABASES FROM SERVER 'name'

从指定的服务器中删除所有数据库，并根据需要将其添加到其他服务器。不允许指定的服务器托管任何新数据库。

DROP SERVER 'name'

从集群中删除指定的服务器。

访问控制

用户管理

SHOW USERS

列出Neo4j DBMS中的所有用户，仅返回默认输出（user、roles、passwordChangeRequired、suspended和home）。

SHOW CURRENT USER

列出当前登录的用户，仅返回默认输出（user、roles、passwordChangeRequired、suspended和home）。

SHOW USERS
WHERE suspended = true

列出已暂停的用户。

SHOW USERS
WHERE passwordChangeRequired

列出下次登录时必须更改密码的用户。

SHOW USERS WITH AUTH

列出用户及其身份验证提供程序。将为每个用户每个身份验证提供程序返回一行。

SHOW USERS WITH AUTH WHERE provider = 'oidc1'

列出具有oidc1身份验证提供程序的用户。

DROP USER user_name

删除指定的用户。

CREATE USER user_name
SET PASSWORD $password

创建一个新用户并设置密码。此密码必须在第一次登录时更改。

CREATE USER user_name
SET AUTH 'native' {
  SET PASSWORD $password
  SET PASSWORD CHANGE REQUIRED
}

使用身份验证提供程序语法创建一个新用户并设置密码。此密码必须在第一次登录时更改。

RENAME USER user_name TO other_user_name

重命名指定的用户。

ALTER CURRENT USER
SET PASSWORD FROM $oldPassword TO $newPassword

更改登录用户的密码。用户无需在下一次登录时更改此密码。

ALTER USER user_name
SET PASSWORD $password
CHANGE NOT REQUIRED

为用户设置新密码（字符串）。用户无需在下一次登录时更改此密码。

ALTER USER user_name IF EXISTS
SET PASSWORD CHANGE REQUIRED

如果指定的用户存在，则强制该用户在下一次登录时更改密码。

ALTER USER user_name
SET AUTH 'externalProviderName' {
  SET ID 'userIdForExternalProvider'
}

添加另一种使用外部提供程序externalProviderName对用户进行身份验证和授权的方法。此提供程序需要在配置设置中定义。

ALTER USER user_name
SET STATUS SUSPENDED

将指定用户的状态更改为SUSPENDED。

ALTER USER user_name
SET STATUS ACTIVE

将指定用户的状态更改为ACTIVE。

ALTER USER user_name
SET HOME DATABASE `database-name`

为指定用户设置主数据库。主数据库可以是数据库或别名。

ALTER USER user_name
REMOVE HOME DATABASE

取消设置指定用户的主数据库，并回退到默认数据库。

角色管理

SHOW ROLES

列出系统中的所有角色，返回输出role。

SHOW ROLES
WHERE role CONTAINS $subString

列出包含给定字符串的角色。

SHOW POPULATED ROLES

列出系统中至少分配给一个用户的角色。

SHOW POPULATED ROLES WITH USERS

列出系统中至少分配给一个用户的全部角色，以及分配给这些角色的用户。返回的输出为role和member。

SHOW POPULATED ROLES WITH USERS
YIELD member, role
WHERE member = $user
RETURN role

列出分配给$user的全部角色。

DROP ROLE role_name

删除一个角色。

CREATE ROLE role_name IF NOT EXISTS

创建一个角色，除非它已经存在。

CREATE ROLE role_name AS COPY OF other_role_name

创建一个角色，作为现有other_role_name角色的副本。

RENAME ROLE role_name TO other_role_name

重命名一个角色。

GRANT ROLE role_name1, role_name2 TO user_name

将角色分配给用户。

REVOKE ROLE role_name FROM user_name

从用户中移除指定的角色。

显示权限

SHOW PRIVILEGES

列出系统中的所有权限，以及分配给它们的全部角色。返回的输出为：access、action、resource、graph、segment、role和immutable。

SHOW PRIVILEGES AS COMMANDS

将系统中的所有权限列为 Cypher 命令，例如GRANT ACCESS ON DATABASE * TO `admin`。仅返回默认输出 (command)。

SHOW USER PRIVILEGES

列出当前登录用户的全部权限，以及分配给它们的全部角色。返回的输出为：access、action、resource、graph、segment、role、immutable和user。

SHOW USER PRIVILEGES AS COMMANDS

将当前登录用户的全部权限，以及分配给它们的全部角色，列为 Cypher 命令，例如GRANT ACCESS ON DATABASE * TO $role。仅返回默认输出 (command)。

SHOW USER user_name PRIVILEGES

列出指定用户（可以使用逗号分隔多个用户，例如n1, n2, n3）的全部权限，以及分配给它们的全部角色。返回的输出为：access、action、resource、graph、segment、role、immutable和user。

SHOW USER user_name PRIVILEGES AS COMMANDS YIELD *

将指定用户（可以使用逗号分隔多个用户，例如n1, n2, n3）的全部权限列为通用 Cypher 命令，例如GRANT ACCESS ON DATABASE * TO $role。返回的输出为：command和immutable。

SHOW ROLE role_name PRIVILEGES

列出指定角色（可以使用逗号分隔多个角色，例如r1, r2, r3）的全部权限。返回的输出为：access、action、resource、graph、segment、role和immutable。

SHOW ROLE role_name PRIVILEGES AS COMMANDS

将指定角色（可以使用逗号分隔多个角色，例如r1, r2, r3）的全部权限列为 Cypher 命令，例如GRANT ACCESS ON DATABASE * TO `admin`。仅返回默认输出 (command)。

显示支持的权限

SHOW SUPPORTED PRIVILEGES

列出服务器上可以授予或拒绝的所有权限。返回的输出为：action、qualifier、target、scope和description。

不变权限

GRANT IMMUTABLE TRAVERSE
ON GRAPH * TO role_name

授予指定角色对所有图的不变TRAVERSE权限。

DENY IMMUTABLE START
ON DATABASE * TO role_name

拒绝指定角色启动所有数据库的不变START权限。

REVOKE IMMUTABLE CREATE ROLE
ON DBMS FROM role_name

撤销指定角色的不变CREATE ROLE权限。当与REVOKE命令一起指定不变时，它将充当过滤器，并且只删除匹配的不变权限。

加载权限

GRANT LOAD
ON ALL DATA
TO role_name

授予指定角色对ALL DATA的LOAD权限，以允许加载所有数据。

DENY LOAD
ON CIDR "127.0.0.1/32"
TO role_name

拒绝指定角色对CIDR范围127.0.0.1/32的LOAD权限，以禁止从该范围内的源加载数据。

在图上

在图上读取权限

GRANT TRAVERSE
ON GRAPH * NODE * TO role_name

授予指定角色对所有图和所有节点的TRAVERSE权限。

  • GRANT – 将权限授予角色。

  • DENY – 拒绝角色的权限。

REVOKE GRANT TRAVERSE
ON GRAPH * NODE * FROM role_name

要移除已授予或拒绝的权限，请在权限查询前添加REVOKE并将TO替换为FROM。

GRANT TRAVERSE
ON GRAPH * RELATIONSHIP * TO role_name

授予指定角色对所有图和所有关系的TRAVERSE权限。

DENY READ {prop}
ON GRAPH `database-name` RELATIONSHIP rel_type TO role_name

拒绝指定角色在指定图中对具有指定类型的全部关系中指定属性的READ权限。

REVOKE READ {prop}
ON GRAPH `database-name` FROM role_name

撤销指定角色在指定图中指定属性的READ权限。

GRANT MATCH {*}
ON HOME GRAPH ELEMENTS label_or_type TO role_name

授予指定角色在主图上对所有节点和具有指定标签/类型的全部关系的MATCH权限。这在语义上等同于同时拥有TRAVERSE权限和READ {*}权限。

GRANT READ {*}
ON GRAPH *
FOR (n) WHERE n.secret = false
TO role_name

授予指定角色对所有图和所有节点（其中secret属性设置为false）的READ权限。

DENY TRAVERSE
ON GRAPH *
FOR (n:label) WHERE n.secret <> false
TO role_name

拒绝指定角色对所有图和所有节点（具有指定标签且secret属性未设置为false）的TRAVERSE权限。

REVOKE MATCH {*}
ON GRAPH *
FOR (n:foo_label|bar_label) WHERE n.secret IS NULL
FROM role_name

撤销指定角色对所有图和所有节点（具有foo_label或bar_label且secret属性为null）的MATCH权限。

在图上写入权限

GRANT ALL GRAPH PRIVILEGES
ON GRAPH `database-name` TO role_name

授予指定角色对指定图的ALL GRAPH PRIVILEGES权限。

GRANT ALL ON GRAPH `database-name` TO role_name

授予ALL GRAPH PRIVILEGES权限的简写形式。

  • GRANT – 将权限授予角色。

  • DENY – 拒绝角色的权限。

要移除已授予或拒绝的权限，请在权限查询前添加REVOKE并将TO替换为FROM；(REVOKE GRANT ALL ON GRAPH `database-name FROM role_name)。

DENY CREATE
ON GRAPH * NODES node_label TO role_name

拒绝指定角色对所有图中具有指定标签的所有节点的CREATE权限。

REVOKE DELETE
ON GRAPH `database-name` TO role_name

撤销指定角色对指定图中所有节点和关系的DELETE权限。

GRANT SET LABEL node_label
ON GRAPH * TO role_name

授予指定角色对所有图中指定标签的SET LABEL权限。

DENY REMOVE LABEL *
ON GRAPH `database-name` TO role_name

拒绝指定角色对指定图中所有标签的REMOVE LABEL权限。

GRANT SET PROPERTY {prop_name}
ON GRAPH `database-name` RELATIONSHIPS rel_type TO role_name

授予指定角色在指定图中对具有指定类型的全部关系中指定属性的SET PROPERTY权限。

GRANT MERGE {*}
ON GRAPH * NODES node_label TO role_name

授予指定角色对所有图中具有指定标签的所有节点的所有属性的MERGE权限。

REVOKE WRITE
ON GRAPH * FROM role_name

撤销指定角色对所有图的WRITE权限。

在数据库上

在数据库上权限

GRANT ALL DATABASE PRIVILEGES
ON DATABASE * TO role_name

授予指定角色对所有数据库的ALL DATABASE PRIVILEGES权限。

  • 允许访问 (GRANT ACCESS)。

  • 索引管理 (GRANT INDEX MANAGEMENT)。

  • 约束管理 (GRANT CONSTRAINT MANAGEMENT)。

  • 名称管理 (GRANT NAME MANAGEMENT)。

请注意，启动和停止所有数据库以及事务管理的权限未包含在内。

GRANT ALL ON DATABASE * TO role_name

授予ALL DATABASE PRIVILEGES权限的简写形式。

  • GRANT – 将权限授予角色。

  • DENY – 拒绝角色的权限。

要移除已授予或拒绝的权限，请在权限查询前添加REVOKE并将TO替换为FROM；(REVOKE GRANT ALL ON DATABASE * FROM role_name)。

REVOKE ACCESS
ON HOME DATABASE FROM role_name

撤销指定角色访问和对主数据库运行查询的ACCESS权限。

GRANT START
ON DATABASE * TO role_name

授予指定角色启动所有数据库的START权限。

DENY STOP
ON HOME DATABASE TO role_name

拒绝指定角色停止主数据库的STOP权限。

在数据库上 - 索引管理权限

GRANT INDEX MANAGEMENT
ON DATABASE * TO role_name

授予指定角色创建、删除和列出所有数据库索引的INDEX MANAGEMENT权限。

  • 允许创建索引 - (GRANT CREATE INDEX)。

  • 允许删除索引 - (GRANT DROP INDEX)。

  • 允许列出索引 - (GRANT SHOW INDEX)。

GRANT CREATE INDEX
ON DATABASE `database-name` TO role_name

授予指定角色在指定数据库上创建索引的CREATE INDEX权限。

GRANT DROP INDEX
ON DATABASE `database-name` TO role_name

授予指定角色在指定数据库上删除索引的DROP INDEX权限。

GRANT SHOW INDEX
ON DATABASE * TO role_name

授予指定角色列出所有数据库索引的SHOW INDEX权限。

在数据库上 - 约束管理权限

GRANT CONSTRAINT MANAGEMENT
ON DATABASE * TO role_name

授予指定角色创建、删除和列出所有数据库约束的CONSTRAINT MANAGEMENT权限。

  • 允许创建约束 - (GRANT CREATE CONSTRAINT)。

  • 允许删除约束 - (GRANT DROP CONSTRAINT)。

  • 允许列出约束 - (GRANT SHOW CONSTRAINT)。

GRANT CREATE CONSTRAINT
ON DATABASE * TO role_name

授予指定角色在所有数据库上创建约束的CREATE CONSTRAINT权限。

GRANT DROP CONSTRAINT
ON DATABASE * TO role_name

授予指定角色在所有数据库上创建约束的DROP CONSTRAINT权限。

GRANT SHOW CONSTRAINT
ON DATABASE `database-name` TO role_name

授予指定角色在指定数据库上列出约束的SHOW CONSTRAINT权限。

在数据库上 - 名称管理权限

GRANT NAME MANAGEMENT
ON DATABASE * TO role_name

授予指定角色对所有数据库创建新标签、新关系类型和新属性名称的NAME MANAGEMENT权限。

  • 允许创建新标签 - (GRANT CREATE NEW LABEL)。

  • 允许创建新关系类型 - (GRANT CREATE NEW TYPE)。

  • 允许创建新属性名称 - (GRANT CREATE NEW NAME)。

GRANT CREATE NEW LABEL
ON DATABASE * TO role_name

授予指定角色在所有数据库上创建新标签的CREATE NEW LABEL权限。

DENY CREATE NEW TYPE
ON DATABASE * TO role_name

拒绝指定角色在所有数据库上创建新关系类型的CREATE NEW TYPE权限。

GRANT CREATE NEW NAME
ON DATABASE * TO role_name

授予指定角色在所有数据库上创建新属性名称的CREATE NEW NAME权限。

数据库 - 事务管理权限

GRANT TRANSACTION MANAGEMENT (*)
ON DATABASE * TO role_name

授予指定角色对所有数据库中所有用户的TRANSACTION MANAGEMENT权限，以便显示和终止事务。

  • 允许列出事务 - (GRANT SHOW TRANSACTION)。

  • 允许终止事务 - (GRANT TERMINATE TRANSACTION)。

GRANT SHOW TRANSACTION (*)
ON DATABASE * TO role_name

授予指定角色对所有数据库中所有用户的SHOW TRANSACTION权限，以便列出事务。

GRANT SHOW TRANSACTION (user_name1, user_name2)
ON HOME DATABASE TO role_name1, role_name2

授予指定角色对指定用户在其主数据库上的SHOW TRANSACTION权限，以便列出事务。

GRANT TERMINATE TRANSACTION (*)
ON DATABASE * TO role_name

授予指定角色对所有数据库中所有用户的TERMINATE TRANSACTION权限，以便终止事务。

DBMS 上

DBMS 权限

GRANT ALL DBMS PRIVILEGES
ON DBMS TO role_name

授予指定角色ALL DBMS PRIVILEGES权限，以便执行角色、用户、数据库、别名和权限的管理。还授予执行过程和用户定义函数的权限。

  • 允许控制角色 - (GRANT ROLE MANAGEMENT)。

  • 允许控制用户 - (GRANT USER MANAGEMENT)。

  • 允许控制数据库 - (GRANT DATABASE MANAGEMENT)。

  • 允许控制别名 - (GRANT ALIAS MANAGEMENT)。

  • 允许控制权限 - (GRANT PRIVILEGE MANAGEMENT)。

  • 允许用户模拟 - (GRANT IMPERSONATE (*))。

  • 允许以提升的权限执行所有过程。

  • 允许以提升的权限执行所有用户定义函数。

GRANT ALL
ON DBMS TO role_name

授予ALL DBMS PRIVILEGES权限的简写形式。

  • GRANT – 将权限授予角色。

  • DENY – 拒绝角色的权限。

要删除已授予或拒绝的权限，请在权限查询前加上REVOKE并将TO替换为FROM；(REVOKE GRANT ALL ON DBMS FROM role_name)。

DENY IMPERSONATE (user_name1, user_name2)
ON DBMS TO role_name

拒绝指定角色模拟指定用户（user_name1和user_name2）的IMPERSONATE权限。

REVOKE IMPERSONATE (*)
ON DBMS TO role_name

撤销指定角色模拟所有用户的IMPERSONATE权限。

GRANT EXECUTE PROCEDURE *
ON DBMS TO role_name

使指定角色能够执行所有过程。

GRANT EXECUTE BOOSTED PROCEDURE *
ON DBMS TO role_name

使指定角色能够在执行所有过程时使用提升的权限。

GRANT EXECUTE ADMIN PROCEDURES
ON DBMS TO role_name

使指定角色能够执行用@Admin注释的过程。这些过程将以提升的权限执行。

GRANT EXECUTE FUNCTIONS *
ON DBMS TO role_name

使指定角色能够执行所有用户定义函数。

GRANT EXECUTE BOOSTED FUNCTIONS *
ON DBMS TO role_name

使指定角色能够在执行所有用户定义函数时使用提升的权限。

GRANT SHOW SETTINGS *
ON DBMS TO role_name

使指定角色能够查看所有配置设置。

DBMS - 角色管理权限

GRANT ROLE MANAGEMENT
ON DBMS TO role_name

授予指定角色ROLE MANAGEMENT权限，以便管理角色。

  • 允许创建角色 - (GRANT CREATE ROLE)。

  • 允许重命名角色 - (GRANT RENAME ROLE)。

  • 允许删除角色 - (GRANT DROP ROLE)。

  • 允许将角色分配给用户 - (GRANT ASSIGN ROLE)。

  • 允许从用户中移除角色 - (GRANT REMOVE ROLE)。

  • 允许列出角色 - (GRANT SHOW ROLE)。

GRANT CREATE ROLE
ON DBMS TO role_name

授予指定角色CREATE ROLE权限，以便创建角色。

GRANT RENAME ROLE
ON DBMS TO role_name

授予指定角色RENAME ROLE权限，以便重命名角色。

DENY DROP ROLE
ON DBMS TO role_name

拒绝指定角色删除角色的DROP ROLE权限。

GRANT ASSIGN ROLE
ON DBMS TO role_name

授予指定角色ASSIGN ROLE权限，以便将角色分配给用户。

DENY REMOVE ROLE
ON DBMS TO role_name

拒绝指定角色从用户中移除角色的REMOVE ROLE权限。

GRANT SHOW ROLE
ON DBMS TO role_name

授予指定角色SHOW ROLE权限，以便列出角色。

DBMS - 用户管理权限

GRANT USER MANAGEMENT
ON DBMS TO role_name

授予指定角色USER MANAGEMENT权限，以便管理用户。

  • 允许创建用户 - (GRANT CREATE USER)。

  • 允许重命名用户 - (GRANT RENAME USER)。

  • 允许修改用户 - (GRANT ALTER USER)。

  • 允许删除用户 - (GRANT DROP USER)。

  • 允许列出用户 - (GRANT SHOW USER)。

DENY CREATE USER
ON DBMS TO role_name

拒绝指定角色创建用户的CREATE USER权限。

GRANT RENAME USER
ON DBMS TO role_name

授予指定角色RENAME USER权限，以便重命名用户。

GRANT ALTER USER
ON DBMS TO my_role

授予指定角色ALTER USER权限，以便修改用户。

  • 允许更改用户的密码 - (GRANT SET PASSWORD)。

  • 允许添加或删除用户的身份验证提供程序 - (GRANT SET AUTH)。

  • 允许更改用户的家目录数据库 - (GRANT SET USER HOME DATABASE)。

  • 允许更改用户的状态 - (GRANT USER STATUS)。

DENY SET PASSWORD
ON DBMS TO role_name

拒绝指定角色更改用户密码的SET PASSWORD权限。

GRANT SET AUTH
ON DBMS TO role_name

授予指定角色SET AUTH权限，以便添加/删除身份验证提供程序。

GRANT SET USER HOME DATABASE
ON DBMS TO role_name

授予指定角色SET USER HOME DATABASE权限，以便修改用户的家目录数据库。

GRANT SET USER STATUS
ON DBMS TO role_name

授予指定角色SET USER STATUS权限，以便修改用户帐户状态。

GRANT DROP USER
ON DBMS TO role_name

授予指定角色DROP USER权限，以便删除用户。

DENY SHOW USER
ON DBMS TO role_name

拒绝指定角色列出用户的SHOW USER权限。

DBMS - 数据库管理权限

GRANT DATABASE MANAGEMENT
ON DBMS TO role_name

授予指定角色DATABASE MANAGEMENT权限，以便管理数据库。

  • 允许创建标准数据库 - (GRANT CREATE DATABASE)。

  • 允许删除标准数据库 - (GRANT DROP DATABASE)。

  • 允许修改标准数据库 - (GRANT ALTER DATABASE)。

  • 允许管理复合数据库 - (GRANT COMPOSITE DATABASE MANAGEMENT)。

GRANT CREATE DATABASE
ON DBMS TO role_name

授予指定角色CREATE DATABASE权限，以便创建标准数据库。

GRANT DROP DATABASE
ON DBMS TO role_name

授予指定角色DROP DATABASE权限，以便删除标准数据库。

GRANT ALTER DATABASE
ON DBMS TO role_name

授予指定角色ALTER DATABASE权限，以便修改标准数据库。

  • 允许修改标准数据库的访问模式 - (GRANT SET DATABASE ACCESS)。

  • 允许修改标准数据库的拓扑设置。

GRANT SET DATABASE ACCESS
ON DBMS TO role_name

授予指定角色SET DATABASE ACCESS权限，以便为标准数据库设置数据库访问模式。

GRANT COMPOSITE DATABASE MANAGEMENT
ON DBMS TO role_name

授予指定角色管理复合数据库的所有权限。

  • 允许创建复合数据库 - (CREATE COMPOSITE DATABASE)。

  • 允许删除复合数据库 - (DROP COMPOSITE DATABASE)。

DENY CREATE COMPOSITE DATABASE
ON DBMS TO role_name

拒绝指定角色创建复合数据库的权限。

REVOKE DROP COMPOSITE DATABASE
ON DBMS FROM role_name

撤销指定角色已授予和拒绝的删除复合数据库的权限。

GRANT SERVER MANAGEMENT
ON DBMS TO role_name

使指定角色能够显示、启用、重命名、更改、重新分配、释放和删除服务器。

DENY SHOW SERVERS
ON DBMS TO role_name

拒绝指定角色显示服务器信息的权限。

DBMS - 别名管理权限

GRANT ALIAS MANAGEMENT
ON DBMS TO role_name

授予指定角色ALIAS MANAGEMENT权限，以便管理别名。

  • 允许创建别名 - (GRANT CREATE ALIAS)。

  • 允许删除别名 - (GRANT DROP ALIAS)。

  • 允许修改别名 - (GRANT ALTER ALIAS)。

  • 允许列出别名 - (GRANT SHOW ALIAS)。

GRANT CREATE ALIAS
ON DBMS TO role_name

授予指定角色CREATE ALIAS权限，以便创建别名。

GRANT DROP ALIAS
ON DBMS TO role_name

授予指定角色DROP ALIAS权限，以便删除别名。

GRANT ALTER ALIAS
ON DBMS TO role_name

授予指定角色ALTER ALIAS权限，以便修改别名。

GRANT SHOW ALIAS
ON DBMS TO role_name

授予指定角色SHOW ALIAS权限，以便列出别名。

DBMS - 角色管理权限

GRANT ROLE MANAGEMENT
ON DBMS TO role_name

授予指定角色ROLE MANAGEMENT权限，以便管理角色。

  • 允许创建角色 - (GRANT CREATE ROLE)。

  • 允许重命名角色 - (GRANT RENAME ROLE)。

  • 允许删除角色 - (GRANT DROP ROLE)。

  • 允许将角色分配给用户 - (GRANT ASSIGN ROLE)。

  • 允许从用户中移除角色 - (GRANT REMOVE ROLE)。

  • 允许列出角色 - (GRANT SHOW ROLE)。

GRANT CREATE ROLE
ON DBMS TO role_name

授予指定角色CREATE ROLE权限，以便创建角色。

GRANT RENAME ROLE
ON DBMS TO role_name

授予指定角色RENAME ROLE权限，以便重命名角色。

DENY DROP ROLE
ON DBMS TO role_name

拒绝指定角色删除角色的DROP ROLE权限。

GRANT ASSIGN ROLE
ON DBMS TO role_name

授予指定角色ASSIGN ROLE权限，以便将角色分配给用户。

DENY REMOVE ROLE
ON DBMS TO role_name

拒绝指定角色从用户中移除角色的REMOVE ROLE权限。

GRANT SHOW ROLE
ON DBMS TO role_name

授予指定角色SHOW ROLE权限，以便列出角色。

DBMS - 权限管理权限

GRANT PRIVILEGE MANAGEMENT
ON DBMS TO role_name

授予指定角色PRIVILEGE MANAGEMENT权限，以便管理 Neo4j DBMS 的权限。

  • 允许为角色分配（GRANT|DENY）权限 - (GRANT ASSIGN PRIVILEGE)。

  • 允许为角色移除（REVOKE）权限 - (GRANT REMOVE PRIVILEGE)。

  • 允许列出权限 - (GRANT SHOW PRIVILEGE)。

GRANT ASSIGN PRIVILEGE
ON DBMS TO role_name

授予ASSIGN PRIVILEGE权限，允许指定角色为角色分配权限。

GRANT REMOVE PRIVILEGE
ON DBMS TO role_name

授予REMOVE PRIVILEGE权限，允许指定角色为角色移除权限。

GRANT SHOW PRIVILEGE
ON DBMS TO role_name

授予指定角色SHOW PRIVILEGE权限，以便列出权限。