Cypher 速查表

读取查询

读取查询结构

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

模式搜索操作的基线。

MATCH

MATCH (n)
RETURN n

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

MATCH (movie:Movie)
RETURN movie.title

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

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

查找别名关系的类型。

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

对 ACTED_IN 关系类型进行关系模式过滤。

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

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

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

匹配节点和关系时，可以在表达式、参数和变量中动态引用节点标签和关系类型。表达式必须求值为 STRING NOT NULL | LIST<STRING NOT NULL> NOT NULL 类型的值。

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

使用变量动态匹配节点。

OPTIONAL MATCH

MATCH (p:Person {name: 'Martin Sheen'})
OPTIONAL MATCH (p)-[r:DIRECTED]->()
RETURN p.name, r

使用 MATCH 查找模式中必须存在的实体。使用 OPTIONAL MATCH 查找模式中可能不存在的实体。OPTIONAL MATCH 对于空行返回 null。

WHERE

MATCH (n)
WHERE n:Swedish
RETURN n.name AS name

WHERE 用于根据节点标签进行过滤。

MATCH (n:Person)
WHERE n.age < 35
RETURN n.name AS name, n.age AS age

WHERE 用于根据节点属性进行过滤。

MATCH (:Person {name:'Andy'})-[k:KNOWS]->(f)
WHERE k.since < 2000
RETURN f.name AS oldFriend

WHERE 用于根据关系属性进行过滤。

MATCH (n:Person)
WHERE n[$propname] > 40
RETURN n.name AS name, n.age AS age

要使用动态计算的名称过滤属性，请使用方括号 []。

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

WHERE 用于固定长度模式内。

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

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

MATCH p = (a:Person {name: "Andy"})-[r:KNOWS WHERE r.since < 2011]->{1,4}(:Person)
RETURN [n IN nodes(p) | n.name] AS paths

WHERE 可用于过滤可变长度模式。

RETURN

MATCH (p:Person {name: 'Keanu Reeves'})
RETURN p

返回一个节点。

MATCH (p:Person {name: 'Keanu Reeves'})-[r:ACTED_IN]->(m)
RETURN type(r)

返回关系类型。

MATCH (p:Person {name: 'Keanu Reeves'})
RETURN p.bornIn

返回特定属性。

MATCH p = (keanu:Person {name: 'Keanu Reeves'})-[r]->(m)
RETURN *

要返回查询中找到的所有节点、关系和路径，请使用 * 符号。

MATCH (p:Person {name: 'Keanu Reeves'})
RETURN p.nationality AS citizenship

返回列的名称可以使用 AS 运算符进行别名。

MATCH (p:Person {name: 'Keanu Reeves'})-->(m)
RETURN DISTINCT m

DISTINCT 为返回的列检索唯一行。

RETURN 子句可以使用

WITH

MATCH (c:Customer)-[:BUYS]->(:Product {name: 'Chocolate'})
WITH c AS customers
RETURN customers.firstName AS chocolateCustomers

WITH 可以与 AS 关键字结合使用，以绑定新变量，然后将其传递给后续子句。任何未被 WITH 显式引用（或由 WITH * 携带）的变量都会从查询范围内删除。

MATCH (supplier:Supplier)-[r]->(product:Product)
WITH *
RETURN supplier.name AS company,
       type(r) AS relType,
       product.name AS product

使用通配符 * 携带范围内所有变量。

WITH 11 AS x
CALL (x) {
  UNWIND [2, 3] AS y
  WITH y
  RETURN x*y AS a
}
RETURN x, a

WITH 无法取消导入到 CALL 子查询的变量的作用域，因为导入到子查询的变量在其内部作用域中被视为全局变量。

MATCH (customer:Customer)-[:BUYS]->(chocolate:Product {name: 'Chocolate'})
WITH customer.firstName || ' ' || customer.lastName AS customerFullName,
     chocolate.price * (1 - customer.discount) AS chocolateNetPrice
RETURN customerFullName,
       chocolateNetPrice

WITH 可用于将表达式的值赋给变量。

MATCH (p:Product)
WITH p, p.price >= 500 AS isExpensive
WITH p, isExpensive, NOT isExpensive AS isAffordable
WITH p, isExpensive, isAffordable,
     CASE
         WHEN isExpensive THEN 'High-end'
         ELSE 'Budget'
     END AS discountCategory
RETURN p.name AS product,
       p.price AS price,
       isAffordable,
       discountCategory
ORDER BY price

WITH 可用于链式表达式。

MATCH (c:Customer)-[:BUYS]->(p:Product)
WITH c.firstName AS customer,
     sum(p.price) AS totalSpent,
     collect(p.name) AS productsBought
RETURN customer,
       totalSpent,
       productsBought
ORDER BY totalSpent DESC

WITH 可用于执行聚合并将结果绑定到新变量。

MATCH (c:Customer)
WITH DISTINCT c.discount AS discountRates
RETURN discountRates
ORDER BY discountRates

如果 WITH 后附加修饰符 DISTINCT，则可用于从结果集中删除重复值。

MATCH (c:Customer)-[:BUYS]->(p:Product)
WITH c,
     sum(p.price) AS totalSpent
  ORDER BY totalSpent DESC
  LIMIT 3
SET c.topSpender = true
RETURN c.firstName AS customer,
       totalSpent,
       c.topSpender AS topSpender

WITH 与 ORDER BY、LIMIT 和 SKIP 子句一起使用时，可以对结果进行排序和分页。

MATCH (s:Supplier)-[:SUPPLIES]->(p:Product)<-[:BUYS]-(c:Customer)
WITH s,
     sum(p.price) AS totalSales,
     count(DISTINCT c) AS uniqueCustomers
  WHERE totalSales > 1000
RETURN s.name AS supplier,
       totalSales,
       uniqueCustomers

WITH 后可跟 WHERE 子句以过滤结果。

MATCH (yusuf:Customer {firstName: 'Yusuf'}),
      (coffee:Product {name: 'Coffee'}),
      (headphones:Product {name: 'Headphones'})
CREATE (yusuf)-[:BUYS {date: date('2025-04-15')}]->(coffee),
       (yusuf)-[:BUYS {date: date('2025-04-15')}]->(headphones)
WITH yusuf
MATCH (yusuf)-[r:BUYS]->(p:Product)
RETURN collect(p.name) AS yusufPurchases,
       r.date AS date
ORDER BY date DESC

如果写入子句后跟读取子句，则必须使用 WITH 作为两者之间的分隔符。

UNION

MATCH (n:Actor)
RETURN n.name AS name
UNION
MATCH (n:Movie)
RETURN n.title AS name

返回所有查询结果的去重并集。结果列的类型和名称必须匹配。

