Neo4j CQL从入门到精通

很高兴为你带来 Neo4j CQL（Cypher Query Language）从入门到精通的全面指南！

Neo4j 是一个领先的图数据库，而 Cypher 是其专门为图数据设计的声明式查询语言。它允许你以一种直观的方式描述图模式，并对其进行创建、查询、更新和删除操作。

为什么选择 Cypher？

• 声明式： 你只需说明你想要什么，而不是如何去做。
• 图模式匹配： 它使用 ASCII 艺术风格的语法来直观地表示图模式（节点和关系）。
• 易学易用： 相对于传统的 SQL，Cypher 对于图结构的数据操作更加自然和高效。
• 高性能： 针对图遍历和复杂关系查询进行了优化。

入门篇：掌握核心概念与基本操作

1. 图数据模型基础

在开始学习 Cypher 之前，理解图数据模型至关重要。Neo4j 中的数据由以下三个核心组件组成：

• 节点 (Nodes)： 代表实体，比如人、公司、电影等。节点可以有零个或多个标签 (Labels)，用于对节点进行分类。
  • 例如：(p:Person) 表示一个带有 Person 标签的节点。
• 关系 (Relationships)： 连接节点，表示实体之间的关联。关系必须有类型 (Types)，并且总是有方向（尽管查询时可以忽略方向）。关系也可以有属性 (Properties)。
  • 例如：-[r:FRIENDS_WITH]-> 表示一个类型为 FRIENDS_WITH 的关系，从左边的节点指向右边的节点。
• 属性 (Properties)： 键值对，用于存储节点和关系的详细信息。键是字符串，值可以是各种数据类型（字符串、数字、布尔、列表等）。
  • 例如：{name: 'Alice', age: 30}

图模式的可视化表示：

• 节点：()
• 关系：--> (有向), -- (无向)
• 节点和关系模式：(node1)-[relationship]->(node2)

neo4j.com

2. 环境搭建

• 下载 Neo4j Desktop 或 Neo4j Community Edition Server： 这是最简单的入门方式。Neo4j Desktop 提供了一个图形界面来管理数据库和执行 Cypher 查询。
  • 下载地址：Neo4j Download
• 启动 Neo4j 数据库： 确保你的数据库实例正在运行。
• 打开 Neo4j Browser： 这是执行 Cypher 查询的主要界面（通常在 http://localhost:7474）。

3. Cypher 基本操作：CRUD

CREATE (创建数据)

用于在图中创建节点、关系和属性。

• 创建节点：

  CREATE (p:Person {name: 'Alice', age: 30})
  RETURN p;
  

  • (p:Person {name: 'Alice', age: 30})：创建了一个变量名为 p、标签为 Person、带有 name 和 age 属性的节点。

• 创建带多个标签的节点：

  CREATE (m:Movie:Action {title: 'The Matrix', released: 1999})
  RETURN m;
  

• 创建关系： 必须连接两个已存在的节点。

  // 先确保节点存在
  MATCH (a:Person {name: 'Alice'}), (m:Movie {title: 'The Matrix'})
  CREATE (a)-[:ACTED_IN {roles: ['Trinity']}]->(m)
  RETURN a, m;
  

  • [:ACTED_IN {roles: ['Trinity']}]：创建了一个类型为 ACTED_IN，带有 roles 属性的关系。

• 同时创建节点和关系：

  CREATE (p:Person {name: 'Bob'})-[:FRIENDS_WITH]->(q:Person {name: 'Charlie'})
  RETURN p, q;
  

MATCH (查找数据)

MATCH 是 Cypher 查询的核心，用于在图中查找符合特定模式的子图。

• 查找所有节点：

  MATCH (n) RETURN n LIMIT 10; // LIMIT 10 限制返回结果为前10条
  

• 查找所有带特定标签的节点：

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

• 查找特定关系：

  MATCH (p:Person)-[r:ACTED_IN]->(m:Movie)
  RETURN p.name, type(r), m.title; // type(r) 返回关系类型
  

