Neo4j Cypher 完整语法参考手册

基于 Neo4j 官方 Cypher Manual 文档整理
最后更新：2026-04-14

1. 查询子句 (Clauses)

1.1 MATCH - 模式匹配

语法：

cypher

MATCH (pattern) [WHERE predicate]

示例：

cypher

// 基本匹配
MATCH (p:Person {name: 'Alice'})-[:FRIENDS_WITH]->(f)
RETURN p.name, f.name

// 多模式匹配
MATCH (p:Person)-[:ACTED_IN]->(m:Movie)
WHERE p.name = 'Charlie Sheen'
RETURN m.title AS movieTitle

1.2 OPTIONAL MATCH - 可选匹配

语法：

cypher

OPTIONAL MATCH (pattern)

说明： 当模式不匹配时不会过滤结果，而是返回 null。

示例：

cypher

MATCH (p:Person {name: 'Alice'})
OPTIONAL MATCH (p)-[r:WORKS_AT]->(c:Company)
RETURN p.name, c.name

1.3 MERGE - 合并（存在则匹配，不存在则创建）

语法：

cypher

MERGE (pattern)
[ON CREATE SET properties]
[ON MATCH SET properties]

示例：

cypher

MERGE (p:Person {name: 'Bob'})
ON CREATE SET p.created = timestamp()
ON MATCH SET p.lastSeen = timestamp()
RETURN p.name, p.created, p.lastSeen

关系 MERGE：

cypher

MATCH (charlie:Person {name: 'Charlie Sheen'}),
      (movie:Movie {title: 'Wall Street'})
MERGE (charlie)-[r:ACTED_IN]->(movie)
RETURN charlie.name, type(r), movie.title

1.4 CREATE - 创建节点/关系

语法：

cypher

CREATE (n:Label {prop: value})
CREATE (n)-[:REL_TYPE]->(m)

示例：

cypher

CREATE (a:Actor {name: 'Tom Hanks'})
CREATE (m:Movie {title: 'Forrest Gump'})
CREATE (a)-[:ACTED_IN {role: 'Forrest', year: 1994}]->(m)

1.5 SET - 更新属性

语法：

cypher

SET n.prop = value
SET n += {prop1: value1, prop2: value2}
SET n:NewLabel

示例：

cypher

MATCH (p:Person {name: 'Alice'})
SET p.age = 30, p.city = 'Beijing'
SET p:VIP
SET p += {department: 'Engineering', level: 5}

1.6 DELETE - 删除节点/关系

语法：

cypher

DELETE node_or_relationship
DETACH DELETE node  // 先删除所有关联关系再删除节点

示例：

cypher

// 删除关系
MATCH (p:Person)-[r:KNOWS]->(f)
WHERE r.since < 2000
DELETE r

// 删除节点及其所有关系
MATCH (p:Person {name: 'TestUser'})
DETACH DELETE p

1.7 REMOVE - 移除标签/属性

语法：

cypher

REMOVE n:Label
REMOVE n.property

示例：

cypher

MATCH (p:Person {name: 'Alice'})
REMOVE p:VIP
REMOVE p.tempProperty

1.8 WHERE - 过滤条件

语法：

cypher

WHERE predicate

支持的谓词：

谓词	说明	示例
`=`	等于	`n.prop = value`
`<>`	不等于	`n.prop <> value`
`<`, `>`, `<=`, `>=`	比较	`n.age > 18`
`IS NULL`	空值检查	`n.email IS NULL`
`IS NOT NULL`	非空检查	`n.name IS NOT NULL`
`IN`	成员检查	`n.status IN ['active', 'pending']`
`STARTS WITH`	前缀匹配	`n.name STARTS WITH 'A'`
`ENDS WITH`	后缀匹配	`n.email ENDS WITH '@gmail.com'`
`CONTAINS`	包含匹配	`n.bio CONTAINS 'developer'`
`=~`	正则表达式	`n.code =~ '^[A-Z]{3}$'`
`EXISTS`	存在性检查	`EXISTS {MATCH (n)-[:KNOWS]->()}`

组合谓词：

cypher

WHERE n.age > 18 AND n.country = 'China'
WHERE n.status = 'active' OR n.status = 'pending'
WHERE NOT n.banned = true

谓词函数：

cypher

// all() - 所有元素满足条件
WHERE all(x IN n.tags WHERE x.size > 0)