MATCH (n:Actor)
RETURN n.name AS name
UNION ALL
MATCH (n:Movie)
RETURN n.title AS name

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

CALL () {
  MATCH (a:Actor)
  RETURN a.name AS name
UNION ALL
  MATCH (m:Movie)
  RETURN m.title AS name
}
RETURN name, count(*) AS count
ORDER BY count

UNION 子句可以在 CALL 子查询中使用，以便在返回最终输出之前进一步处理合并结果。

写入查询

仅写入查询结构

[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)

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

CREATE (greta:$($nodeLabels) {name: 'Greta Gerwig'})
WITH greta
UNWIND $movies AS movieTitle
CREATE (greta)-[rel:$($relType)]->(m:Movie {title: movieTitle})
RETURN greta.name AS name, labels(greta) AS labels, type(rel) AS relType, collect(m.title) AS movies

合并节点和关系时，可以在表达式、参数和变量中动态引用节点标签和关系类型。表达式必须求值为 STRING NOT NULL | LIST<STRING NOT NULL> NOT NULL 类型的值。

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 查找或创建附加到节点的路径。

MERGE (greta:$($nodeLabels) {name: 'Greta Gerwig'})
WITH greta
UNWIND $movies AS movieTitle
MERGE (greta)-[rel:$($relType)]->(m:Movie {title: movieTitle})
RETURN greta.name AS name, labels(greta) AS labels, type(rel) AS relType, collect(m.title) AS movies

合并节点和关系时，可以在表达式、参数和变量中动态引用节点标签和关系类型。表达式必须求值为 STRING NOT NULL | LIST<STRING NOT NULL> NOT NULL 类型的值。

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 子句与属性替换运算符 (=) 和空映射 ({}) 作为右操作数来删除节点或关系的所有现有属性。

模式

固定长度模式

MATCH (n:Station WHERE n.name STARTS WITH 'Preston')
RETURN n

匹配包含 WHERE 子句谓词的节点模式。

MATCH (s:Stop)-[:CALLS_AT]->(:Station {name: 'Denmark Hill'})
RETURN s.departs AS departureTime

匹配固定长度路径模式到图中的路径。

可变长度模式

MATCH (:Station { name: 'Denmark Hill' })<-[:CALLS_AT]-(d:Stop)
      ((:Stop)-[:NEXT]->(:Stop)){1,3}
      (a:Stop)-[:CALLS_AT]->(:Station { name: 'Clapham Junction' })
RETURN d.departs AS departureTime, a.arrives AS arrivalTime

量化路径模式匹配两个节点之间长度受特定范围（本例中为 1 到 3）约束的路径序列。

MATCH (d:Station { name: 'Denmark Hill' })<-[:CALLS_AT]-
        (n:Stop)-[:NEXT]->{1,10}(m:Stop)-[:CALLS_AT]->
        (a:Station { name: 'Clapham Junction' })
WHERE m.arrives < time('17:18')
RETURN n.departs AS departureTime

量化关系匹配路径，其中指定关系发生 1 到 10 次。

MATCH (bfr:Station {name: "London Blackfriars"}),
      (ndl:Station {name: "North Dulwich"})
MATCH p = (bfr)
          ((a)-[:LINK]-(b:Station)
            WHERE point.distance(a.location, ndl.location) >
              point.distance(b.location, ndl.location))+ (ndl)
RETURN reduce(acc = 0, r in relationships(p) | round(acc + r.distance, 2))
  AS distance

包含谓词的量化路径模式。

最短路径

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 path = ANY
  (:Station {name: 'Pershore'})-[l:LINK WHERE l.distance < 10]-+(b:Station {name: 'Bromsgrove'})
RETURN [r IN relationships(path) | r.distance] AS distances

ANY 关键字可用于测试给定节点（或多个节点）的可达性。它返回与 SHORTEST 1 相同的结果，但使用 ANY 关键字可以使查询意图更清晰。

非线性模式

MATCH (n:Station {name: 'London Euston'})<-[:CALLS_AT]-(s1:Stop)
  -[:NEXT]->(s2:Stop)-[:CALLS_AT]->(:Station {name: 'Coventry'})
  <-[:CALLS_AT]-(s3:Stop)-[:NEXT]->(s4:Stop)-[:CALLS_AT]->(n)
RETURN s1.departs+'-'+s2.departs AS outbound,
  s3.departs+'-'+s4.departs AS `return`

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

MATCH (:Station {name: 'Starbeck'})<-[:CALLS_AT]-
        (a:Stop {departs: time('11:11')})-[:NEXT]->*(b)-[:NEXT]->*
        (c:Stop)-[:CALLS_AT]->(lds:Station {name: 'Leeds'}),
      (b)-[:CALLS_AT]->(l:Station)<-[:CALLS_AT]-(m:Stop)-[:NEXT]->*
        (n:Stop)-[:CALLS_AT]->(lds),
      (lds)<-[:CALLS_AT]-(x:Stop)-[:NEXT]->*(y:Stop)-[:CALLS_AT]->
        (:Station {name: 'Huddersfield'})
WHERE b.arrives < m.departs AND n.arrives < x.departs
RETURN a.departs AS departs,
       l.name AS changeAt,
       m.departs AS changeDeparts,
       y.arrives AS arrives
ORDER BY y.arrives LIMIT 1

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

子句

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 命名结果。

FINISH

MATCH (p:Person)
FINISH

以 FINISH 结束的查询（而不是 RETURN）没有结果，但会执行其所有副作用。

FOREACH

MATCH p=(start)-[*]->(finish)
WHERE start.name = 'A' AND finish.name = 'D'
FOREACH (n IN nodes(p) | SET n.marked = true)

FOREACH 可用于更新数据，例如对路径中的元素或聚合创建的列表执行更新命令。此示例将路径中所有节点的 marked 属性设置为 true。

MATCH p=(start)-[*]->(finish)
WHERE start.name = 'A' AND finish.name = 'D'
FOREACH ( r IN relationships(p) | SET r.marked = true )

此示例将路径中所有关系的 marked 属性设置为 true。

WITH ['E', 'F', 'G'] AS names
FOREACH ( value IN names | CREATE (:Person {name: value}) )

此示例为列表中的每个标签创建一个新节点。

LIMIT

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

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

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

LIMIT 可以作为独立子句使用。

LOAD CSV

LOAD CSV FROM 'file:///artists.csv' AS row
MERGE (a:Artist {name: row[1], year: toInteger(row[2])})
RETURN a.name, a.year

LOAD CSV 用于将数据从 CSV 文件导入 Neo4j 数据库。此示例从本地文件导入艺术家的姓名和年份信息。