• 忽略关系方向：

  MATCH (p:Person)-[r]-(m:Movie) // 使用 -- 表示不关心关系的方向
  RETURN p.name, type(r), m.title;
  

• 查找特定属性值的节点：

  MATCH (p:Person {name: 'Alice'}) RETURN p;
  

RETURN (返回结果)

RETURN 用于指定查询结果中要包含的内容。

• 返回所有匹配项：

  MATCH (p:Person) RETURN p;
  

• 返回特定属性并重命名：

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

• 返回关系类型和关系本身：

  MATCH (p:Person)-[r]->(m:Movie) RETURN type(r) AS RelationshipType, r;
  

SET (更新数据)

SET 用于添加、修改或替换节点和关系的属性，也可以用于添加或移除标签。

• 添加/修改节点属性：

  MATCH (p:Person {name: 'Alice'})
  SET p.city = 'New York', p.age = 31 // 如果属性不存在则添加，存在则修改
  RETURN p;
  

• 添加/修改关系属性：

  MATCH (a:Person {name: 'Alice'})-[r:ACTED_IN]->(m:Movie {title: 'The Matrix'})
  SET r.award = 'Best Actress'
  RETURN r;
  

• 添加标签：

  MATCH (p:Person {name: 'Bob'})
  SET p:Actor // 给节点添加 Actor 标签
  RETURN p;
  

• 移除属性：

  MATCH (p:Person {name: 'Alice'})
  SET p.city = NULL // 将属性值设置为 NULL，相当于移除该属性
  RETURN p;
  

DELETE / DETACH DELETE (删除数据)

• 删除节点（必须没有传入或传出关系）：

  MATCH (p:Person {name: 'Charlie'})
  DELETE p; // 如果 Charlie 有任何关系，此操作会报错
  

• 删除关系：

  MATCH (a:Person {name: 'Alice'})-[r:ACTED_IN]->(m:Movie {title: 'The Matrix'})
  DELETE r;
  

• 删除节点及其所有关系（推荐且常用）：

  MATCH (p:Person {name: 'Bob'})
  DETACH DELETE p; // 这会先删除所有与 Bob 相关的关系，然后再删除 Bob 节点
  

• 删除所有数据（谨慎使用，生产环境禁用！）：

  MATCH (n) DETACH DELETE n;
  

4. WHERE (过滤数据)

WHERE 子句用于过滤 MATCH 语句的结果，类似于 SQL 中的 WHERE。

• 属性过滤：

  MATCH (p:Person)
  WHERE p.age > 25 AND p.city = 'New York'
  RETURN p.name, p.age, p.city;
  

• 存在性检查：

  MATCH (p:Person)
  WHERE EXISTS(p.email) // 查找所有有 email 属性的 Person 节点
  RETURN p.name, p.email;
  

• 关系属性过滤：

  MATCH (p:Person)-[r:KNOWS]->(q:Person)
  WHERE r.since < 2020
  RETURN p.name, q.name, r.since;
  

• 模式过滤：

  MATCH (p:Person {name: 'Alice'})
  WHERE (p)-[:FRIENDS_WITH]->(:Person) // 查找 Alice 必须有 FRIENDS_WITH 关系
  RETURN p.name;
  

进阶篇：提升查询能力与处理复杂场景

1. MERGE (合并数据：创建或匹配)

MERGE 是一个非常强大的子句，它尝试匹配图中已有的模式。如果找到，它将使用该模式；如果没有找到，它将创建该模式。这使得 MERGE 成为处理幂等操作（多次运行结果相同）的理想选择。

• 合并节点：

  MERGE (c:City {name: 'London'}) // 如果 'London' 城市节点不存在就创建，否则就匹配
  RETURN c;
  

• 合并关系：

  MATCH (p:Person {name: 'Alice'}), (c:City {name: 'London'})
  MERGE (p)-[l:LIVES_IN]->(c) // 如果关系不存在就创建，否则就匹配
  RETURN p, l, c;
  