// any() - 至少一个元素满足条件
WHERE any(x IN n.tags WHERE x = 'vip')

// none() - 没有元素满足条件
WHERE none(x IN n.tags WHERE x = 'banned')

// single() - 恰好一个元素满足条件
WHERE single(x IN n.roles WHERE x = 'admin')

1.9 RETURN - 返回结果

语法：

cypher

RETURN expression [AS alias]
RETURN *  // 返回所有变量

示例：

cypher

MATCH (p:Person)
RETURN p.name AS name, p.age AS age

RETURN *

1.10 ORDER BY - 排序

语法：

cypher

ORDER BY expression [ASC | DESC] [NULLS FIRST | NULLS LAST]

示例：

cypher

MATCH (p:Person)
ORDER BY p.age DESC, p.name ASC
RETURN p.name, p.age

1.11 SKIP & LIMIT - 分页

语法：

cypher

SKIP n
LIMIT n

示例：

cypher

MATCH (p:Person)
ORDER BY p.name
SKIP 10
LIMIT 20
RETURN p.name

1.12 WITH - 传递数据/中间处理

语法：

cypher

WITH expression AS alias
WITH aggregation(expression) AS alias
WITH DISTINCT expression

示例：

cypher

// 传递和转换数据
MATCH (p:Person)-[:FRIENDS_WITH]->(f)
WITH p, count(f) AS friendCount
WHERE friendCount > 5
RETURN p.name, friendCount

// 分组聚合
MATCH (m:Movie)<-[:ACTED_IN]-(a:Actor)
RETURN m.title, collect(a.name) AS actors

1.13 UNWIND - 展开列表

语法：

cypher

UNWIND list AS variable

示例：

cypher

// 基本展开
UNWIND [1, 2, 3] AS x
RETURN x

// 创建多个节点
UNWIND ['Alice', 'Bob', 'Charlie'] AS name
CREATE (p:Person {name: name})
RETURN p

// 去重
WITH [1, 1, 2, 2] AS coll
UNWIND coll AS x
WITH DISTINCT x
RETURN collect(x) AS uniqueValues

1.14 FOREACH - 循环更新

语法：

cypher

FOREACH (variable IN list | update_statements)

说明： 主要用于批量更新操作，不能用于读取数据。

示例：

cypher

MATCH (p:Person {name: 'Alice'})
FOREACH (tag IN ['developer', 'engineer', 'tech'] | 
  CREATE (t:Tag {name: tag})-[:TAGGED]->(p))

1.15 CALL - 调用过程/函数

语法：

cypher

CALL procedure_name(parameters)
[YIELD column_names]

示例：

cypher

// 获取组件信息
CALL dbms.components()
YIELD name, versions
RETURN name, versions[0]

// 获取所有标签
CALL db.labels() YIELD label
RETURN label ORDER BY label

// 执行自定义过程
CALL apoc.load.json('https://api.example.com/data') YIELD value

1.16 UNION / INTERSECT / EXCEPT - 集合操作

语法：

cypher

RETURN ...
UNION [ALL]
RETURN ...

示例：

cypher

MATCH (p:Person {name: 'Alice'})-[:FRIENDS_WITH]->(f)
RETURN f.name
UNION
MATCH (p:Person {name: 'Bob'})-[:FRIENDS_WITH]->(f)
RETURN f.name

1.17 LOAD CSV - 加载 CSV 数据

语法：

cypher

LOAD CSV [WITH HEADERS] FROM 'url' AS row
[SELECT ... | ...]

示例：

cypher

// 基本加载
LOAD CSV WITH HEADERS FROM 'file:///people.csv' AS row
CREATE (:Person {name: row.name, age: toInteger(row.age)})

// 带 MERGE 的加载
LOAD CSV WITH HEADERS FROM 'file:///data.csv' AS row
MERGE (p:Person {id: row.id})
SET p.name = row.name, p.email = row.email

1.18 USING PERIODIC COMMIT - 批量导入优化

语法：

cypher

USING PERIODIC COMMIT n
LOAD CSV ...

示例：

cypher

USING PERIODIC COMMIT 1000
LOAD CSV WITH HEADERS FROM 'file:///large_dataset.csv' AS row
CREATE (:Entity {id: row.id, data: row.data})

1.19 事务控制

语法：

cypher