LOAD CSV FROM 'https://data.neo4j.com/bands/artists.csv' AS row
MERGE (a:Artist {name: row[1], year: toInteger(row[2])})
RETURN a.name, a.year

从远程文件 URL 导入艺术家的姓名和年份信息。

LOAD CSV WITH HEADERS FROM 'file:///bands-with-headers.csv' AS line
MERGE (n:$(line.Label) {name: line.Name})
RETURN n AS bandNodes

CSV 列可以动态引用，将标签映射到图中的节点。这使得数据处理更加灵活，允许从 CSV 列值填充标签，而无需手动指定每个条目。

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 TRANSACTIONS OF 200 ROWS

以多个事务加载 CSV 文件。此示例使用变量作用域子句（在 Neo4j 5.23 中引入）将变量导入 CALL 子查询。

LOAD CSV FROM 'file:///artists.csv' AS row
RETURN linenumber() AS number, row

使用 linenumber() 函数访问 CSV 中的行号。

LOAD CSV FROM 'file:///artists.csv' AS row
RETURN DISTINCT file() AS path

使用 file() 函数访问 CSV 文件路径。

LOAD CSV WITH HEADERS FROM 'file:///artists-with-headers.csv' AS row
MERGE (a:Artist {name: row.Name, year: toInteger(row.Year)})
RETURN
  a.name AS name,
  a.year AS year

加载带标题的 CSV 数据。

LOAD CSV FROM 'file:///artists-fieldterminator.csv' AS row FIELDTERMINATOR ';'
MERGE (:Artist {name: row[1], year: toInteger(row[2])})

使用 ; 作为字段分隔符导入 CSV。

ORDER BY

MATCH (o:Order)
RETURN o.id AS order,
       o.total AS total
  ORDER BY total

ORDER BY 指定子句输出的排序方式。它可以用作 RETURN 或 WITH 后面的子子句。

MATCH (o:Order)
RETURN o.id AS order,
       o.total AS total,
       o.orderDate AS orderDate
  ORDER BY total,
           orderDate

您可以通过在 ORDER BY 子句中声明每个变量来按多个属性排序。

MATCH (i:Item)
ORDER BY i.price DESC
SKIP 1
LIMIT 1
RETURN i.name AS secondMostExpensiveItem,
       i.price AS price

通过在要排序的变量后添加 DESC[ENDING]，排序将按逆序完成。

ORDER BY 可以与 SKIP 和 LIMIT 结合使用。

MATCH (i:Item)
ORDER BY i.price
RETURN collect(i.name || " ($" || toString(i.price) || ")") AS orderedPriceList

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)
RETURN n.name
ORDER BY n.name
SKIP 1
LIMIT 2

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

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

SKIP 可以作为独立子句使用。

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

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, null] AS x
RETURN x, 'val' AS y

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

返回四行。

UNWIND $events AS event
MERGE (y:Year {year: event.year})
MERGE (y)<-[:IN]-(e:Event {id: event.id})
RETURN e.id AS x ORDER BY x

多个 UNWIND 子句可以链式使用，以展开嵌套列表元素。

返回五行。

UNWIND [1, 2, 3, null] AS x
RETURN x, 'val' AS y

从参数列表创建多个节点和关系，而无需使用 FOREACH。

USE

USE myDatabase
MATCH (n) RETURN n

USE 子句决定查询针对哪个图执行。此示例假设 DBMS 包含一个名为 myDatabase 的数据库。

USE myComposite.myConstituent
MATCH (n) RETURN n

此示例假设 DBMS 包含一个名为 myComposite 的复合数据库，其中包含一个名为 myConstituent 的别名。

子查询

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 (p:Player)
OPTIONAL CALL (p) {
    MATCH (p)-[:PLAYS_FOR]->(team:Team)
    RETURN team
}
RETURN p.name AS playerName, team.name AS team

可选地 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 playerName, p.age AS age

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

事务中的 CALL 子查询

LOAD CSV FROM 'file:///friends.csv' AS line
CALL (line) {
  CREATE (:Person {name: line[1], age: toInteger(line[2])})
} IN TRANSACTIONS

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

LOAD CSV FROM 'file:///friends.csv' AS line
CALL (line) {
  CREATE (: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}) // Note, fails when i = 0
  RETURN n
} IN TRANSACTIONS
  OF 1 ROW
  ON ERROR CONTINUE
RETURN n.num

有四个不同的选项标志来控制任何内部事务中发生错误时的行为：

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

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

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

  • ON ERROR RETRY - 对于因瞬时错误（即重试事务可能产生不同结果的错误）而失败的事务批次，使用重试尝试之间的指数延迟，并可选择最大重试持续时间。如果事务在最大持续时间后仍然失败，则根据可选指定的备用错误处理模式（THEN CONTINUE、THEN BREAK、THEN FAIL（默认））处理失败。