• ON CREATE 和 ON MATCH： 可以在 MERGE 语句中为创建或匹配的情况添加额外的操作。

  MERGE (u:User {email: 'newuser@example.com'})
  ON CREATE SET u.created = timestamp(), u.status = 'active' // 如果是创建新节点，设置创建时间和状态
  ON MATCH SET u.lastLogin = timestamp(), u.loginCount = coalesce(u.loginCount, 0) + 1 // 如果是匹配已有节点，更新登录时间和次数
  RETURN u;
  

  • timestamp()：返回当前时间戳。
  • coalesce(value1, value2)：返回第一个非 NULL 值。

2. UNWIND (展开列表)

UNWIND 子句用于将列表展开为独立的行，这在处理批量数据或将复杂结构分解为更简单的查询时非常有用。

UNWIND ['Apple', 'Banana', 'Orange'] AS fruit
RETURN fruit;
/* 结果：
fruit
-----
Apple
Banana
Orange
*/

• 结合 CREATE 批量创建：

  UNWIND [{name: 'Eve', age: 25}, {name: 'Frank', age: 40}] AS personData
  CREATE (p:Person) SET p = personData
  RETURN p;
  

• 结合 FOREACH 进行批量操作： FOREACH 用于对列表中的每个元素执行操作，通常与 UNWIND 结合使用。

  MATCH (m:Movie {title: 'The Matrix'})
  UNWIND ['Neo', 'Trinity', 'Morpheus'] AS characterName
  MERGE (a:Actor {name: characterName}) // 确保演员节点存在
  MERGE (a)-[:ACTED_IN]->(m) // 创建或匹配关系
  RETURN a.name, m.title;
  

3. WITH (链式查询与中间结果处理)

WITH 子句允许你将查询的不同部分连接起来，传递或过滤中间结果。它类似于 SQL 中的子查询或 CTE (Common Table Expression)，是构建复杂查询的关键。

// 查找年龄大于25的人，并计算他们朋友的数量，然后只返回朋友数量大于等于2的人
MATCH (p:Person)-[:FRIENDS_WITH]->(f:Person)
WHERE p.age > 25
WITH p, COUNT(f) AS friendCount // 将 p 和 friendCount 作为中间结果传递给下一个子句
WHERE friendCount >= 2
RETURN p.name, friendCount;

4. ORDER BY, LIMIT, SKIP (排序、限制、分页)

• ORDER BY： 排序结果。

  MATCH (p:Person) RETURN p.name, p.age ORDER BY p.age DESC, p.name ASC;
  // 按年龄降序排列，年龄相同则按姓名升序排列
  

• LIMIT： 限制返回的行数。

  MATCH (p:Person) RETURN p.name LIMIT 5; // 返回前5个姓名
  

• SKIP： 跳过指定数量的行（用于分页）。

  MATCH (p:Person) RETURN p.name SKIP 5 LIMIT 5; // 跳过前5个，返回接下来的5个（即第6到第10个）
  

5. UNION / UNION ALL (合并查询结果)

• UNION ALL： 合并两个或多个查询的结果集，包括重复项。

  MATCH (p:Person) RETURN p.name AS Name
  UNION ALL
  MATCH (m:Movie) RETURN m.title AS Name;
  

• UNION： 合并两个或多个查询的结果集，并去除重复项。

  MATCH (p:Person) RETURN p.name AS Item
  UNION
  MATCH (m:Movie) RETURN m.title AS Item;
  

  • 注意： UNION 和 UNION ALL 要求合并的查询结果集中的列名和数据类型必须一致。

6. CALL (调用存储过程)

CALL 用于调用 Neo4j 的内置过程或用户自定义的存储过程。

CALL db.labels(); // 查看数据库中所有节点标签
CALL db.relationshipTypes(); // 查看数据库中所有关系类型
CALL db.schema.visualization(); // 可视化数据库模式 (在 Neo4j Browser 中效果明显)

• 注意： 许多 Neo4j APOC 库（Awesome Procedures On Cypher）提供了大量有用的存储过程。要使用它们，你需要将 APOC 插件安装到 Neo4j 实例中。
  • 例如，使用 APOC 导入 CSV：CALL apoc.load.csv('file:///my_data.csv') YIELD map RETURN map;