BEGIN
COMMIT
ROLLBACK

查看事务：

cypher

SHOW TRANSACTIONS
SHOW TRANSACTIONS YIELD *

终止事务：

cypher

TERMINATE TRANSACTION transactionId

1.20 EXPLAIN / PROFILE - 查询分析

语法：

cypher

EXPLAIN query  // 查看执行计划（不执行）
PROFILE query  // 执行并分析性能

示例：

cypher

EXPLAIN MATCH (n:Person) WHERE n.name = 'Alice' RETURN n

PROFILE MATCH (n) RETURN count(n)

2. 模式语法 (Patterns)

2.1 节点模式

模式	说明	示例
`()`	任意节点	`MATCH ()`
`(n)`	绑定到变量	`MATCH (n)`
`(:Label)`	带标签的节点	`MATCH (:Person)`
`(n:Label)`	绑定并带标签	`MATCH (n:Person)`
`(n:L1:L2)`	多标签	`MATCH (n:Person:VIP)`
`(n {prop: v})`	属性模式	`MATCH (n {name: 'Alice'})`
`(n:Label {k:v})`	标签 + 属性	`MATCH (n:Person {age: 30})`

2.2 关系模式

模式	说明	示例
`[]`	任意关系	`-[]-`
`[r]`	绑定关系	`-[r]-`
`[:TYPE]`	指定类型	`-[:KNOWS]->`
`[r:TYPE]`	绑定 + 类型	`-[r:FRIENDS_WITH]->`
`()-[:T]->()`	单向（出度）	`(a)-[:LOVES]->(b)`
`()<-[T:]-( )`	单向（入度）	`(a)<-[:LOVED_BY]-(b)`
`()-[:T]-()`	双向	`(a)-[:KNOWS]-(b)`
`[{k:v}]`	带属性	`-[{since: 2020}]->`

2.3 路径模式

模式	说明	示例
`-[]->()`	任意长度	`()-[*]->()`
`-*->()`	0 到无穷	`()-[*0..]->()`
`-*2..5->()`	2 到 5 跳	`()-[:KNOWS*2..5]->()`
`-*3->()`	恰好 3 跳	`()-[:FRIENDS*3]->()`
`-*..5->()`	0 到 5 跳	`()-[*..5]->()`

复合类型路径：

cypher

// 多种关系类型
()-[:KNOWS|MEETS*2..5]->()

// 带属性的变长路径
()-[r:KNOWS* WHERE r.since < 2010]->{1,4}()

2.4 列表推导式 (List Comprehension)

语法：

cypher

[variable IN list | expression]
[variable IN list WHERE predicate | expression]

示例：

cypher

// 基本推导
RETURN [x IN range(1, 5) | x * x]  // [1, 4, 9, 16, 25]

// 带过滤
MATCH (p:Person {name: 'Alice'})
RETURN [(f:Person)-[:FRIENDS_WITH]->(p) WHERE f.age > 30 | f.name]

// 路径节点提取
MATCH p = (a)-[:KNOWS*2]->(b)
RETURN [n IN nodes(p) | n.name]

2.5 模式推导式 (Pattern Comprehension)

语法：

cypher

[(pattern) | expression]
[(pattern) WHERE predicate | expression]

示例：

cypher

MATCH (alice:Person {name: 'Alice'})
RETURN [(alice)-[:FRIENDS_WITH]->(friend) | friend.name] AS friends

3. 内置函数 (Built-in Functions)

3.1 List 函数

函数	说明	示例
`head(list)`	获取第一个元素	`head([1,2,3])` → 1
`last(list)`	获取最后一个元素	`last([1,2,3])` → 3
`tail(list)`	除第一个外的所有元素	`tail([1,2,3])` → [2,3]
`size(list)`	列表长度	`size([1,2,3])` → 3
`range(start, end[, step])`	生成数字列表	`range(1, 5)` → [1,2,3,4,5]
`reverse(list)`	反转列表	`reverse([1,2,3])` → [3,2,1]
`sort(list)`	排序列表	`sort([3,1,2])` → [1,2,3]
`filter(x IN list WHERE p)`	过滤列表	`filter(x IN [1,2,3] WHERE x > 1)`
`extract(x IN list \| expr)`	映射列表	`extract(x IN [1,2,3] \| x * 2)`
`reduce(r = init, x IN list \| e)`	归约列表	`reduce(s=0, x IN [1,2,3] \| s+x)`
`collect(expr)`	聚合为列表	`collect(n.name)`
`distinct(expr)`	去重	`collect(distinct n.label)`
`any(x IN list WHERE p)`	存在满足条件的元素	`any(x IN [1,2,3] WHERE x > 2)`
`all(x IN list WHERE p)`	所有元素满足条件	`all(x IN [2,3,4] WHERE x > 1)`
`none(x IN list WHERE p)`	没有元素满足条件	`none(x IN [1,2,3] WHERE x > 10)`
`single(x IN list WHERE p)`	恰好一个元素满足	`single(x IN [1,2,3] WHERE x = 2)`