LOAD CSV WITH HEADERS FROM 'https://data.neo4j.com/importing-cypher/persons.csv' AS row
CALL (row) {
  CREATE (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 是一个可选的并发值，用于设置可以并行执行的最大事务数。

LOAD CSV WITH HEADERS FROM 'https://data.neo4j.com/importing-cypher/movies.csv' AS row
CALL (row) {
   MERGE (m:Movie {movieId: row.movieId})
   MERGE (y:Year {year: row.year})
   MERGE (m)-[r:RELEASED_IN]->(y)
} IN 2 CONCURRENT TRANSACTIONS OF 10 ROWS ON ERROR RETRY FOR 3 SECONDS THEN CONTINUE REPORT STATUS AS status
RETURN status.transactionID as transaction, status.committed AS successfulTransaction

ON ERROR RETRY …​ THEN CONTINUE 可用于在继续执行后续内部事务之前，在指定的最大持续时间内重试事务的执行，同时忽略任何可恢复错误。

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 子查询确定图中是否存在至少一次指定模式。WHERE 子句可以在 COLLECT、COUNT 和 EXISTS 模式中使用。

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 子查询可以在其他子句中使用。

谓词

布尔运算符

MATCH (n:Person)
WHERE n.age > 30 AND n.role = 'Software developer'
RETURN n.name AS name, n.age AS age, n.role AS role

AND 运算符用于组合多个布尔表达式，仅当所有条件都为 true 时才返回 true。

MATCH (n:Person)
WHERE n.age < 30 OR n.role = 'Software developer'
RETURN n.name AS name, n.age AS age, n.role AS role

OR 运算符用于组合多个布尔表达式，如果至少一个条件为 true，则返回 true。

MATCH (n:Person)
WHERE n.age > 30 XOR n.role = 'Software developer'
RETURN n.name AS name, n.age AS age, n.role AS role

XOR 运算符在两个布尔表达式中只有一个为 true 时返回 true，但不能同时为 true。

MATCH (n:Person)
WHERE NOT n.age = 39
RETURN n.name AS name, n.age AS age

NOT 运算符用于否定布尔表达式，如果表达式为 false 则返回 true，如果为 true 则返回 false。

比较运算符

MATCH (n:Person)
WHERE n.role = 'Software developer'
RETURN n.name AS name, n.role AS role

等号运算符 = 检查两个值之间是否相等。

MATCH (n:Person)
WHERE n.role <> 'Software developer'
RETURN n.name AS name, n.role AS role

不等号运算符 <> 检查两个值是否不相等。

MATCH (n:Person)
WHERE n.age < 39
RETURN n.name AS name, n.age AS age

小于运算符 < 如果左侧的值小于右侧的值，则返回 true。

MATCH (n:Person)
WHERE n.age <= 39
RETURN n.name AS name, n.age AS age

小于或等于运算符 <= 如果左侧的值小于或等于右侧的值，则返回 true。

MATCH (n:Person)
WHERE n.age > 39
RETURN n.name AS name, n.age AS age

大于运算符 > 如果左侧的值大于右侧的值，则返回 true。

MATCH (n:Person)
WHERE n.age >= 39
RETURN n.name AS name, n.age AS age

大于或等于运算符 >= 如果左侧的值大于或等于右侧的值，则返回 true。

MATCH (n:Person)
WHERE n.email IS NULL
RETURN n.name AS name

IS NULL 运算符如果值为 NULL 则返回 true，否则返回 false。

MATCH (n:Person)
WHERE n.email IS NOT NULL
RETURN n.name AS name, n.email AS email

IS NOT NULL 运算符如果值不为 NULL 则返回 true，否则返回 false。

列表运算符

MATCH (n:Person)
WHERE n.role IN ['Software developer', 'Project manager']
RETURN n.name AS name, n.role AS role

IN 运算符检查值是否存在于 LIST 中。

RETURN any(x IN [1, 2, null] WHERE x IS NULL) AS containsNull

要检查 NULL 是否是 LIST 的成员，请使用 any() 函数。

RETURN [3, 4] IN [[1, 2], [3, 4]] AS listInNestedList

当与嵌套 LIST 值一起使用时，IN 运算符评估一个 LIST 是否与作为外部 LIST 一部分的任何嵌套 LIST 值完全匹配。嵌套 LIST 中单个元素的局部匹配将返回 false。

WITH [1,3,4] AS sub, [3,5,1,7,6,2,8,4] AS list
RETURN all(x IN sub WHERE x IN list) AS subInList

使用 all() 函数的子集检查验证一个 LIST 的所有元素是否存在于另一个 LIST 中。

路径模式表达式

MATCH (employee:Person)
WHERE (employee)-[:WORKS_FOR]->(:Person {name: 'Alice'})
RETURN employee.name AS employee

与EXISTS 子查询类似，路径模式表达式可用于断言图中是否存在至少一次指定路径。

MATCH (employee:Person)
WHERE NOT employee.name = 'Cecil' AND (employee)-[:WORKS_FOR]->(:Person {name: 'Alice'})
RETURN employee.name AS employee

带有布尔运算符的路径模式表达式。

字符串运算符

MATCH (n:Person)
WHERE n.name STARTS WITH 'C'
RETURN n.name AS name

STARTS WITH 运算符检查 STRING 值是否以指定前缀开头。

MATCH (n:Person)
WHERE n.role ENDS WITH 'developer'
RETURN n.name AS name, n.role AS role

ENDS WITH 运算符检查 STRING 值是否以指定后缀结尾。

MATCH (n:Person)
WHERE n.role CONTAINS 'eng'
RETURN n.name AS name, n.role AS role

CONTAINS 运算符检查 STRING 值是否包含指定子字符串。

MATCH (n:Person)
WHERE n.email =~ '.*@company.com'
RETURN n.name AS name, n.email AS email

正则表达式运算符 =~ 检查 STRING 值是否匹配正则表达式。

MATCH (n:Person)
WHERE n.name =~ '(?i)CEC.*'
RETURN n.name

=~ 运算符可以与正则表达式标志一起使用，例如 (?i) 用于不区分大小写匹配，以修改正则表达式的应用方式。

RETURN 'the \u212B char' IS NORMALIZED AS normalized

IS NORMALIZED 运算符用于检查给定的 STRING 值是否为 NFC Unicode 规范化形式。

RETURN 'the \u212B char' IS NOT NORMALIZED AS notNormalized

IS NOT NORMALIZED 运算符用于检查给定的 STRING 值是否不为 NFC Unicode 规范化形式。

WITH 'the \u00E4 char' as myString
RETURN myString IS NFC NORMALIZED AS nfcNormalized,
    myString IS NFD NORMALIZED AS nfdNormalized

可以定义使用哪种 Unicode 规范化类型。可用的规范化类型有：NFC（默认）、NFD、NFKC 和 NFKD。

类型谓词表达式

UNWIND [42, true, 'abc', null] AS val
RETURN val, val IS :: INTEGER AS isInteger

类型谓词表达式可用于验证变量、字面量、属性或其他 Cypher 表达式的类型。

UNWIND [42, true, 'abc', null] AS val
RETURN val, val IS NOT :: STRING AS notString

可以使用否定类型谓词表达式 IS NOT :: 来验证 Cypher 表达式是否不属于某种特定类型。

RETURN
  NULL IS :: BOOLEAN AS isBoolean,
  NULL IS :: BOOLEAN NOT NULL AS isNotNullBoolean

所有 Cypher 类型都包含 NULL 值。类型谓词表达式可以附加 NOT NULL。这意味着除非附加 NOT NULL，否则 IS :: 对所有求值为 NULL 的表达式返回 TRUE。

MATCH (n:Person)
WHERE n.age IS :: INTEGER AND n.age > 18
RETURN n.name AS name, n.age AS age

类型谓词表达式还可以用于过滤具有特定类型属性的节点或关系。

UNWIND [42, 42.0, "42"] as val
RETURN val, val IS :: INTEGER | FLOAT AS isNumber

封闭动态联合类型允许在同一谓词中测试多种类型。

表达式

条件表达式（CASE）

MATCH (n:Person)
RETURN
CASE n.eyes
  WHEN 'blue'  THEN 1
  WHEN 'brown', 'hazel' THEN 2
  ELSE 3
END AS result, n.eyes

简单 CASE 形式用于将单个表达式与多个值进行比较，类似于编程语言中的 switch 结构。表达式由 WHEN 运算符评估，直到找到匹配项。如果未找到匹配项，则返回 ELSE 运算符中的表达式。如果没有 ELSE 情况且未找到匹配项，则返回 null。

MATCH (n:Person)
RETURN n.name,
CASE n.age
  WHEN IS NULL, IS NOT TYPED INTEGER | FLOAT THEN "Unknown"
  WHEN = 0, = 1, = 2 THEN "Baby"
  WHEN <= 13 THEN "Child"
  WHEN < 20 THEN "Teenager"
  WHEN < 30 THEN "Young Adult"
  WHEN > 1000 THEN "Immortal"
  ELSE "Adult"
END AS result

扩展简单 CASE 可以使用比较运算符。

MATCH (n:Person)
RETURN
CASE
  WHEN n.eyes = 'blue' THEN 1
  WHEN n.age < 40      THEN 2
  ELSE 3
END AS result, n.eyes, n.age

通用 CASE 表达式支持多个条件语句，类似于编程语言中的 if-elseif-else 结构。每行按顺序评估，直到找到 true 值。如果未找到匹配项，则返回 ELSE 运算符中的表达式。如果没有 ELSE 情况且未找到匹配项，则返回 null。

MATCH (n:Person)
WITH n,
CASE n.eyes
  WHEN 'blue'  THEN 1
  WHEN 'brown' THEN 2
  ELSE 3
END AS colorCode
SET n.colorCode = colorCode
RETURN n.name, n.colorCode

CASE 表达式的结果可用于设置节点或关系上的属性。

标签表达式

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

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

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

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

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

使用 OR (|) 标签表达式的关系模式。由于关系只能有一个类型，()-[:A&B]→() 永远不会匹配关系。

列表表达式

WITH [1, 2, 3, 4] AS list
RETURN list[0] AS firstElement,
       list[2] AS thirdElement,
       list[-1] AS finalElement

下标运算符 [] 可用于访问 LIST 中的特定元素。[0] 指 LIST 中的第一个元素，[1] 指第二个，依此类推。[-1] 指 LIST 中的最后一个元素，[-2] 指倒数第二个元素，依此类推。

WITH [[1, 2], [3, 4], [5, 6]] AS nestedList
RETURN nestedList[1] AS secondList

访问嵌套 LIST 中的 LIST。

WITH [[1, 2], [3, 4], [5, 6]] AS nestedList
RETURN nestedList[1] AS secondList,
       nestedList[1][0] AS firstElementOfSecondList

访问嵌套 LIST 中的特定元素。

WITH [1, 2, 3, 4, 5, 6] AS list
RETURN list[2..4] AS middleElements,
       list[..2] AS noLowerBound,
       list[2..] AS noUpperBound

如果在下标运算符 [] 中提供范围，则可以对 LIST 值进行切片。范围的边界使用两个点 (..) 分隔。这允许提取 LIST 的子集而不是单个元素。列表切片在范围的开始处是包含的，但在结束处是排他的（例如，list[start..end] 包含 start，但不包含 end）。

WITH [1, 2, 3, 4, 5, 6] AS list
RETURN list[..-1] AS finalElementRemoved,
       list[..-2] AS finalTwoElementsRemoved,
       list[-3..-1] AS removedFirstThreeAndLast

列表切片中的负索引从 LIST 的末尾引用元素；..-1 排除最后一个元素，..-2 排除最后两个元素，依此类推。

WITH [[1, 2, 3], [4, 5, 6], [7, 8, 9]] AS nestedList
RETURN nestedList[1][0..2] AS slicedInnerList

切片内部 LIST 值需要两个 [] 运算符；第一个 [] 访问外部 LIST 中的元素，而第二个切片或访问内部 LIST 中的元素。

RETURN [1,2] || [3,4] AS list1,
       [1,2] + [3,4] AS list2

Cypher 包含两个列表连接运算符：|| 和 +。它们功能上等效，但 || 符合 GQL 标准而 + 不符合。

WITH [1, 2, 3, 4] AS list
RETURN 0 + list AS newBeginning,
       list + 5 AS newEnd

+ 运算符可以将元素添加到 LIST 值的开头或末尾。这在使用 || 运算符时是不可能的。

WITH [1, 2, 3, 4, 5] AS list
RETURN [n IN list WHERE n > 2 | n] AS filteredList

列表推导式用于通过迭代现有 LIST 值并根据特定条件或操作转换元素来创建新的 LIST 值。此过程有效地将原始 LIST 中的每个元素映射到新值。结果是一个由转换后的元素组成的新 LIST。

MATCH (p:Person) WHERE p.skills IS NOT NULL
ORDER BY p.name
RETURN p.name AS name,
      [skill IN p.skills | skill + " expert"] AS modifiedSkills

使用节点属性的列表推导式。

MATCH (p:Person)
RETURN [person IN collect(p) WHERE 'Python' IN person.skills | person.name] AS pythonExperts

带有 WHERE 谓词的列表推导式。

RETURN [x IN ([1, null, 3] || [null, 5, null]) WHERE x IS NOT NULL] AS listWithoutNull

列表推导式可用于在连接 LIST 值时删除任何未知的 NULL 值。

MATCH (alice:Person {name: 'Alice'})
RETURN [(employee:Person)-[:WORKS_FOR]->(alice) | employee.name] AS employees

模式推导式用于通过匹配图模式并对匹配的元素应用条件来创建新的 LIST 值，返回自定义投影。

MATCH (alice:Person {name: 'Alice'})
RETURN [(employee:Person)-[:WORKS_FOR]->(alice) WHERE employee.age > 30 | employee.name || ', ' || toString(employee.age)] AS employeesAbove30

带有 WHERE 谓词的模式推导式。

MATCH (cecil:Person {name: 'Cecil'})
WITH [(cecil)-[:WORKS_FOR*]->(superior:Person) | superior.skills] AS allSuperiorsSkills
WITH reduce(accumulatedSkills = [], superiorSkills IN allSuperiorsSkills | accumulatedSkills || superiorSkills) AS allSkills
UNWIND allSkills AS superiorsSkills
RETURN collect(DISTINCT superiorsSkills) AS distinctSuperiorsSkills

可变长度模式推导式。

节点和关系运算符

MATCH (employee:Person)-[r:WORKS_FOR]->(manager:Person)
RETURN employee.firstName AS employee,
       r.since AS employedSince,
       manager.firstName AS manager

节点和关系的属性值可以通过在 . 运算符后指定属性名称来静态访问。

WITH 'lastName' AS nodeProperty
MATCH (p:Person)
RETURN p[nodeProperty] AS lastName

属性值可以使用下标运算符 [] 动态访问。

MATCH (p:Person)
RETURN p.firstName || coalesce(' ' + p.middleName, '') || ' ' || p.lastName AS fullName

如果尝试静态或动态访问属性的表达式中缺少属性（或属性值），则整个表达式将求值为 NULL。可以使用 coalesce() 函数跳过表达式中的第一个 NULL 值。

数学运算符

RETURN 10 + 5 AS result

加法运算符 + 用于添加数值。

RETURN 10 - 5 AS result

减法运算符 - 用于减去数值。

RETURN 10 * 5 AS result

乘法运算符 * 用于乘以数值。

RETURN 10 / 5 AS result

除法运算符 / 用于除数值。

RETURN 10 % 3 AS result

模除法运算符 % 返回一个数除以另一个数后的余数。

RETURN 10 ^ 5 AS result

幂运算符 ^ 将一个数提高到另一个数的幂。

映射表达式

WITH {a: 10, b: 20, c: 30} AS map
RETURN map.a AS firstValue,
       map.c AS lastValue

MAP 值可以通过在 . 运算符后指定键来静态访问。

WITH {a: 10, b: 20, c: 30, innerMap: {x: 100, y: 200, z: 300}} AS map
RETURN map.a AS firstOuterValue,
       map.innerMap.y AS secondInnerValue

要静态访问嵌套 MAP 中的值，请使用链式 . 运算符。每个 . 运算符深入嵌套结构一层。

WITH {a: 10, b: 20, c: 30} AS map,
     'a' AS dynamicKey
RETURN map[dynamicKey] AS dynamicValue

要动态访问 MAP 值，请使用下标运算符 []。键可以通过变量或参数提供。

WITH {a: 10, b: 20, c: 30, innerMap: {x: 100, y: 200, z: 300}} AS map,
     'z' AS dynamicInnerKey
RETURN map.innerMap[dynamicInnerKey] AS dynamicInnerValue

动态访问嵌套 MAP 值。

WITH {a: 10, b: 20, c: 30} AS map
RETURN map{.a, .c} AS projectedMap

带有键选择器的映射投影，用于从 MAP 中提取特定的键值对。

WITH {a: 10, b: 20, c: 30} AS map
RETURN map{a: map.a, valueSum: map.a + map.b + map.c} AS projectedMap

带有字面量条目的映射投影，用于向投影的 MAP 值添加自定义值，而不修改原始数据结构。

MATCH (keanu:Person {name: 'Keanu Reeves'})
WITH keanu, date('1964-09-02') AS dob, 'Beirut, Lebanon' AS birthPlace
RETURN keanu{.name, dob, birthPlace} AS projectedKeanu

带有变量选择器的映射投影，用于根据变量名投影值。

WITH {a: 10, b: 20, c: 30} AS map
RETURN map{.*} AS projectedMap

带有全映射投影的映射投影，用于投影 MAP 中的所有键值对，而无需显式列出它们。

字符串连接运算符

RETURN 'Neo' || '4j' AS result1,
       'Neo' + '4j' AS result2

Cypher 包含两个用于连接 STRING 值的运算符：|| 和 +。这两个运算符功能上等效。但是，|| 符合 GQL 标准，而 + 不符合。

RETURN 'Alpha' || 'Beta' AS result1,
       'Alpha' || ' ' || 'Beta' AS result2

Cypher 在连接 STRING 值时不会插入空格。

CREATE (p:Person {firstName: 'Keanu', lastName: 'Reeves'})
SET p.fullName = p.firstName || ' ' || p.lastName
RETURN p.fullName AS fullName

两个 STRING 属性的字符串连接。

RETURN 'My favorite fruits are: ' || 'apples' || ', ' || 'bananas' || ', and ' || 'oranges' || '.' AS result

字符串连接，添加前缀、后缀和分隔符。

WITH ['Neo', '4j'] AS list
RETURN reduce(acc = '', item IN list| acc || item) AS result

LIST 中的 STRING 值可以使用 reduce() 函数进行连接。

WITH ['Apples', null, 'Bananas', null, 'Oranges', null] AS list
RETURN 'My favorite fruits are: ' || reduce(acc = head(list), item IN tail(list) | acc || coalesce(', ' || item, '')) || '.' AS result

将 STRING 值与 NULL 连接将返回 NULL。要跳过表达式列表中的第一个 NULL 值，请使用 coalesce() 函数。

WITH ['Apples', 'Bananas', 'Oranges'] AS list
RETURN [item IN list | 'Eat more ' || item || '!'] AS result

列表推导式允许将 STRING 值连接到 LIST 中的每个项，以生成一个新的修改后的 STRING 值 LIST。

时间运算符

WITH localdatetime({year:1984, month:10, day:11, hour:12, minute:31, second:14}) AS aDateTime,
     duration({years: 12, nanoseconds: 2}) AS aDuration
RETURN aDateTime + aDuration AS addition,
      aDateTime - aDuration AS subtraction

DURATION 值可以与时间瞬时值（例如 LOCAL DATETIME）进行加减。

WITH duration({days: 14, minutes: 12, seconds: 70, nanoseconds: 1}) AS aDuration
RETURN aDuration,
       aDuration * 2 AS multipliedDuration,
       aDuration / 3 AS dividedDuration

乘除 DURATION 时，每个组成部分都单独处理。在乘法中，每个组成部分的值乘以给定因子；在除法中，每个组成部分除以给定数字。如果除法结果不适合原始组成部分，则会溢出到更小的组成部分（例如将天转换为小时）。

函数

聚合函数

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)
WHERE p.name IN ['Keanu Reeves', 'Liam Neeson', 'Carrie Anne Moss']
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: 5, days: 1.5}),
duration({months: 0.75}),
duration({weeks: 2.5}),
duration({minutes: 1.5, seconds: 1, milliseconds: 123, microseconds: 456, nanoseconds: 789}),
duration({minutes: 1.5, seconds: 1, nanoseconds: 123456789})
] AS aDuration
RETURN aDuration

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