7. OPTIONAL MATCH (可选匹配)

OPTIONAL MATCH 尝试匹配模式。如果找到模式，它会像 MATCH 一样工作；如果找不到模式，它会返回 null 值，而不会过滤掉整个行。这对于查找“可能存在”的关系或属性非常有用。

MATCH (p:Person)
OPTIONAL MATCH (p)-[:LIVES_IN]->(c:City)
RETURN p.name, c.name AS CityName;
// 这会返回所有 Person，即使他们没有 LIVES_IN 关系，此时 CityName 将为 null。

精通篇：高级技巧、优化与最佳实践

1. 索引与约束 (Indices & Constraints)

索引和约束对于查询性能和数据完整性至关重要。

• 创建节点标签属性索引： 显著提高根据属性查找节点的性能。

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

• 创建节点属性唯一性约束： 确保某个标签的某个属性值是唯一的。这会自动创建索引。

  CREATE CONSTRAINT ON (p:Person) ASSERT p.email IS UNIQUE;
  

• 创建节点标签属性存在性约束： 确保某个标签的某个属性总是存在。

  CREATE CONSTRAINT ON (p:Person) ASSERT EXISTS (p.name);
  

• 创建关系属性存在性约束： 确保某个关系类型的某个属性总是存在。

  CREATE CONSTRAINT ON ()-[r:ACTED_IN]-() ASSERT EXISTS (r.roles);
  

• 查看索引和约束：

  CALL db.indexes();
  CALL db.constraints();
  

2. 路径查找与图算法

Cypher 擅长处理图的路径和遍历。

• 固定长度路径：

  MATCH (p:Person {name: 'Alice'})-[:KNOWS*2]->(friendOfFriend:Person)
  RETURN friendOfFriend.name; // 查找 Alice 的两跳朋友
  

• 可变长度路径：

  MATCH (p:Person {name: 'Alice'})-[*1..3]->(n) // 查找 Alice 的 1 到 3 跳的任何节点
  RETURN DISTINCT n.name;
  

• 最短路径 (使用 GDS 库)： 对于复杂的图算法，Neo4j Graph Data Science (GDS) 库提供了高度优化的实现。

  // 假设你已安装 GDS 插件，并且图已投射到内存中
  MATCH (startNode:Person {name: 'Alice'}), (endNode:Person {name: 'David'})
  CALL gds.shortestPath.dijkstra.stream('myGraph', { // 'myGraph' 是你投射到内存的图名称
      sourceNode: id(startNode),
      targetNode: id(endNode),
      relationshipWeightProperty: 'cost' // 假设关系有 cost 属性作为权重
  })
  YIELD path
  RETURN path;
  

  • 注意： GDS 算法通常需要在图上预先投射 (project) 一个内存图。

3. 性能优化与 EXPLAIN / PROFILE

理解查询的执行计划对于优化性能至关重要。

• EXPLAIN： 显示查询的执行计划，但不会实际执行查询。用于分析查询的预期行为。

  EXPLAIN MATCH (p:Person {name: 'Alice'})-[:ACTED_IN]->(m:Movie) RETURN m.title;
  

• PROFILE： 执行查询并显示执行计划，包括每个操作的实际行数和 DB 命中次数。用于分析查询的实际性能。

  PROFILE MATCH (p:Person {name: 'Alice'})-[:ACTED_IN]->(m:Movie) RETURN m.title;
  