详细示例：

cypher

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

// filter
RETURN filter(x IN [1, 2, 3, 4, 5] WHERE x % 2 = 0)  // [2, 4]

// extract (等同于列表推导)
RETURN extract(x IN [1, 2, 3] | x * 10)  // [10, 20, 30]

// reduce
RETURN reduce(total = 0, x IN [1, 2, 3, 4, 5] | total + x)  // 15

// 连接字符串
WITH ['Neo', '4j', 'Rocks'] AS words
RETURN reduce(acc = '', word IN words | acc + word)  // "Neo4jRocks"

3.2 String 函数

函数	说明	示例
`toString(value)`	转换为字符串	`toString(123)` → '123'
`split(text, delimiter)`	分割字符串	`split('a,b,c', ',')`
`trim(text)`	去除首尾空格	`trim(' abc ')` → 'abc'
`toUpper(text)`	转大写	`toUpper('abc')` → 'ABC'
`toLower(text)`	转小写	`toLower('ABC')` → 'abc'
`substring(text, start[, len])`	截取子串	`substring('hello', 1, 3)` → 'ell'
`contains(text, sub)`	包含检查	`contains('hello', 'ell')`
`startsWith(text, prefix)`	前缀检查	`startsWith('hello', 'he')`
`endsWith(text, suffix)`	后缀检查	`endsWith('hello', 'lo')`
`left(text, n)`	左侧 n 个字符	`left('hello', 2)` → 'he'
`right(text, n)`	右侧 n 个字符	`right('hello', 2)` → 'lo'
`replace(text, from, to)`	替换字符串	`replace('hello', 'l', 'x')` → 'hexxo'
`toStringList(list)`	列表转字符串列表	`toStringList([1, 2, true])`

示例：

cypher

RETURN
  toString(11.5),
  toString(true),
  toString(date({year: 1984, month: 10, day: 11})) AS dateString,
  split('one,two,three', ',') AS parts,
  trim('  hello world  '),
  substring('hello world', 0, 5)

3.3 Numeric 函数

函数	说明	示例
`abs(number)`	绝对值	`abs(-5)` → 5
`ceil(number)`	向上取整	`ceil(3.2)` → 4
`floor(number)`	向下取整	`floor(3.8)` → 3
`round(number)`	四舍五入	`round(3.5)` → 4
`sqrt(number)`	平方根	`sqrt(16)` → 4
`log(number)`	自然对数	`log(e)` → 1
`exp(number)`	指数 e^n	`exp(2)` → 7.389
`pow(base, exp)`	幂运算	`pow(2, 10)` → 1024
`rand()`	随机数 [0,1)	`rand()`
`min(value)`	最小值（聚合）	`min(n.age)`
`max(value)`	最大值（聚合）	`max(n.score)`
`sum(value)`	求和（聚合）	`sum(n.amount)`
`avg(value)`	平均值（聚合）	`avg(n.rating)`
`count(*)`	计数（聚合）	`count(*)`
`stDev(value)`	样本标准差	`stDev(n.score)`
`stDevP(value)`	总体标准差	`stDevP(n.score)`
`percentileCont(value, p)`	连续百分位	`percentileCont(n.score, 95)`
`percentileDisc(value, p)`	离散百分位	`percentileDisc(n.score, 50)`

示例：

cypher

MATCH (p:Person)
RETURN
  count(p) AS total,
  avg(p.age) AS averageAge,
  min(p.age) AS youngest,
  max(p.age) AS oldest,
  stDev(p.age) AS ageStdDev,
  percentileCont(p.age, 90) AS ninetyPercentile

3.4 Map 函数