UNWIND [
duration("P14DT16H12M"),
duration("P5M1.5D"),
duration("P0.75M"),
duration("PT0.75M"),
duration("P2012-02-02T14:37:21.545")
] AS aDuration
RETURN aDuration

duration from a string 函数通过解析时间量的 STRING 表示形式返回 DURATION 值。

UNWIND [
duration.between(date("1984-10-11"), date("1985-11-25")),
duration.between(date("1985-11-25"), date("1984-10-11")),
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")),
duration.between(datetime({year: 2017, month: 10, day: 29, hour: 0, timezone: 'Europe/Stockholm'}), datetime({year: 2017, month: 10, day: 29, hour: 0, timezone: 'Europe/London'}))
] AS aDuration
RETURN aDuration

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

UNWIND [
duration.inMonths(date("1984-10-11"), date("1985-11-25")),
duration.inMonths(date("1985-11-25"), date("1984-10-11")),
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")),
duration.inMonths(datetime({year: 2017, month: 10, day: 29, hour: 0, timezone: 'Europe/Stockholm'}), datetime({year: 2017, month: 10, day: 29, hour: 0, timezone: 'Europe/London'}))
] AS aDuration
RETURN aDuration

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

UNWIND [
duration.inDays(date("1984-10-11"), date("1985-11-25")),
duration.inDays(date("1985-11-25"), date("1984-10-11")),
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")),
duration.inDays(datetime({year: 2017, month: 10, day: 29, hour: 0, timezone: 'Europe/Stockholm'}), datetime({year: 2017, month: 10, day: 29, hour: 0, timezone: 'Europe/London'}))
] AS aDuration
RETURN aDuration

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