• 优化技巧：

  • 尽早过滤： 使用 WHERE 子句尽可能早地限制匹配结果。
  • 使用索引： 确保你的查询利用了已创建的索引。检查 PROFILE 输出中是否有 NodeIndexSeek 或 RelationshipIndexSeek。
  • 避免全图扫描： 尽量从有标签或属性的节点开始匹配。例如，MATCH (p:Person) 比 MATCH (n) 更高效。
  • 限制返回数据： 只返回你需要的属性，而不是整个节点或关系，避免不必要的数据传输。
  • 理解 WITH： 正确使用 WITH 来分解复杂查询并过滤中间结果，避免笛卡尔积。
  • APOC 库： 考虑使用 APOC 库中提供的更高效的函数和过程，例如批量操作、数据转换等。
  • GDS 库： 对于复杂的图算法（如 PageRank、社区检测、最短路径），使用 GDS 库通常比纯 Cypher 更高效。
  • 避免 ORDER BY 大量数据： ORDER BY 操作在处理大量数据时成本很高。

4. 参数化查询

在应用程序中执行 Cypher 查询时，始终使用参数化查询来防止 CQL 注入攻击并提高性能（数据库可以缓存查询计划）。

// Cypher 查询中的参数占位符
MATCH (p:Person {name: $personName})-[:ACTED_IN]->(m:Movie {title: $movieTitle})
RETURN p, m

• 在你的 Java 应用程序中，使用 Neo4j Driver 传入参数：

  import org.neo4j.driver.Driver;
  import org.neo4j.driver.Session;
  import java.util.Map;
  
  // ... (假设你已经有 Driver 实例)
  try (Session session = driver.session()) {
      Map<String, Object> params = Map.of("personName", "Alice", "movieTitle", "The Matrix");
      String query = "MATCH (p:Person {name: $personName})-[:ACTED_IN]->(m:Movie {title: $movieTitle}) RETURN p, m";
      session.run(query, params)
             .forEach(record -> System.out.println(record.get("p").asNode().get("name") + " acted in " + record.get("m").asNode().get("title")));
  }
  

5. 常见函数

Cypher 提供了多种内置函数来处理字符串、数字、列表、日期时间以及图元素。

• 聚合函数： COUNT(), SUM(), AVG(), MIN(), MAX(), COLLECT()

  MATCH (p:Person)-[:ACTED_IN]->(m:Movie)
  RETURN m.title, COUNT(p) AS ActorsCount;
  

• 列表函数： SIZE(), HEAD(), LAST(), KEYS()

  MATCH (p:Person {name: 'Alice'})
  RETURN SIZE(p.hobbies), KEYS(p);
  

• 字符串函数： TOUPPER(), TOLOWER(), SUBSTRING(), TRIM(), STARTS WITH, ENDS WITH, CONTAINS

  MATCH (m:Movie)
  WHERE m.title STARTS WITH 'The'
  RETURN m.title;
  

• 数值函数： ABS(), CEIL(), FLOOR(), ROUND()

• 路径函数： LENGTH(), NODES(), RELATIONSHIPS()

  MATCH p = (a)-[*]->(b)
  RETURN LENGTH(p) AS pathLength;
  

学习资源推荐

• Neo4j 官方文档 (Cypher Manual)： 这是最权威、最详细的资源，覆盖了所有 Cypher 功能和语法。
  • Neo4j Cypher Manual
• Neo4j GraphAcademy (免费在线课程)： 提供从入门到高级的实践课程，包含大量练习和项目。强烈推荐！
  • Neo4j GraphAcademy
• Tutorialspoint Neo4j CQL 教程： 简洁明了的入门教程，适合快速了解基础概念。
  • Neo4j CQL Introduction - Tutorialspoint
• Neo4j APOC 库文档： 了解强大的扩展功能，如何安装和使用其提供的函数和过程。
  • Neo4j APOC Documentation
• Neo4j GDS 库文档： 学习如何运行各种图算法，如最短路径、中心性算法、社区检测等。
  • Neo4j Graph Data Science Library
• Cypher Cheat Sheet： 速查表，方便快速查找常用语法。
  • Cypher Cheat Sheet

总结

从入门到精通 Cypher 需要不断实践和深入理解图数据模型。从基本的 CRUD 操作开始，逐步掌握 MERGE、WITH、UNWIND 等高级子句，并最终关注索引、查询优化和图算法。Neo4j 提供了丰富的学习资源，多动手实践是掌握 Cypher 的最佳途径。祝你学习顺利！