函数	说明	示例
`keys(map)`	获取所有键	`keys({a:1, b:2})` → ['a','b']
`entries(map)`	获取键值对列表	`entries({a:1})` → [{key:'a', value:1}]
`values(map)`	获取所有值	`values({a:1, b:2})` → [1,2]

访问方式：

cypher

// 点访问
MATCH (n:Person {name: 'Alice'})
RETURN n.age, n.city

// 括号访问（动态键）
WITH {name: 'Alice', age: 30} AS person
RETURN person['name'], person.age

创建 Map：

cypher

RETURN {name: 'Alice', age: 30, tags: ['dev', 'tech']} AS person

3.5 Date/Time/Duration 函数

创建时间对象：

cypher

// 日期
date()                                    // 当前日期
date({year: 2024, month: 1, day: 15})     // 指定日期
date('2024-01-15')                        // 字符串解析

// 时间
time()                                    // 当前时间
time({hour: 14, minute: 30, second: 0})   // 指定时间

// 日期时间
datetime()                                // 当前日期时间
datetime({year: 2024, month: 1, day: 15, hour: 14, minute: 30})

// 持续时间
duration({days: 1, hours: 2, minutes: 30})
duration("P1DT2H30M")                     // ISO-8601 格式
duration.between(date1, date2)            // 计算两个时间点之间的持续时间

// 时间戳
timestamp()                               // 当前时间戳（毫秒）

时间函数：

函数	说明
`date()`	当前日期
`time()`	当前时间
`datetime()`	当前日期时间
`localDateTime()`	本地日期时间
`utcDateTime()`	UTC 日期时间
`timestamp()`	当前时间戳
`duration()`	创建持续时间
`duration.between(d1, d2)`	计算持续时间
`duration.inDays(d1, d2)`	天数差
`duration.inMonths(d1, d2)`	月数差
`duration.inSeconds(d1, d2)`	秒数差

时间属性访问：

cypher

WITH datetime() AS dt
RETURN
  dt.year,
  dt.month,
  dt.day,
  dt.hour,
  dt.minute,
  dt.second,
  dt.dayOfWeek,      // 0=Sunday
  dt.dayOfYear,
  dt.weekYear,
  dt.quarter,
  dt.timezone

3.6 Node/Relationship 函数

函数	说明	示例
`id(node)`	内部 ID	`id(n)` → 12345
`labels(node)`	标签列表	`labels(n)` → ['Person','VIP']
`properties(node)`	属性 Map	`properties(n)`
`type(rel)`	关系类型	`type(r)` → 'FRIENDS_WITH'
`startNode(rel)`	起始节点	`startNode(r)`
`endNode(rel)`	结束节点	`endNode(r)`
`relationships(node)`	所有关联关系	`relationships(n)`
`neighbors(node)`	相邻节点	`neighbors(n)`

示例：

cypher

MATCH (n:Person {name: 'Alice'})
RETURN
  id(n) AS nodeId,
  labels(n) AS nodeLabels,
  properties(n) AS nodeProps,
  size(relationships(n)) AS relationshipCount

关系方向：

cypher

MATCH (x:Developer)-[r]-()
RETURN
  startNode(r) AS fromNode,
  endNode(r) AS toNode,
  type(r) AS relType

3.7 Path 函数

函数	说明	示例
`nodes(path)`	路径中所有节点	`nodes(p)`
`relationships(path)`	路径中所有关系	`relationships(p)`
`length(path)`	路径长度（关系数）	`length(p)`

示例：

cypher

MATCH p = (a:Person {name: 'Alice'})-[:KNOWS*1..3]-(b)
RETURN
  length(p) AS pathLength,
  [n IN nodes(p) | n.name] AS nodeNames,
  [r IN relationships(p) | type(r)] AS relTypes

3.8 Graph 算法函数

函数	说明
`shortestPath((a)-[*]->(b))`	最短路径
`allShortestPaths((a)-[*]->(b))`	所有最短路径
`allSimplePaths((a)-[*..n]->(b))`	所有简单路径

示例：

cypher

MATCH p = shortestPath(
  (a:Person {name: 'Alice'})-[:KNOWS*]-(b:Person {name: 'Bob'})
)
RETURN p

MATCH p = allShortestPaths(
  (a:City {name: 'Beijing'})-[:CONNECTED_TO*]-(b:City {name: 'Shanghai'})
)
RETURN length(p) AS distance, p