UNWIND [
duration.inSeconds(date("1984-10-11"), date("1984-10-12")),
duration.inSeconds(date("1984-10-12"), date("1984-10-11")),
duration.inSeconds(date("1984-10-11"), datetime("1984-10-12T01:00:32.142+0100")),
duration.inSeconds(date("2015-06-24"), localtime("14:30")),
duration.inSeconds(datetime({year: 2017, month: 10, day: 29, hour: 0, timezone: 'Europe/Stockholm'}), datetime({year: 2017, month: 10, day: 29, hour: 0, timezone: 'Europe/London'}))
] AS aDuration
RETURN aDuration

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

图函数

RETURN graph.names() AS name

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

UNWIND graph.names() AS name
RETURN name, graph.propertiesByName(name) AS props

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

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.likedColors, tail(a.likedColors)

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

RETURN toBooleanList(null) as noList,
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()

rand 函数返回一个介于 0（包含）到 1（不包含）之间的随机 FLOAT。返回的数字遵循近似均匀分布。

RETURN round(3.141592)

round 函数返回给定数字四舍五入到最接近的 INTEGER 的值，平局时始终朝正无穷大舍入。

RETURN round(3.141592, 3)

round with precision 函数返回给定数字四舍五入到给定精度的最接近值，平局时始终远离零舍入（使用 HALF_UP 舍入模式）。精度为 0 时例外，此时平局向正无穷大舍入，以与不带精度的 round() 对齐。

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

