---
url: /neo4j/Cypher.md
---
# Neo4j Cypher 完整语法参考手册

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

***

## 目录

1. [查询子句 (Clauses)](#1-查询子句-clauses)
2. [模式语法 (Patterns)](#2-模式语法-patterns)
3. [内置函数 (Built-in Functions)](#3-内置函数-built-in-functions)
4. [架构管理 (Schema Management)](#4-架构管理-schema-management)
5. [数据库管理命令](#5-数据库管理命令)
6. [实用技巧](#6-实用技巧)

***

## 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 运算符优先级

1. `.` (属性访问)
2. `::` (类型断言)
3. `+`, `-` (一元)
4. `*`, `/`, `%`
5. `+`, `-` (二元)
6. `||` (字符串连接)
7. `=`, `<>, <, >, <=, >=`
8. `IS NULL`, `IS NOT NULL`
9. `STARTS WITH`, `ENDS WITH`, `CONTAINS`, `=~`
10. `IN`
11. `AND`
12. `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/*