3.9 Predicate 函数

函数	语法	说明
`exists(pattern)`	`EXISTS {MATCH (n)}`	模式是否存在
`isEmpty(input)`	`isEmpty(list/map/string)`	是否为空
`all(v IN list WHERE p)`	-	所有元素满足条件
`any(v IN list WHERE p)`	-	至少一个元素满足
`none(v IN list WHERE p)`	-	没有元素满足
`single(v IN list WHERE p)`	-	恰好一个元素满足

示例：

cypher

// exists
MATCH (p:Person {name: 'Alice'})
WHERE EXISTS {
  MATCH (p)-[:WORKS_AT]->(:Company {name: 'Google'})
}
RETURN p.name

// isEmpty
WHERE isEmpty(n.tags)
WHERE NOT isEmpty(n.history)

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

3.10 Spatial 函数

cypher

// 创建点
point({x: 1, y: 2})                          // 2D 点
point({x: 1, y: 2, z: 3})                    // 3D 点
point({latitude: 39.9, longitude: 116.4})    // 地理位置点

// 距离计算
distance(point1, point2)

// 点属性
p.x, p.y, p.z, p.latitude, p.longitude, p.height, p CRS

3.11 Database 函数

函数	说明
`dbms.components()`	显示组件信息
`dbms.listModules()`	列出已安装模块
`version()`	Neo4j 版本
`labelID(label)`	标签的内部 ID
`relationshipTypeID(type)`	关系类型的内部 ID
`propertyKeyID(key)`	属性键的内部 ID

4. 架构管理 (Schema Management)

4.1 创建索引

范围索引（默认）：

cypher

CREATE INDEX FOR (n:Label) ON (n.property)
CREATE INDEX IF NOT EXISTS indexName FOR (n:Person) ON (n.email)

文本索引：

cypher

CREATE TEXT INDEX postTitleIndex FOR (p:Post) ON (p.title)
CREATE TEXT INDEX commentTextIndex FOR ()-[:COMMENTED]-() ON (r.text)

全文索引：

cypher

CREATE FULLTEXT INDEX personSearch FOR (p:Person)
ON EACH [p.name, p.bio, p.email]

// 带配置选项
CREATE FULLTEXT INDEX namesAndTeams FOR (n:Employee|Manager)
ON EACH [n.name, n.team]
OPTIONS {
  indexConfig: {
    `fulltext.analyzer`: 'standard-no-stop-words',
    `fulltext.eventually_consistent`: false
  }
}

向量索引：

cypher

CREATE VECTOR INDEX movieEmbeddings FOR (m:Movie)
ON m.embedding
OPTIONS {
  indexConfig: {
    `vector.dimensions`: 1536,
    `vector.similarity_function`: 'cosine'
  }
}

// 多标签向量索引
CREATE VECTOR INDEX multiLabel FOR (n:Label1|Label2)
ON n.embedding

点索引（空间）：

cypher

CREATE INDEX locationIndex FOR (l:Location) ON (l.location)

4.2 创建约束

唯一性约束：

cypher

CREATE CONSTRAINT FOR (p:Person) REQUIRE p.email IS UNIQUE

存在性约束：

cypher

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

类型约束：

cypher

CREATE CONSTRAINT FOR (p:Person) REQUIRE p.age :: INT
CREATE CONSTRAINT FOR (p:Person) REQUIRE p.name :: STRING

主键约束（唯一性 + 存在性）：

cypher

CREATE CONSTRAINT FOR (p:Person) REQUIRE p.id IS KEY

4.3 查看架构

cypher

SHOW INDEXES
SHOW INDEXES YIELD *
SHOW CONSTRAINTS
SHOW CONSTRAINTS YIELD *
SHOW LABELS
SHOW RELATIONSHIP TYPES
SHOW FUNCTIONS
SHOW FUNCTIONS YIELD *
SHOW PROCEDURES
SHOW PROCEDURES YIELD *
SHOW DATABASES
SHOW DATABASES YIELD *

4.4 删除索引/约束

cypher

DROP INDEX indexName
DROP CONSTRAINT constraintName

示例：

cypher

DROP INDEX personEmailIndex
DROP CONSTRAINT person_name_not_null

4.5 索引使用示例

cypher

// 范围查询（使用范围索引）
MATCH (p:Person)
WHERE p.name = 'Alice'
RETURN p