round with precision and rounding mode 函数返回给定数字按指定精度和指定舍入模式四舍五入后的值。

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 函数返回第一个非 null 参数。

MATCH (n:Developer)
RETURN elementId(n)

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

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

endNode 函数返回 RELATIONSHIP 的结束 NODE。

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

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

MATCH (a)
RETURN id(a)

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

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

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 函数返回移除了开头和结尾 `trimCharacterString` 字符的原始 `STRING`。如果未指定 `trimCharacterString`，则会移除所有开头和结尾的空白字符。

RETURN left('hello', 3)

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

RETURN lower('HELLO')

的 lower 函数返回给定 `STRING` 的小写形式。此函数是 toLower 函数的别名。

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

的 ltrim 函数返回移除了开头 `trimCharacterString` 字符的原始 `STRING`。如果未指定 `trimCharacterString`，则会移除所有开头的空白字符。

RETURN normalize('\u212B') = '\u00C5' AS result

的 normalize 函数使用 `NFC` Unicode 规范化形式返回给定 `STRING` 的规范化形式。

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 函数返回移除了结尾 `trimCharacterString` 字符的给定 `STRING`。如果未指定 `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 toStringOrNull(11.5),
toStringOrNull('already a string'),
toStringOrNull(true),
toStringOrNull(date({year: 1984, month: 10, day: 11})) AS dateString,
toStringOrNull(datetime({year: 1984, month: 10, day: 11, hour: 12, minute: 31, second: 14, millisecond: 341, timezone: 'Europe/Stockholm'})) AS datetimeString,
toStringOrNull(duration({minutes: 12, seconds: -60})) AS durationString,
toStringOrNull(['A', 'B', 'C']) AS list

的 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(BOTH 'x' FROM 'xxxhelloxxx')

的 trim 函数返回移除了开头和结尾空白字符的给定 `STRING`。

RETURN upper('hello')

的 upper 函数返回给定 `STRING` 的大写形式。此函数是 toUpper 函数的别名。

空间函数

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 笛卡尔二维 函数返回对应于给定坐标值的 _笛卡尔_ CRS 中的二维 `POINT`。

RETURN
  point.withinBBox(
    null,
    point({longitude: 56.7, latitude: 12.78}),
    point({longitude: 57.0, latitude: 13.0})
  ) AS in

的 point 笛卡尔三维 函数返回对应于给定坐标值的 _笛卡尔_ 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 WGS 84 二维 函数返回对应于给定坐标值的 _WGS 84 CRS_ 中的二维 `POINT`。

WITH
  point({x: 0, y: 0, crs: 'cartesian'}) AS lowerLeft,
  point({x: 10, y: 10, crs: 'cartesian'}) AS upperRight
RETURN point.withinBBox(point({x: 5, y: 5, crs: 'cartesian'}), lowerLeft, upperRight) AS result

的 point WGS 84 三维 函数返回对应于给定坐标值的 _WGS 84 CRS_ 中的三维 `POINT`。

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

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

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

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

时间函数

RETURN date() AS currentDate

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

RETURN date.realtime() AS currentDate

的 date.realtime() 函数使用实时时钟返回当前的 `DATE` 瞬时值。

RETURN date.statement() AS currentDate

的 date.statement() 函数使用语句时钟返回当前的 `DATE` 瞬时值。

RETURN date.transaction() AS currentDate

的 date.transaction() 函数使用事务时钟返回当前的 `DATE` 瞬时值。

WITH
  datetime({
    year: 2017, month: 11, day: 11,
    hour: 12, minute: 31, second: 14, nanosecond: 645876123,
    timezone: '+01:00'
  }) AS d
RETURN
  date.truncate('millennium', d) AS truncMillenium,
  date.truncate('century', d) AS truncCentury,
  date.truncate('decade', d) AS truncDecade,
  date.truncate('year', d, {day: 5}) AS truncYear,
  date.truncate('weekYear', d) AS truncWeekYear,
  date.truncate('quarter', d) AS truncQuarter,
  date.truncate('month', d) AS truncMonth,
  date.truncate('week', d, {dayOfWeek: 2}) AS truncWeek,
  date.truncate('day', d) AS truncDay

的 date.truncate() 函数使用指定的单位将给定的时间值截断为 `DATE` 瞬时值。

RETURN datetime() AS currentDateTime

的 datetime() 函数创建一个 `ZONED DATETIME` 瞬时值。

WITH datetime.fromEpoch(1683000000, 123456789) AS dateTimeFromEpoch
RETURN dateTimeFromEpoch

的 datetime.fromEpoch() 函数根据自纪元开始以来的秒数和纳秒数创建 `ZONED DATETIME`。

WITH datetime.fromEpochMillis(1724198400000) AS dateTimeFromMillis
RETURN dateTimeFromMillis

的 datetime.fromEpochMillis() 函数根据自纪元开始以来的毫秒数创建 `ZONED DATETIME`。

RETURN datetime.realtime() AS currentDateTime

的 datetime.realtime() 函数使用实时时钟返回当前的 `ZONED DATETIME` 瞬时值。

RETURN datetime.statement() AS currentDateTime

的 datetime.statement() 函数使用语句时钟返回当前的 `ZONED DATETIME` 瞬时值。

RETURN datetime.transaction() AS currentDateTime

的 datetime.transaction() 函数使用事务时钟返回当前的 `ZONED DATETIME` 瞬时值。

WITH
  datetime({
    year:2017, month:11, day:11,
    hour:12, minute:31, second:14, nanosecond: 645876123,
    timezone: '+03:00'
  }) AS d
RETURN
  datetime.truncate('millennium', d, {timezone: 'Europe/Stockholm'}) AS truncMillenium,
  datetime.truncate('year', d, {day: 5}) AS truncYear,
  datetime.truncate('month', d) AS truncMonth,
  datetime.truncate('day', d, {millisecond: 2}) AS truncDay,
  datetime.truncate('hour', d) AS truncHour,
  datetime.truncate('second', d) AS truncSecond

的 datetime.truncate() 函数使用指定的单位将给定的时间值截断为 `ZONED DATETIME` 瞬时值。

RETURN
  localdatetime({
    year: 1984, ordinalDay: 202,
    hour: 12, minute: 31, second: 14, microsecond: 645876
  }) AS theDate

的 localdatetime() 函数创建一个 `LOCAL DATETIME` 瞬时值。

RETURN localdatetime.realtime() AS now

的 localdatetime.realtime() 函数使用实时时钟返回当前的 `LOCAL DATETIME` 瞬时值。

RETURN localdatetime.statement() AS now

的 localdatetime.statement() 函数使用语句时钟返回当前的 `LOCAL DATETIME` 瞬时值。

RETURN localdatetime.transaction() AS now

的 localdatetime.transaction() 函数使用事务时钟返回当前的 `LOCAL DATETIME` 瞬时值。

WITH
  localdatetime({
    year: 2017, month: 11, day: 11,
    hour: 12, minute: 31, second: 14, nanosecond: 645876123
  }) AS d
RETURN
  localdatetime.truncate('millennium', d) AS truncMillenium,
  localdatetime.truncate('year', d, {day: 2}) AS truncYear,
  localdatetime.truncate('month', d) AS truncMonth,
  localdatetime.truncate('day', d) AS truncDay,
  localdatetime.truncate('hour', d, {nanosecond: 2}) AS truncHour,
  localdatetime.truncate('second', d) AS truncSecond

的 localdatetime.truncate() 函数使用指定的单位将给定的时间值截断为 `LOCAL DATETIME` 瞬时值。

RETURN localtime() AS now

的 localtime() 函数创建一个 `LOCAL TIME` 瞬时值。

RETURN localtime.realtime() AS now

的 localtime.realtime() 函数使用实时时钟创建并返回当前的 `LOCAL TIME` 瞬时值。

RETURN localtime.statement() AS now

的 localtime.statement() 函数使用语句时钟创建并返回当前的 `LOCAL TIME` 瞬时值。

RETURN localtime.transaction() AS now

的 localtime.transaction() 函数使用事务时钟返回当前的 `LOCAL TIME` 瞬时值。

WITH time({hour: 12, minute: 31, second: 14, nanosecond: 645876123, timezone: '-01:00'}) AS t
RETURN
  localtime.truncate('day', t) AS truncDay,
  localtime.truncate('hour', t) AS truncHour,
  localtime.truncate('minute', t, {millisecond: 2}) AS truncMinute,
  localtime.truncate('second', t) AS truncSecond,
  localtime.truncate('millisecond', t) AS truncMillisecond,
  localtime.truncate('microsecond', t) AS truncMicrosecond

的 localtime.truncate() 函数使用指定的单位将给定的时间值截断为 `LOCAL TIME` 瞬时值。

RETURN time() AS currentTime

的 time() 函数创建一个 `ZONED TIME` 瞬时值。

RETURN time.realtime() AS currentTime

的 time.realtime() 函数使用实时时钟返回当前的 `ZONED TIME` 瞬时值。

RETURN time.statement() AS currentTime

的 time.statement() 函数使用语句时钟返回当前的 `ZONED TIME` 瞬时值。

RETURN time.transaction() AS currentTime

的 time.transaction() 函数使用事务时钟返回当前的 `ZONED TIME` 瞬时值。

WITH time({hour: 12, minute: 31, second: 14, nanosecond: 645876123, timezone: '-01:00'}) AS t
RETURN
  time.truncate('day', t) AS truncDay,
  time.truncate('hour', t) AS truncHour,
  time.truncate('minute', t) AS truncMinute,
  time.truncate('second', t) AS truncSecond,
  time.truncate('millisecond', t, {nanosecond: 2}) AS truncMillisecond,
  time.truncate('microsecond', t) AS truncMicrosecond

的 time.truncate() 函数使用指定的单位将给定的时间值截断为 `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`，以获取与 `query` 参数给定向量相似的 `10` 个评论的邻域。

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 ()-[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`。如果创建的带有该标签的节点具有不同 Cypher 类型的 `name` 属性，则写入操作将失败。

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

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

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 ()-[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` 为前缀的数据库名称保留供内部使用。

数据库名称可以包含点 (`.`)，无需用反引号引用，尽管此行为已弃用，因为它在寻址复合数据库时可能会引入歧义。将数据库命名为 `foo.bar.baz` 是有效的，但已弃用。 `` `foo.bar.baz` `` 是有效的。

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` 的复合数据库中，为名为 `database-name` 的数据库创建一个名为 `alias-in-composite-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 *

以通用 Cypher 命令形式列出分配给每个指定用户（可以指定多个用户，用逗号 `n1, n2, n3` 分隔）的所有权限，例如 `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

以 Cypher 命令形式列出分配给每个指定角色（可以指定多个角色，用逗号 `r1, r2, r3` 分隔）的所有权限，例如 `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` 权限。当 `immutable` 与 `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`）角色给用户 - （`GRANT ASSIGN ROLE`）。

  • 允许从用户移除（`REVOKE`）角色 - （`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`）角色给用户 - （`GRANT ASSIGN ROLE`）。

  • 允许从用户移除（`REVOKE`）角色 - （`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

授予指定角色管理 Neo4j DBMS 权限的 `PRIVILEGE MANAGEMENT` 权限。

  • 允许为角色分配（`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` 权限。

© . All rights reserved.