// 文本搜索（使用全文索引）
CALL db.index.fulltext.queryNodes('personSearch', 'Alice developer',
  {limit: 10})
YIELD node, score
RETURN node.name, score
ORDER BY score DESC

// 向量相似性搜索
MATCH (m:Movie)
WHERE elementId(m) IN vector.similarity.topK(
  'movieEmbeddings',
  m.embedding,
  [0.1, 0.2, 0.3],
  10
)
RETURN m.title

5. 数据库管理命令

5.1 数据库操作

cypher

// 创建数据库
CREATE DATABASE myDatabase
CREATE DATABASE myDatabase IF NOT EXISTS
CREATE DATABASE myDatabase WAIT
CREATE DATABASE myDatabase TIMEOUT 5 m

// 删除数据库
DROP DATABASE myDatabase
DROP DATABASE myDatabase IF EXISTS

// 重建数据库
REBUILD DATABASE myDatabase

// 验证数据库
VALIDATE DATABASE myDatabase
VALIDATE DATABASE myDatabase FULLSCAN

// 失败恢复
FAILOVER DATABASE myDatabase

5.2 用户管理

cypher

// 创建用户
CREATE USER username IDENTIFIED BY 'password'
CREATE USER username IDENTIFIED BY PASSWORD 'hash'

// 修改用户
ALTER USER username SET PASSWORD 'newPassword'
ALTER USER username SET PASSWORD SET KEY 'key'
ALTER USER username SET STATUS {ACTIVE | INACTIVE}

// 删除用户
DROP USER username

// 设置角色
GRANT ROLE roleName TO username
REVOKE ROLE roleName FROM username

// 查看用户
SHOW USERS
SHOW ROLES

5.3 权限管理

cypher

// 授予权限
GRANT READ, TRAVERSE ON GRAPH db.* TO role
GRANT WRITE NODE ON LABELS Person TO role
GRANT WRITE RELATIONSHIP ON RELATIONSHIP TYPES KNOWS TO role

// 撤销权限
REVOKE ALL ON GRAPH db.* FROM role

// 查看权限
SHOW PRIVILEGES
SHOW MY PRIVILEGES

5.4 备份与恢复

cypher

// 全量备份
CALL dbms.backup.full()

// 增量备份
CALL dbms.backup.incremental()

// 查看备份状态
CALL dbms.backup.list()

6. 实用技巧

6.1 参数化查询

cypher

// 防止注入攻击，提高性能
MATCH (p:Person)
WHERE p.name = $name AND p.age > $minAge
RETURN p
// 参数：{"name": "Alice", "minAge": 18}

6.2 调试技巧

cypher

// 查看执行计划
EXPLAIN MATCH (n:Person) WHERE n.name = 'Alice' RETURN n

// 执行并分析
PROFILE MATCH (n) RETURN count(n)

// 查看使用了哪些索引
CALL db.indexes()

6.3 性能优化

cypher

// 使用索引
CREATE INDEX FOR (p:Person) ON (p.email)

// 避免笛卡尔积
MATCH (p:Person {name: 'Alice'})
MATCH (f:Person {name: 'Bob'})
// 比先 MATCH 所有再 WHERE 过滤要快

// 使用 WITH 限制中间结果
MATCH (p:Person)-[:FRIENDS_WITH]->(f)
WITH p, collect(f)[..10] AS topFriends  // 只取前 10 个
UNWIND topFriends AS friend
RETURN p.name, friend.name

6.4 常见模式

邻居查询：

cypher

MATCH (p:Person {name: 'Alice'})-[:FRIENDS_WITH*2]-(friend)
RETURN friend.name

共同好友：

cypher

MATCH (a:Person {name: 'Alice'})-[:FRIENDS_WITH]-(mutual)-[:FRIENDS_WITH]-(b:Person {name: 'Bob'})
WHERE mutual <> a AND mutual <> b
RETURN mutual.name, count(*) AS commonFriends

路径查找：

cypher

MATCH p = shortestPath(
  (a:Person {name: 'Alice'})-[:FRIENDS_WITH*]-(b:Person {name: 'Dave'})
)
RETURN p

图统计：

cypher

MATCH (n)
RETURN
  count{n:Person} AS persons,
  count{n:Movie} AS movies,
  count{(}-[:ACTED_IN]->(}) AS actedInRelations

附录：快速参考

A.1 运算符优先级

. (属性访问)
:: (类型断言)
+, - (一元)
*, /, %
+, - (二元)
|| (字符串连接)
=, <>, <, >, <=, >=
IS NULL, IS NOT NULL
STARTS WITH, ENDS WITH, CONTAINS, =~
IN
AND
OR

A.2 数据类型

STRING - 字符串
INTEGER - 整数
FLOAT - 浮点数
BOOLEAN - 布尔值
LIST - 列表
MAP - 地图/对象
DATE - 日期
TIME - 时间
DATETIME - 日期时间
DURATION - 持续时间
POINT - 几何点

A.3 保留字

ALL, AND, AS, ASSERT, AGGREGATE, ASC, ASCENDING, ATTACH,
AUTO, BEGIN, CALL, CASE, COMMIT, CONFLICT, CONSTRAINT,
CREATE, COUNT, DELETE, DESC, DESCENDING, DETACH, DROP,
ELSE, END, EXISTS, FALSE, FETCH, FILTER, FIRST, FOLLOWING,
FOR, FOREACH, FORCE, FROM, FULLTEXT, FUNCTION, GROUP,
HAVING, HEAD, IF, IN, INDEX, INFO, INNER, INSTALL, INTERSECT,
INTO, IS, JOIN, JSON, KEY, LIMIT, LOAD, LOCK, MATCH,
MERGE, NAMED, NONE, NOT, NULL, OF, ON, OPTIONAL, OR, ORDER,
OUTER, OVER, PATH, PLAIN, PRECEDED, PRECEDING, PREFIX,
PROCEDURE, PROPERTIES, PROPERTY, QUERY, RANGE, RELATIONSHIP,
REMOVE, RETURN, REVOKE, RIGHT, ROW, ROWS, SET, SHOW, SINGLE,
SKIP, START, STEP, SUM, TABLE, THEN, TO, TRUE, UNBINDER,
UNION, UNIQUE, UNWIND, USING, VALUE, VALUES, VERSION,
WHEN, WHERE, WINDOW, WITH, XOR, YIELD

本文档基于 Neo4j 官方 Cypher Manual 整理
官方文档：https://neo4j.com/docs/cypher-manual/current/

Neo4j Cypher 完整语法参考手册

目录

1. 查询子句 (Clauses)

1.1 MATCH - 模式匹配

1.2 OPTIONAL MATCH - 可选匹配

1.3 MERGE - 合并（存在则匹配，不存在则创建）

1.4 CREATE - 创建节点/关系

1.5 SET - 更新属性

1.6 DELETE - 删除节点/关系

1.7 REMOVE - 移除标签/属性

1.8 WHERE - 过滤条件

1.9 RETURN - 返回结果

1.10 ORDER BY - 排序

1.11 SKIP & LIMIT - 分页

1.12 WITH - 传递数据/中间处理

1.13 UNWIND - 展开列表

1.14 FOREACH - 循环更新

1.15 CALL - 调用过程/函数

1.16 UNION / INTERSECT / EXCEPT - 集合操作

1.17 LOAD CSV - 加载 CSV 数据

1.18 USING PERIODIC COMMIT - 批量导入优化

1.19 事务控制

1.20 EXPLAIN / PROFILE - 查询分析

2. 模式语法 (Patterns)

2.1 节点模式

2.2 关系模式

2.3 路径模式

2.4 列表推导式 (List Comprehension)

2.5 模式推导式 (Pattern Comprehension)

3. 内置函数 (Built-in Functions)

3.1 List 函数

3.2 String 函数

3.3 Numeric 函数

3.4 Map 函数

3.5 Date/Time/Duration 函数

3.6 Node/Relationship 函数

3.7 Path 函数

3.8 Graph 算法函数

3.9 Predicate 函数

3.10 Spatial 函数

3.11 Database 函数

4. 架构管理 (Schema Management)

4.1 创建索引

4.2 创建约束

4.3 查看架构

4.4 删除索引/约束

4.5 索引使用示例

5. 数据库管理命令

5.1 数据库操作

5.2 用户管理

5.3 权限管理

5.4 备份与恢复

6. 实用技巧

6.1 参数化查询

6.2 调试技巧

6.3 性能优化

6.4 常见模式

附录：快速参考

A.1 运算符优先级

A.2 数据类型

A.3 保留字