{"success":true,"data":[{"id":"67f4cf91455186f56d9f412f","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

Neo4j 官方教程（持续更新中）

\n

本教程引用Neo4j官方文档： https://neo4j.com/docs/，内容持续更新中

\n

目录

\n

Neo4j官方教程：第1节，Neo4j是什么\nNeo4j官方教程：第2节，什么是图数据库\nNeo4j官方教程：第3节，图数据库概念\nNeo4j官方教程：第4节，从关系型数据库过渡到图数据库\nNeo4j官方教程：第5节，从NoSQL到图数据库的转型\nNeo4j官方教程：第6节， 什么是 Cypher\nNeo4j官方教程：第7节， Cypher 与 SQL 比较\nNeo4j官方教程：第8节， 模式\nNeo4j官方教程：第9节，实践中的模式\nNeo4j官方教程：第10节，获取正确的结果\nNeo4j官方教程：第11节，更新数据\nNeo4j官方教程：第12节，编写大型语句\nNeo4j官方教程：第13节， Cypher 中的子查询\nNeo4j官方教程：第14节，定义模式\nNeo4j官方教程：第15节，日期、日期时间和持续时间\nNeo4j官方教程：第16节， 如何扩展 Cypher\nNeo4j官方教程：第17节， 导入数据\nNeo4j官方教程：第18节， Cypher 资源\nNeo4j官方教程：第19节， 图数据建模是什么\nNeo4j官方教程：第20节，创建图数据模型\nNeo4j官方教程：第21节，重构图数据模型\nNeo4j官方教程：第22节，数据建模设计\nNeo4j官方教程：第23节，版本控制\nNeo4j官方教程：第24节，从关系型数据模型到图数据模型的建模\nNeo4j官方教程：第25节，图数据建模技巧

\n
","title":"《Neo4j 官方教程中文版》Neo4j首选学习资料（持续更新中）","last_reply_at":"2025-04-08T07:26:09.329Z","good":true,"top":true,"reply_count":0,"visit_count":9195,"create_at":"2025-04-08T07:26:09.329Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"67ad4b328e65137814c5a995","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

官方下载页

\n

下载地址：https://neo4j.com/deployment-center/\n打开后滚动到网页中部，如下位置选择版本下载\n\"image.png\"

\n

Neo4j 2025.01.0 Released 6 February 2025

\n

Neo4j 社区版

\n

Windows 版压缩包

\n

neo4j-community-2025.01.0-windows.zip

\n

Linux / Mac 版压缩包

\n

neo4j-community-2025.01.0-unix.tar.gz

\n

Debian / Ubuntu 版安装包

\n

neo4j_2025.01.0_all.deb

\n

Red Hat Linux 版安装包

\n

neo4j-2025.01.0-1.noarch.rpm

\n

Neo4j桌面安装版 Neo4j Desktop 1.6.1

\n

Windows 版 Neo4j Desktop (exe)

\n

Neo4j-Desktop-Setup-1.6.1.exe

\n

Mac 版 Neo4j Desktop (dmg)

\n

Neo4j-Desktop-1.6.1.dmg

\n
","title":"Neo4j 各个版本安装包下载点","last_reply_at":"2025-02-13T01:30:26.506Z","good":true,"top":true,"reply_count":0,"visit_count":22254,"create_at":"2025-02-13T01:30:26.506Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"64ad026377567df4044c1862","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

NeuroDB是一个内存级图数据库引擎，能够利用Neuro-cypher指令实现对图数据的创建、编辑、检索 以及建立在复杂图算法上的一些高级图应用。官方主页：neurodb.org\n视频介绍：【研发轻量级图数据库引擎：NeuroDB-哔哩哔哩】 https://b23.tv/DkFT60M

\n

NeuroDB的主要特性为：

\n\n

\"image.png\"\nNeuroDB提供友好强大的图可视化界面：NeuroStudio，其实现了可视化数据展示、图数据编辑、图数据建模功能。

\n

特别的，NeuroStudio引入了“图建模”概念实现了 类似 面向对象的 根据模型“派生”图数据的概念，可以在建模中设计 图的节点、关系关联机构，并且可以向关系数据库表结构那样 设计节点或关系上的属性（属性名、属性数据类型、属性数据长度等）\n\"image.png\"

\n
","title":"NeuroDB图数据库引擎 发布，一款全自主研发的轻量级图数据库","last_reply_at":"2023-07-11T07:18:59.653Z","good":true,"top":true,"reply_count":0,"visit_count":5304,"create_at":"2023-07-11T07:18:59.653Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"59b7418c9fe13f5e0a2212c3","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

本社区的技术交流QQ群为：\n1群：547190638 点击加入QQ群

\n

2群：705837093 点击加入QQ群

\n

3群：622711500 点击加入QQ群

\n

加群请回答加群问题（用于防止不良人员加入）\nQQ群内如果没有人及时回答你的问题，请先发到本社区。

\n
","title":"Neo4j 中文社区 技术交流 QQ群，1群：547190638，2群：705837093，3群：511493693","last_reply_at":"2020-07-25T11:05:20.393Z","good":false,"top":true,"reply_count":3,"visit_count":14358,"create_at":"2017-09-12T02:08:12.245Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"6a29248fb46e89224e453e84","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

Conda 简明使用指南

\n

📦 核心概念

\n

Conda = 环境管理器 + 包管理器，一个命令搞定 Python 版本、依赖包、甚至系统库（如 CUDA）。

\n

🚀 常用命令速查\n操作\t命令\n创建环境\tconda create -n 环境名 python=3.10\n激活环境\tconda activate 环境名\n退出环境\tconda deactivate\n安装包\tconda install 包名\n指定渠道安装\tconda install -c 渠道名 包名\n查看所有环境\tconda env list\n删除环境\tconda env remove -n 环境名\n导出环境\tconda env export > environment.yml\n从文件创建环境\tconda env create -f environment.yml

\n

🎯 针对你的项目：完整操作流程

\n
# 1. 创建项目专用环境（命名：securities_qa，Python 3.10）\nconda create -n securities_qa python=3.10\n\n# 2. 激活环境（命令行前出现 (securities_qa) 说明成功）\nconda activate securities_qa\n\n# 3. 安装 faiss-gpu（从 pytorch 渠道）\nconda install -c pytorch faiss-gpu\n\n# 4. 可选：安装 Jupyter（方便调试）\nconda install jupyter\n\n# 5. 退出环境（开发结束后）\nconda deactivate\n

🔄 常用工作流

\n

日常开发流程：

\n
# 每次打开新终端，先激活环境\nconda activate securities_qa\n\n# 然后正常写代码、运行脚本\npython main.py\n\n# 需要新包时，直接用 conda 或 pip（在 conda 环境里都可以）\nconda install pandas\n# 或\npip install langchain\n\n# 用完退出（可选，不退出也没影响）\nconda deactivate\n

查看环境状态：

\n
# 当前激活了哪个环境？\nconda info --envs\n\n# 当前环境装了哪些包？\nconda list\n

删除重建环境（出问题时）：

\n
conda deactivate\nconda env remove -n securities_qa\nconda create -n securities_qa python=3.10\n

💡 关键技巧

\n

激活环境后，pip/uv 装的包也在 conda 环境里，不冲突

\n

conda install 很慢：可换国内源（清华/中科大）加速

\n

不确定包名：conda search 关键词 查找

\n

环境移植：conda env export > environment.yml 分享给队友

\n

📋 你的项目下一步

\n
conda activate securities_qa\nconda install -c pytorch faiss-gpu\nuv pip install langchain langchain-community ollama chromadb\n

然后就可以开始写代码了！

\n
","title":"Conda 简明使用指南","last_reply_at":"2026-06-10T08:47:11.247Z","good":false,"top":false,"reply_count":0,"visit_count":200,"create_at":"2026-06-10T08:47:11.247Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"6a0d3bb270557b690faa5bb5","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

介绍

\n

图数据库厂商Neo4j公司今日发布了Infinigraph，称其为分布式图技术的重大进步。

\n

该公司表示，这一架构允许用户在单一图数据库平台上同时运行操作和分析工作负载，处理规模超过100TB，且无需分割图结构、复制基础设施或影响性能。

\n

经过两年多的开发，Infinigraph解决了事务系统与分析工作负载协调的问题。Neo4j的早期版本需要在单台物理计算机上运行，这意味着组织必须使用提取/传输/加载管道、同步或多个数据库来处理大量数据。

\n

Infinigraph通过使用分片技术解决了这一限制。分片是一种将大型数据集拆分为更小、更易管理片段的数据库技术，可支持数十亿关系和数千个并发查询跨多个处理器执行，同时保持事务场景所需的原子性、一致性、隔离性和持久性（ACID）特性。

\n

该公司可以在多台机器间对图数据进行分片，同时保持其逻辑一致性，实现数据的自动分发和扩展，无需应用程序重写或人工干预。

\n

Neo4j表示，新架构允许客户将数千万文档作为向量直接嵌入图中。这使得欺诈检测、产品知识图谱、长期合规监控和语义搜索等用例能够在更大、更丰富的数据量上进行。

\n

Neo4j技术总裁Sudhir Hasbe表示：“我们现在能够在Neo4j数据库中支持数十亿个向量。这在生命科学领域特别有用，公司需要处理数千万份科学文档进行药物发现。过去，这些文档是孤立的。现在，它们可以直接嵌入到图中。”

\n

四年前，Neo4j通过引入Fabric为新架构奠定了基础，实现了跨机器的联邦图查询，但客户必须自己管理分片。Infinigraph自动化了这一过程，同时保持完整的ACID合规性。

\n

"由于遍历查询的存在，图分片是一个困难的问题，"Hasbe说，“我们通过在一个环境中维护全局索引实现快速路径查询，同时将实际数据分布在多台机器上实现水平扩展来解决这个问题。即使是分布式事务也保持一致和可靠。”

\n

Neo4j还强调了图作为生成式AI中使用的向量数据库的价值。AI训练需要结构化和非结构化数据。该公司在2023年首次添加了向量支持，允许文档以向量嵌入的形式存储。Infinigraph实现了更大规模的存储。

\n

"生成式AI使非结构化数据比以往更有价值，"Hasbe说，“我们看到客户从使用Elastic Store处理向量转向在Neo4j内管理一切。这大大简化了他们的技术栈。”

\n

Infinigraph目前在Neo4j自管理企业版中提供早期访问，更广泛的可用性计划在10月推出。该公司表示，该功能很快将在其AuraDB云原生图平台中提供。

\n

Infinigraph的定价将采用解耦模式，分离计算和存储以提供更大的灵活性。"我们正在将定价模式与现代分布式系统的运行方式保持一致，"Hasbe说，"这允许客户扩展工作负载而不会产生意外成本。"他表示，工作负载较小的客户可能会看到成本较当前支付的费用有所下降。

\n

Q&A

\n

Q1：Infinigraph是什么？它解决了什么问题？

\n

A：Infinigraph是Neo4j公司发布的分布式图技术架构，它解决了事务系统与分析工作负载协调的问题。该架构允许用户在单一图数据库平台上同时运行操作和分析工作负载，处理规模超过100TB，无需分割图结构、复制基础设施或影响性能。

\n

Q2：Infinigraph与之前的Neo4j版本有什么区别？

\n

A：之前的Neo4j版本需要在单台物理计算机上运行，组织必须使用多个数据库来处理大量数据。Infinigraph通过分片技术可以在多台机器间对图数据进行分片，同时保持逻辑一致性，实现数据的自动分发和扩展，无需应用程序重写或人工干预。

\n

Q3：Infinigraph在生成式AI方面有什么优势？

\n

A：Infinigraph能够支持数十亿个向量，可以将数千万文档作为向量直接嵌入图中。这在生命科学等领域特别有用，比如处理数千万份科学文档进行药物发现。生成式AI使非结构化数据更有价值，客户可以在Neo4j内管理一切，大大简化技术栈。

\n
","title":"Neo4j发布Infinigraph架构，统一实时交易与图分析处理","last_reply_at":"2026-05-20T04:42:26.230Z","good":false,"top":false,"reply_count":0,"visit_count":408,"create_at":"2026-05-20T04:42:26.230Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"69fdcc1d70557b690faa5bb3","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

图数据库到底是什么？一篇讲清楚核心原理、应用场景和选型指南

\n

\"微信图片_20260508194705_162_5.jpg\"

\n
\n

当关系型数据库还在「连表查询」时，图数据库已经在走「朋友的朋友的朋友」了

\n
\n

每天都在聊知识图谱、GraphRAG，图数据库这个词你一定不陌生。但你真的搞懂了它是什么、怎么工作、什么时候该用吗？

\n

这篇文章不堆砌术语，从原理到选型，给你一次性讲透。

\n
\n

一、一句话说清楚图数据库

\n

图数据库 = 专门用来存储和处理「关系」的数据库。

\n

它不是存图的（别被名字骗了）。它存的是实体（节点）和实体之间的关系（边），每一个关系都是「一等公民」。

\n

举个例子，在传统数据库里你要查「张三的朋友的朋友是谁」，需要写三四个 JOIN 才能搞定；在图数据库里，你只要说「沿着朋友关系走两步」，它就知道你要什么。

\n
\n

二、核心模型：属性图

\n

图数据库基于图论，最主流的数据模型叫属性图（Property Graph），只有三个概念：

\n

1️⃣ 节点：代表实体。可以是人、公司、文章、商品……任何东西。

\n

2️⃣ 边：代表实体之间的关系。每条边都有方向（A→B）、类型（朋友/属于/购买）和属性。比如：

\n
\n

（小明）—[任职于 {职务：CEO}]→（字节跳动）

\n
\n

3️⃣ 属性：节点和边都可以挂上键值对，存额外信息。

\n

和关系型数据库的最大区别：在 MySQL 里，「关系」是通过外键和 JOIN 连接出来的，查询时实时计算；在图数据库里，「关系」本身就是数据，存的时候就贴身挨着。

\n
\n

三、高性能的秘密：无索引邻接

\n

图数据库快的根本原因，是一个词：无索引邻接（Index-Free Adjacency）。

\n

什么意思？在图数据库里，每个节点都直接存着它所有邻居的「指针」——就像你手机通讯录里直接存了朋友的电话号码，不需要翻黄页查。

\n

当你查「A 的朋友的朋友的朋友」：

\n\n

深度为 3 到 5 层的多跳查询，图数据库比 MySQL 快 几十倍甚至几百倍。

\n
\n

四、图数据库分类一次看懂

\n

别看都叫「图数据库」，内部差异很大。按存储架构分：

\n

原生图数据库

\n\n

多模型数据库

\n\n

分布式图数据库

\n\n

单机/嵌入式

\n\n
\n

五、主流查询语言横向对比

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
语言家族代表产品特点
CypherNeo4j、NebulaGraph声明式，像 SQL，学习曲线平缓
GremlinJanusGraph、Neptune命令式，灵活但复杂
GSQL / nGQLTigerGraph、NebulaGraph接近 SQL，对传统DBA友善
SPARQLStardog、GraphDB语义网标准，适合知识图谱推理
\n

如果你是新手，从 Cypher 入手最友好。它的查询长什么样？比如「找张三朋友推荐的书」：

\n
MATCH (张三:Person)-[:朋友]->(朋友:Person)-[:推荐]->(书:Book)\nRETURN 书.title\n

是不是还挺直观的？

\n
\n

六、图数据库在解决什么问题？

\n

社交网络\n推荐可能认识的人、发现社群结构。关系天然就是图，为什么非要把图装进方形的表里？

\n

知识图谱\n「某公司的CTO之前在哪家公司工作过？」——知识图谱就是属性图，图数据库是最佳底座。

\n

反欺诈与风控\n欺诈团伙往往是隐蔽的关系网络。图数据库能三跳之内揪出关联账户和交易环。

\n

推荐系统\n「你朋友喜欢的东西，你可能也喜欢」——这句话本身就是图的遍历。

\n

供应链与物流\n追踪原材料来源、发现供应链瓶颈。上下游关系天然是图。

\n

IT运维\n服务调用链、故障根因定位。微服务越拆越细，关系越来越复杂，图数据库看得很清楚。

\n
\n

七、主流产品怎么选？

\n

Neo4j

\n\n

NebulaGraph

\n\n

TigerGraph

\n\n

JanusGraph

\n\n

ArangoDB

\n\n
\n

八、总结：什么时候该上图数据库？

\n

✅ 适合用图数据库的场景：

\n\n

❌ 别用图数据库的场景：

\n\n

一句话总结：

\n
\n

如果业务核心是「实体本身」 → 用关系型数据库

\n

如果业务核心是「实体之间的关系」 → 上图数据库

\n
\n
\n

觉得有用？点个「在看」，转发给你的技术团队同事，一起搞清楚图数据库到底值不值得用。

\n

关注本公众号，下一期聊：GraphRAG——图数据库+大模型，能否彻底干掉传统 RAG？

\n
\n

📝 本文参考自腾讯云开发者社区技术文章及多个图数据库产品官方文档整理

\n
","title":"图数据库小白经常问的问题","last_reply_at":"2026-05-08T11:42:21.563Z","good":false,"top":false,"reply_count":0,"visit_count":620,"create_at":"2026-05-08T11:42:21.563Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"69606769243e73b30c0db24b","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

参考官方：https://neo4j.com/docs/operations-manual/5/database-internals/store-formats/

\n

Neo4j 存储格式概述

\n

Neo4j 使用不同的存储格式（store formats）来将图数据持久化到磁盘上，每种格式针对特定的性能、容量和可扩展性需求进行了优化。截至 Neo4j 5.x 版本（2026 年 1 月，5.23 版本已发布），支持的格式包括 block、aligned、standard 和 high_limit。其中，block 格式是 Neo4j 5.22 及以后版本中 Enterprise Edition 新建数据库的推荐默认格式，具有最佳性能（基于块存储和数据内联）。aligned 格式是 Community Edition 和早期 Enterprise Edition 的默认格式。standard 和 high_limit 格式自 Neo4j 5.23 起已被弃用，不推荐用于新数据库，支持将于 2029 年 11 月结束。

\n

这些格式的主要区别在于数据结构、实体容量上限、ID 分配方式、性能表现、磁盘占用以及迁移路径。以下详细说明每种格式，所有信息请以 Neo4j 官方文档（Operations Manual 5 版）的 Store formats 章节 及其子页面内容为准。

\n

1. Block 格式

\n\n

2. Aligned 格式

\n\n

3. Standard 格式

\n\n

4. High-Limit 格式

\n\n

格式对比总结表

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
特性Block 格式Aligned 格式Standard 格式High-Limit 格式
数据结构块存储 + 内联记录 + 对齐基础记录记录 + 高容量设计
最大节点数2⁴⁸（281 万亿）2³⁵（343 亿）2³⁵（343 亿）2⁵⁰（1 万亿亿）
最大关系数无限制2³⁵（343 亿）2³⁵（343 亿）2⁵⁰（1 万亿亿）
最大属性数无限制2³⁶（687 亿）2³⁶（687 亿）2⁵⁰（1 万亿亿）
关系类型数2³⁰（10 亿）2¹⁶（65,536）2¹⁶（65,536）2²⁴（1678 万）
属性键数2³¹（21 亿）2²⁴（1678 万）2²⁴（1678 万）2²⁴（1678 万）
性能最佳（低 I/O、高缓存效率）良好基础略差于 standard
磁盘占用高效中等（对齐开销）最低最高（容量开销）
状态活跃，Enterprise 推荐活跃，Community 默认已弃用（5.23）已弃用（5.23）
可用版本仅 EnterpriseCommunity & EnterpriseCommunity & Enterprise仅 Enterprise
ID 分配物理位置，迁移重分配物理位置，迁移重分配物理位置，迁移重分配物理位置，迁移重分配
可迁移目标N/A（目标格式）到 block 或 high_limit到 aligned、block 或 high_limit仅到 block
\n

附加说明

\n\n
","title":"Neo4j 不同的存储格式（store formats）的差异","last_reply_at":"2026-01-09T02:26:49.382Z","good":false,"top":false,"reply_count":0,"visit_count":1987,"create_at":"2026-01-09T02:26:49.382Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"68f63beca8f5aea0094a7c78","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

图表分析在企业决策中能够发挥极大的价值，而好的图形算法不仅易于使用，执行速度快，而且能够产生强大的结果。Neo4j包含一个不断增长的开放式高性能图形算法库，可以揭示连接数据中的隐藏模式和结构。\n本文将为大家介绍Neo4j中提供的诸多图算法以及它们的功能。使用Neo4j图形算法，用户可以建模并预测复杂的动态特性，例如资源或信息的流动，传染或网络故障传播的途径，以及组的影响和弹性。\n由于Neo4j是将原生图平台中的分析和事务操作结合在一起，用户不仅可以揭示真实世界系统的内在本质，还可以更快地开发和部署基于图形的解决方案，并具有易于使用、简化的工作流程。

\n

遍历和寻路算法

\n

1.广度优先算法(BFS)

\n

做什么：遍历树数据结构，探索最近的邻居和他们的次级邻居。它用于定位连接，是许多其他图算法的前身。\n当树较不平衡或目标更接近起点时，BFS是首选。它也可用于查找节点之间的最短路径或避免深度优先搜索的递归过程。\n如何使用：广度优先搜索可用于定位像BitTorrent等对等网络中的邻居节点，GPS系统可精确定位附近的位置，社交网络服务可在特定距离内查找人员。

\n

2.深度优先算法(DFS)

\n

做什么：遍历树数据结构，通过在回溯之前尽可能探索每个分支。用于深层次的数据，是许多其他图算法的前身。当树较平衡或目标更接近端点时，深度优先搜索是首选。\n如何使用：深度优先算法通常用于游戏模拟，其中每个选择或动作引发另一个操作，从而扩展成可能性的树形图。它将遍历选择树，直到找到最佳解决方案路径(即胜利)。

\n

3.单源最短路径

\n

做什么：计算节点与所有其他节点之间的路径，以及其与所有其他节点的总和值(成本，距离，时间或容量等关系的权重)并得出总和最小。\n如何使用：单源最短路径通常用于自动获取物理位置之间的路线，例如通过Google地图获取驾车路线。在逻辑路由中也很重要，例如电话呼叫路由(最低成本路由)。

\n

4.全源最短路径

\n

做什么：计算包含图中节点之间所有最短路径的最短路径森林(组)。当最短路径被阻塞或变得次优时，切换到新的最短路径，通常用于备用路由。\n如何使用：用于评估备用路由，例如高速公路备份或网络容量。它也是为逻辑路由提供多路径的关键，比如呼叫路由选择。

\n

5.最小生成树(MWST)

\n

做什么：计算与访问树中所有节点相关的最小值(如成本，时间或容量等关系的权重)的路径，用于逼近一些NP难题，如旅行商问题和随机或迭代舍入。\n如何使用：最小生成树广泛用于网络设计：成本最低的逻辑或物理路由，如铺设电缆，最快的垃圾收集路线，供水系统容量，高效电路设计等等。它还可用于滚动优化的实时应用程序，如化学炼油厂的过程或行驶路线修正。\nCentrality Algorithms

\n

6. PageRank

\n

做什么：估计当前节点对其相邻节点的重要性，然后再从其邻居那里获得节点的重要性。一个节点的排名来源于其传递链接的数量和质量。PageRank虽然被谷歌抛弃了，但它还是被广泛认为是检测任何网络中有影响力的节点的常用方式。\n如何使用：PageRank用于评估重要性和影响力，经常的用法是推荐推特账户以及一般的情绪分析。\nPageRank也用于机器学习，以确定最有影响的提取特征。在生物学中，它被用来识别食物网中哪些物种的灭绝会导致物种死亡的最大连锁反应。

\n

7. Degree Centrality

\n

做什么：测量节点(或整个图表)所具有的关系数量，被分为流入和流出两个方向，关系具有指向性。\n如何使用：Degree Centrality着眼于用途的直接连通性，例如评估患者接近病毒或听取信息的近期风险。在社会研究中，可以用来预估人气或者其它情感。

\n

8. Closeness Centrality

\n

做什么：衡量一个节点对其集群内所有邻居的集中程度。假定到所有其他节点的路径都是最短的，那么该节点就能够以最快的速度到达整个组。\n如何使用：Closeness Centrality适用于多种资源、交流和行为分析，尤其是当交互速度显着时。\n在新公共服务中，被用于确定最大可访问性的位置。\n在社交网络分析中，用于找到具有理想社交网络位置的人，以便更快地传播信息。

\n

9. Betweenness Centrality

\n

做什么：测量通过节点的最短路径的数量(首先通过广度优先算法找到)。出现在最短路径上次数最多的节点具有较高的介数中心性，并且是不同集群之间的桥梁。它通常与控制资源和信息的流动有关。\n如何使用：Betweenness Centrality适用于网络科学中的各种问题，用于查明通信和交通网络中的瓶颈或可能的攻击目标。在基因组学中，被用于了解控制某些基因在蛋白质网络中的改进，例如更好的药物/疾病靶向。\nBetweenness Centrality也被用来评估多人在线游戏玩家和共享医师专业知识的信息流。

\n

社区发现算法

\n

这个类别也被称为聚类算法或分区算法。

\n

10. Label Propagation

\n

做什么：基于邻域多数的标签作为推断集群的手段。这种极其快速的图形分割需要很少的先验信息，并且被广泛地应用于大规模的社区检测网络中。这是理解图组织的一个关键方法，通常是其他分析的主要步骤。\n如何使用：Label Propagation具有不同的应用，例如了解社会团体中的共识形成、识别在生物网络的过程(功能模块)中所涉及的蛋白质集合等等。甚至还可以用于半监督和无监督的机器学习作为初始的预处理步骤。

\n

11. Strongly Connected

\n

做什么：定位节点组，其中每个节点可从同一组中的所有其他节点按照关系的方向到达，常被应用于深度优先算法。\n如何使用：Strongly Connected通常用于在识别的集群上独立运行其他算法。作为有向图的预处理步骤，它有助于快速识别不连通的集群。\n在零售推荐中，它有助于识别具有强亲和性的组，然后将向那些尚未购买商品的群体推荐首选商品。

\n

12. Union-Find/Connected Components/Weakly Connected

\n

做什么：查找节点组，其中每个节点可从同一组中的任何其他节点到达，而不考虑关系的方向。它提供几乎恒定的时间操作(独立于输入大小)来添加新的组，合并现有的组，并确定两个节点是否在同一组中。\n如何使用：Union-find/connected 经常与其他算法结合使用，特别是对于高性能分组。作为无向图的预处理步骤，它有助于快速识别断开的组。

\n

13. Louvain Modularity

\n

做什么：通过比较它的关系密度与适当定义的随机网络来测量社团分组的质量(即假定的准确性)。它通常用于评估复杂网络的组织和社区层次结构。这对于无监督机器学习中的初始数据预处理也是有用的。\n如何使用：Louvain用于评估Twitter，LinkedIn和YouTube上的社交结构;用于欺诈分析，以评估一个组织是只存在一些不良行为，还是背后一个连环欺诈。Louvain在比利时电信网络中揭示了一个六级客户层级。

\n

14. Local Clustering Coefficient/Node Clustering Coefficient

\n

做什么：对于一个特定的节点，量化了其到邻居节点的距离， (每个节点都直接连接到其他节点)。例如，如果您的所有朋友都直接了解对方，那么您的本地集群系数将是1。集群的小值表明尽管存在一个分组，但节点之间并没有紧密连接。\n如何使用：Local cluster coefficient通过理解群体相关性或碎片化的可能性，对估计弹性具有重要意义。用这种方法对欧洲电网的分析发现，与稀疏连接的节点相比，集群更能抵御普遍的故障。

\n

15. Triangle-Count and Average Clustering Coefficient

\n

做什么：测量有多少节点具有三角形以及节点倾向于聚集在一起的程度。平均聚类系数为1时表明有一个分组，0时没有连接。为使聚类系数有意义，它应该明显高于网络中所有关系随机的版本。\n如何使用：平均聚类系数通常用于估计网络是否可能展现基于紧密集群的“小世界”行为。这也是集群稳定性和弹性的一个因素。流行病学家使用平均聚类系数来帮助预测不同社区的各种感染率。

\n

结论

\n

世界是由关系驱动的，而Neo4j图形分析揭示了图形背后的意义，希望这些优化的图形算法能够帮助你以更加有意义、更有效的方式来理解所连接的数据。

\n
","title":"Neo4j中的15种不同图算法及其功能","last_reply_at":"2025-10-20T13:41:00.883Z","good":false,"top":false,"reply_count":0,"visit_count":2638,"create_at":"2025-10-20T13:41:00.883Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"686f1befa8f5aea0094a7c67","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

Neo4j 企业版 vs 社区版对比（ 基于Neo4j 4.x）

\n

参考官方：\nhttps://neo4j.com/docs/operations-manual/4.4/introduction/\n基于Neo4j 5.x 参考官方：\nhttps://neo4j.com/docs/operations-manual/5/introduction/\nhttps://neo4j.com/docs/operations-manual/5/database-internals/store-formats/#high-limit-format

\n

1. 核心功能对比

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
功能社区版企业版
属性图模型✔️ 支持✔️ 支持
原生图处理与存储✔️ 支持✔️ 支持
符合ACID原则的事务✔️ 支持✔️ 支持
密码图查询语言✔️ 支持✔️ 支持
带有语法高亮功能的Neo4j浏览器✔️ 支持✔️ 支持
Bolt协议✔️ 支持✔️ 支持
C#、Go、Java、JavaScript和Python的语言驱动[1]✔️ 支持✔️ 支持
高性能原生API✔️ 支持✔️ 支持
高性能缓存✔️ 支持✔️ 支持
基于成本的查询优化器✔️ 支持✔️ 支持
支持人工智能计划的图算法[1]✔️ 支持✔️ 支持
通过原生标签索引实现快速写入✔️ 支持✔️ 支持
组合索引✔️ 支持✔️ 支持
全文节点和关系索引✔️ 支持✔️ 支持
存储副本❌ 不支持✔️ 支持
空间的自动复用✔️ 支持✔️ 支持
多个数据库（超出系统和默认数据库范围）❌ 不支持✔️ 支持
槽式和流水线式Cypher运行时❌ 不支持✔️ 支持
属性存在性约束❌ 不支持✔️ 支持
节点键约束❌ 不支持✔️ 支持
列出并终止正在运行的查询❌ 不支持✔️ 支持
基于角色的访问控制❌ 不支持✔️ 支持
子图访问控制❌ 不支持✔️ 支持
LDAP与Active Directory集成❌ 不支持✔️ 支持
Kerberos安全选项❌ 不支持✔️ 支持
\n

2. 性能与扩展性

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
特性社区版企业版
全局应用的因果集群❌ 不支持✔️ 支持
簇内加密❌ 不支持✔️ 支持
离线备份✔️ 支持✔️ 支持
在线备份❌ 不支持✔️ 支持
加密备份❌ 不支持✔️ 支持
滚动升级❌ 不支持✔️ 支持
自动缓存预热❌ 不支持✔️ 支持
使用Neo4j驱动进行路由和负载均衡❌ 不支持✔️ 支持
高级监控(Neo4j Ops Manager、Prometheus)❌ 不支持✔️ 支持
图形大小限制340亿个节点，340亿条关系，以及680亿个属性无限制
导入命令行工具（neo4j-admin import 命令）✔️ 支持✔️ 支持
导入命令行工具（neo4j-admin import 命令），可恢复❌ 不支持✔️ 支持
\n

3. 安全与合规

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
特性社区版企业版
角色访问控制(RBAC)❌ 仅基础用户/密码认证✔️ 细粒度权限管理
数据加密❌ 仅传输加密(TLS)✔️ 传输+静态加密
审计日志❌ 无✔️ 完整操作记录
LDAP/AD集成❌ 不支持✔️ 支持
合规认证❌ 无✔️ SOC2, GDPR等
\n

4. 运维与管理

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
特性社区版企业版
Neo4j Browser✔️ 完整功能✔️ 完整功能
Neo4j Bloom❌ 不包含✔️ 包含可视化工具
Neo4j Desktop✔️ 支持✔️ 支持
官方技术支持❌ 仅社区论坛✔️ 24/7 SLA
升级与补丁❌ 依赖社区发布✔️ 优先获取
\n

5. 授权与成本

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
特性社区版企业版
许可证GPLv3 开源(免费)商业许可证(按核心/年收费)
云部署❌ 需自行部署✔️ 支持Neo4j AuraDB
商业用途✔️ 允许(需遵守GPL条款)✔️ 允许
\n

6. 适用场景推荐

\n

选择企业版当您需要：

\n

✅ 生产环境高可用 （如集群部署 故障自动转移、读写分离）\n✅ 企业级安全与合规\n✅ TB级大规模数据处理 （如集群部署 数据库分片扩展）\n✅ 官方技术支持服务\n✅ 需要7×24小时在线不中断，包括备份\n✅ 需要权限、角色管理\n✅ 需要完善的审计日志\n✅ 需要完善的监控功能

\n

选择社区版当您需要：

\n

✅ 个人学习/开发测试\n✅ 小型项目 无集群的单实例项目\n✅ 零预算的起步阶段\n✅ 能接受停机备份\n✅ 无需权限、角色管理\n✅ 对审计日志要求不高

\n
\n

提示：企业版提供30天免费试用，可通过官网申请体验完整功能。

\n
\n
","title":"neo4j 企业版 和 社区版 对比","last_reply_at":"2025-07-10T01:48:31.077Z","good":false,"top":false,"reply_count":0,"visit_count":7677,"create_at":"2025-07-10T01:48:31.077Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"686b8f2ea8f5aea0094a7c66","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/data-modeling/modeling-tips/

\n

图数据建模技巧

\n

目标

\n

在本指南中，您将找到一些有助于为您的领域设计数据模型的实用信息。优化模型可以帮助开发人员最大化系统和查询的性能。

\n
\n

建模技巧和方法

\n

正如您在阅读建模指南或自己进行图数据建模时可能发现的那样，没有绝对正确或错误的建模方式。一些方式可能更适合您的需求，并在您优先考虑的方面表现更好，但您有多种选择。

\n

为了找到最适合您需求的数据模型，通常可以采用一些技术并根据分析结果做出数据模型决策。接下来的段落中，我们将讨论一些建模技巧和方法，帮助您选择适合的数据模型。

\n
\n

1. 先编写查询

\n

了解您希望从数据中提出的问题和查询类型，是确定数据模型结构的绝佳方法。如果您知道查询需要在特定日期范围内返回结果，那么您可能需要确保日期不是节点上的属性，而是存储为单独的节点或关系。相比之下，对于大学课程领域，寻找与当前课程类似的课程可能更适合使用高层次的类别层次结构，这样可以更高效地搜索主题内的所有课程。

\n

即使您尚未确定确切的查询语法，理解您正在构建的系统或应用程序的意图，并围绕业务需求构建模型，将帮助您以更准确的方式组织数据。

\n
\n

2. 优先考虑查询

\n

找到适合每个查询或功能的完美模型是非常困难的（甚至是不可能的）。正如我们在建模设计指南中讨论的那样，选择一种特定模型而不是另一种（或使用多种模型）会有权衡。虽然您可能会改善某些方面，但无法获得适合所有情况的解决方案。

\n

相反，您应该确定哪个模型最适合您的需求。您可能无法在每个单独查询上都达到性能最大化，但您可以通过某些资源、时间和代码从系统中获得最大收益。

\n

为此，您需要决定哪些查询必须绝对具有最高性能，以及哪些功能对于提供价值至关重要。这可能是一个艰难的决定，但无论您使用哪种技术，这些决策都会以某种形式存在。Neo4j 的优势在于其模型灵活性，可以随着优先级的变化进行调整。

\n
\n

3. 测试模型

\n

在设计阶段，您可能会遇到未意识到的场景。找到这些场景的最佳方法之一是实际测试模型。

\n

加载部分数据并在系统上执行测试和查询，可以确定您收到的结果是否符合您的需求或预期性能。同样，Neo4j 的灵活性使您可以调整模型或优化查询以微调输出。

\n

在多个模型之间难以决定？尝试为每个模型创建概念验证测试，并同时测试它们的运行情况。哪些模型复杂或不值得麻烦？是否有一个模型在实际运行中表现更好，或者多数据模型方法是否真正提供了最佳结果？有时，找到答案的最佳方法是使用实时数据进行测试。

\n
\n

4. 重构图模型

\n

如上所述以及其他指南中提到的，使用 Neo4j 时始终可以进行更改。数据模型设计为灵活且易于调整，正是出于这个原因。业务需求和优先级往往会波动。用户行为也可能发生变化，从而导致业务的转变。

\n

Cypher® 允许您编写查询以对标签进行批量更新、添加或删除属性，以及向结构中插入额外的节点和关系。此外，还有一些程序可以帮助批量查询和更新集群实例。

\n

有关此主题的更多信息，请查看 APOC 库！

\n
\n

其他注意事项

\n

数据集的大小也会影响查询和性能。如果您的数据集较小，那么在执行更复杂的查询时可能不会看到太大的性能影响。只有当数据量增长时，您才可能看到影响增加。这时，数据模型和查询优化对于最大化系统价值变得至关重要。

\n
","title":"Neo4j官方教程：第25节，图数据建模技巧","last_reply_at":"2025-07-07T09:11:10.243Z","good":true,"top":false,"reply_count":0,"visit_count":3312,"create_at":"2025-07-07T09:11:10.243Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"686b8eaaa8f5aea0094a7c65","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/data-modeling/relational-to-graph-modeling/

\n

从关系型数据模型到图数据模型的建模

\n

对于有关系型数据建模背景的人来说，本指南将帮助您将现有的关系型数据建模知识转化为图数据建模知识。它将帮助您比较和对比两种建模过程的步骤，并帮助您识别两种数据库类型在数据建模方面的相似点和不同点。

\n
\n

简介

\n

如果您熟悉关系型数据模型（包括表、列、关系基数等组件），那么图数据建模不会显得完全陌生。数据模型的设计仍然需要基于访问需求、查询需求、性能预期和业务逻辑。然而，图数据模型的结构略有不同。

\n

您可能有一个全新的项目，想要创建图数据模型，但只熟悉如何创建关系型模型。或者您可能已经有一个现有的关系型模型项目，想要将其转换为图模型。无论哪种情况，本指南都将利用您对关系型数据模型的现有知识，教您如何创建图数据模型。

\n
\n

关系型与图数据库架构

\n

快速回顾一下，关系型数据库依赖索引查找和表连接来连接不同的实体。这在性能方面很快会成为问题，尤其是当有多个表连接、表中有数百万行或查询复杂且需要通过子查询遍历多个层级时。

\n

在概念页面的示例中，要找到 Alice 所属的部门，您需要查询 Person 表以找到代表 Alice 的行，该行与唯一 ID（主键）绑定。然后，查询需要访问关联实体表（Person_Dept），以找到她的 ID 与一个或多个部门 ID 的关联。最后，查询需要检查 Department 表，以找到关联实体表中部门 ID 的实际值。

\n

下图回顾了我们刚刚描述的示例：

\n

关系型模型示例

\n

\"image\"\n图 1. 关系型模型 - Person 和 Department 表

\n

在图数据库中，您无需担心表连接和索引查找，因为图数据是通过每个单独实体及其与其他实体的关系来构建的。

\n

那么，我们如何从创建关系型数据模型转向图数据模型呢？

\n
\n

数据模型转换技巧

\n

以下是将关系型数据模型的关键组件转换为图数据模型组件的一些技巧。帮助您将关系型图表转换为图模型的步骤如下：

\n
    \n
  1. 表到节点标签 - 关系型模型中的每个实体表变成图模型中的节点标签。
    2. \n
  2. 行到节点 - 关系型实体表中的每一行变成图中的一个节点。
    3. \n
  3. 列到节点属性 - 关系型表中的列（字段）变成图中的节点属性。
    4. \n
  4. 仅保留业务主键 - 删除技术主键，仅保留业务主键。
    5. \n
  5. 添加约束/索引 - 为业务主键添加唯一约束，为频繁查找的属性添加索引。
    6. \n
  6. 外键到关系 - 将指向其他表的外键替换为关系，然后删除外键。
    7. \n
  7. 移除默认值 - 删除具有默认值的数据，无需存储这些值。
    8. \n
  8. 清理数据 - 去除规范化表中的重复数据，将其提取到单独的节点以获得更清晰的模型。
    9. \n
  9. 索引列到数组 - 索引列名（如 email1, email2, email3）可能表示数组属性。
    10. \n
  10. 连接表到关系 - 连接表转换为关系，表中的列变成关系属性。
    11. \n
\n

如果将上述列表中的项目应用到我们寻找 Alice 所属部门的示例中，我们可以得到如下图所示的图模型：

\n

图模型示例

\n

\"image\"\n图 2. 图模型 - Alice 和三个部门作为节点

\n

虽然两种模型都有类似之处，例如通过表结构或标签对数据进行分类，但图模型不会将数据限制在预定义的严格表/列布局中。我们将在下一节中查看另一个示例。

\n
\n

组织领域数据模型

\n

为了让我们有另一个练习机会，我们将使用一个标准的组织领域，并展示它在关系型数据库和图数据库中的建模方式。您可以尝试自己创建图数据模型，然后看看它与示例模型的相似程度。

\n

关系型组织结构图

\n

\"image\"\n图 3. 组织领域 - 关系型模型

\n
\n

转换步骤

\n
    \n
  1. 首先，我们可以通过颜色将表分类为主域表和关联实体表。然后，我们可以将表名转换为节点标签。在这种情况下，Project、Person、Department 和 Organization 成为图模型中的标签。
    2. \n
  2. 表中的行变成它们自己的节点，行中的列变成节点上的属性。例如，Person 表中的一行将变成一个节点，节点上的属性包括姓名和出生日期。任何允许多个相似值的索引列将变成数组（例如 skill1, skill2, skill3 列转换为节点上的数组属性）。
    3. \n
  3. 如果有任何技术主键（即仅为了使行唯一而创建的主键，例如 project_id），则删除这些主键，仅保留业务需求所需的属性。还需要为业务主键添加唯一约束，以确保数据库不会允许重复。
    4. \n
  4. 外键用于关系型连接查找的，转换为关系，因为它们显示了节点之间的链接。连接表（或关联实体表）也变成关系，连接表中的列移动到关系属性。
    5. \n
  5. 由于 Neo4j 仅存储所需属性，因此无需存储空值和默认值，因此可以删除关系型模型中创建的任何默认值。
    6. \n
  6. 最后，任何为规范化表或为简化而去规范化创建的重复数据都需要删除，因为在图模型中不需要这些数据。
    7. \n
\n

经过此过程后，您的图数据模型应类似于下图所示：

\n

图组织结构图

\n

图 4. 组织领域 - 图模型

\n
\n

总结

\n

在开始导入数据之前，了解图模型的基本概念非常重要，因为随着需求的变化，调整模型或填充模型会变得更加容易。在即将发布的指南中，您将看到图数据的建模如何影响查询、性能和模型变化。

\n
","title":"Neo4j官方教程：第24节，从关系型数据模型到图数据模型的建模","last_reply_at":"2025-07-07T09:08:58.341Z","good":true,"top":false,"reply_count":0,"visit_count":3554,"create_at":"2025-07-07T09:08:58.341Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"686b8d6da8f5aea0094a7c64","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/data-modeling/versioning/

\n

版本控制

\n

每次重构数据模型时，都会创建新的版本。跟踪数据结构的变化或显示当前和过去的值对于审计目的、趋势分析等非常有价值。本页面概述了可以用来跟踪随时间变化的数据的不同建模方式。

\n
\n

实体的版本控制

\n

通过对相关实体进行版本控制，可以跟踪数据的变化。这种策略在以下情况下非常有用：

\n\n

\"image\"

\n

示例：图中显示实体的不同版本，其属性值随时间变化

\n\n

优缺点

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
优点缺点
建模、查询和维护简单。更新节点需要删除 LATEST 关系，并创建实体与其最新版本之间的新关系。
对最终用户显式，无需任何转换。如果不使用其他版本控制模式，可能会受到限制，因为如果不是最新版本，可能很难知道要检索哪个版本。
\n

查询示例

\n

以下是使用实体版本控制策略的常见查询示例：

\n

获取 ID 为 ‘1’ 的产品版本 2 的名称

\n
MATCH (:Product {id:1})-[:V2]->(s:State)\nRETURN s.name\n

获取 ID 为 ‘1’ 的产品最新版本的名称

\n
MATCH (:Product {id:1})-[:LATEST]->(s:State)\nRETURN s.name\n
\n

基于时间的实体版本控制

\n

实体版本控制的一种变体是基于时间的方法。这在以下情况下非常有用：

\n\n

示例：基于时间的实体版本控制

\n\n

优缺点

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
优点缺点
每个元素都有明确的时间间隔，在该时间间隔内元素有效。如果节点状态发生变化，节点必须被复制，并分配新的有效时间间隔。
状态绑定到特定元素（无需额外关系）。更新节点需要创建连接到新节点/状态的新关系，并分配新的有效时间间隔。
可以聚合所有元素（或某个时间点的有效元素）。数据重复无法避免。
\n

查询示例

\n

以下是使用基于时间的实体版本控制策略的常见查询示例：

\n

获取产品 “Rice Cooker” 的当前价格

\n
MATCH (p:Product)\nWHERE p.name = "Rice Cooker" AND p.validTo = ∞\nRETURN p.price\n

获取产品 “Rice Cooker” 在 11 月的价格

\n
MATCH (p:Product)\nWHERE p.name = "Rice Cooker"\nAND datetime(p.validFrom) <= datetime("November") <= datetime(p.validTo)\nRETURN p.price\n

获取当前产品目录及价格

\n
MATCH ()-[r:HAS_PRODUCT]->(p)\nWHERE r.validTo = ∞\nRETURN p.name, p.price\n
\n

链表

\n

链表是一种建模策略，当对象的顺序很重要时非常有用。

\n

链表的用途：

\n\n

示例：使用链表模型设计进行版本控制

\n\n

优缺点

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
优点缺点
使用关系获取下一个/前一个元素效率高。如果不使用其他版本控制模式，可能仅限于非常具体的用例。
建模和维护简单。很难找到不是第一个或最后一个的特定版本。
对最终用户显式。-
\n

查询示例

\n

以下是使用链表版本控制策略的常见查询示例：

\n

获取产品 “Professional chair” 的下一个名称

\n
MATCH (:State{name: "Professional chair"})-[:NEXT]->(s:State)\nRETURN s.name\n

获取 ID 为 ‘1’ 的产品的前一个名称

\n
MATCH (:Product {id:1})-[:LAST]->(:State)<-[:NEXT]-(s:State)\nRETURN s.name\n
\n

时间线树

\n

如建模设计中所述，时间线树是一种常见的建模设计。当您想要跟踪变化时，它可以是一种有用的策略。在此示例中，时间线结构从年份扩展到天，其余的非时间数据节点是图中包含重要数据的节点。\n\"image\"

\n

示例：图中显示两个不同的时间线按年份划分

\n

查询示例

\n

如果您想找到某个时间段内发生的所有购买，例如 2012 年 12 月的所有购买，可以从 2012 年导航到 12 月，然后从该分支下的所有叶节点（没有后代的节点）中获取数据：

\n
MATCH (root:Timeline)-[:IN_YEAR]->(year:Year {value:2012})-[:IN_MONTH]->(month:Month {value:12})\nWITH month\nMATCH (month)-[:ON_DAY]->(day)\nMATCH (purchase:Purchase)-[:OCCURRED]->(day)\nRETURN purchase\n
\n

组合方法

\n

一些复杂的用例需要结合上述一种或多种建模技术，因为每种技术都有其优点和缺点。

\n

示例：结合时间线树的更复杂版本控制方法

\n\n
","title":"Neo4j官方教程：第23节，版本控制","last_reply_at":"2025-07-07T09:03:41.998Z","good":true,"top":false,"reply_count":0,"visit_count":2966,"create_at":"2025-07-07T09:03:41.998Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"5af6db359662eee704f31c92","author_id":"5aa77f3f51bad0a10b198ac0","tab":"ask","content":"

最好是Java的

\n
","title":"请问 没有将sparql语句转换成cypher语句的工具？","last_reply_at":"2025-06-23T03:17:04.972Z","good":false,"top":false,"reply_count":2,"visit_count":4544,"create_at":"2018-05-12T12:16:53.444Z","author":{"loginname":"butchercode","avatar_url":"https://avatars0.githubusercontent.com/u/28502818?v=4&s=120"}},{"id":"6833c811b13f67342db8ad6c","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

安装LangChain 依赖

\n
pip install --upgrade --quiet  langchain langchain-community langchain-openai neo4j\n

安装Neo4j

\n

https://neo4j.com/deployment-center/ 下载安装 neo4j-community-5.26.4 解压到任意目录

\n

安装Neo4j Apoc 插件

\n

https://github.com/neo4j/apoc/releases?page=1 下载安装apoc-5.26.6-core.jar\n复制到neo4j安装目录 plugins目录下\n修改Neo4j配置文件，启用Neo4j Apoc 插件：到neo4j安装目录 plugins目录下修改\\conf\\neo4j.conf，添加如下两行

\n
dbms.security.procedures.unrestricted=apoc.*\ndbms.security.procedures.allowlist=apoc.*\n

启动Neo4j

\n

命令行到neo4j安装目录\\bin下运行：

\n
neo4j console\n

langchain + deepseek +neo4j 构建电影知识图谱智能问答

\n
import getpass\nimport os\nfrom langchain.chains import GraphCypherQAChain\nfrom langchain_openai import ChatOpenAI\nfrom langchain_community.graphs import Neo4jGraph\n\nos.environ["OPENAI_API_KEY"] = "您的DeepSeek API 秘钥"\nos.environ["NEO4J_URI"] = "bolt://localhost:7687"\nos.environ["NEO4J_USERNAME"] = "neo4j"\nos.environ["NEO4J_PASSWORD"] = "您的Neo4j密码"\n\nllm = ChatOpenAI(\n    model='deepseek-chat',\n    base_url="https://api.deepseek.com/v1"\n)\n\ngraph = Neo4jGraph()\n\n# Import movie information\n\nmovies_query = """\nLOAD CSV WITH HEADERS FROM \n'https://raw.githubusercontent.com/tomasonjo/blog-datasets/main/movies/movies_small.csv' \nAS row\nMERGE (m:Movie {id:row.movieId})\nSET m.released = date(row.released),\n    m.title = row.title,\n    m.imdbRating = toFloat(row.imdbRating)\nFOREACH (director in split(row.director, '|') | \n    MERGE (p:Person {name:trim(director)})\n    MERGE (p)-[:DIRECTED]->(m))\nFOREACH (actor in split(row.actors, '|') | \n    MERGE (p:Person {name:trim(actor)})\n    MERGE (p)-[:ACTED_IN]->(m))\nFOREACH (genre in split(row.genres, '|') | \n    MERGE (g:Genre {name:trim(genre)})\n    MERGE (m)-[:IN_GENRE]->(g))\n"""\n#用Loadcsv 在线下载并构建电影知识图谱数据\n\ngraph.query(movies_query)\ngraph.refresh_schema() #刷新schema\n\n\nchain = GraphCypherQAChain.from_llm(graph=graph,allow_dangerous_requests=True,llm=llm, verbose=True)\nresponse = chain.invoke({"query": "电影《Casino》的演员阵容是怎样的？"}) #提问\nprint(response) #回答\n

回答如下：

\n
\u001b[1m> Entering new GraphCypherQAChain chain...\u001b[0m\nGenerated Cypher:\n\u001b[32;1m\u001b[1;3mMATCH (p:Person)-[:ACTED_IN]->(m:Movie {title: 'Casino'}) RETURN p.name\u001b[0m\nFull Context:\n\u001b[32;1m\u001b[1;3m[{'p.name': 'James Woods'}, {'p.name': 'Joe Pesci'}, {'p.name': 'Robert De Niro'}, {'p.name': 'Sharon Stone'}]\u001b[0m\n\n\u001b[1m> Finished chain.\u001b[0m\n{'query': '电影《Casino》的演员阵容是怎样的？', 'result': '电影《Casino》的演员阵容包括詹姆斯·伍兹（James Woods）、乔·佩西（Joe Pesci）、罗伯特·德尼罗（Robert De Niro）和莎朗·斯通（Sharon Stone）。'}\n
","title":"Langchain + deepseek +neo4j 构建电影知识图谱智能问答","last_reply_at":"2025-05-26T01:46:57.860Z","good":true,"top":false,"reply_count":0,"visit_count":3281,"create_at":"2025-05-26T01:46:57.860Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"682700deb13f67342db8ad69","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/data-modeling/modeling-designs/

\n

数据建模设计

\n

在本节中，您将学习如何使用各种建模决策来表示图数据。数据模型的构建方式会影响查询和性能。我们的目标是教您如何评估模型并进行适当的更改，以便为您的用例定义最佳解决方案并最大化查询性能。

\n

为什么数据模型很重要

\n

与任何数据库一样，您设计的数据模型对确定查询逻辑和数据存储结构都很重要。这种实践也适用于图数据库，但有一个例外：Neo4j 是无模式的，这意味着您的数据模型可以随业务需求轻松调整和变化。

\n

常见场景

\n\n

您可能在一家公司工作过，其中每个区域或部门对领域的定义都不同。以通用客户域为例：对于业务内的不同区域，客户可以被定义为不同类型的个体。这些定义也可能随时间变化，或者公司可能决定统一各部门之间客户的含义。

\n

Neo4j的优势

\n

如果您使用过其他类型的数据库，您会熟悉这些场景所涉及的开发和管理工作。然而，Neo4j允许您轻松地对图的局部或整体进行详细和广泛的更改：

\n\n

开发人员和架构师只需要确定：

\n
    \n
  1. 数据模型的结构
    2. \n
  2. 如何定义用于查询的实体
    3. \n
\n

属性与关系的对比

\n

在早期设计决策中，您可能会遇到是将某些内容建模为：

\n\n

例如，可以将电影类型作为 Movie 节点上的属性进行建模。

\n

这种设计选择将影响：

\n\n

在接下来的内容中，我们将介绍查看不同数据集的几种方法，并展示每种方法如何影响图数据的查询和遍历性能。\n\"image\"

\n

编写查询来查找特定电影的类型是很简单的。只需找到想要了解的 Movie 节点，然后返回 genre 属性中列出的值。但是，要找出共享类型的电影，需要一个更复杂的查询来：

\n
    \n
  1. 查找每个 Movie 节点
    2. \n
  2. 遍历每个电影的类型属性数组
    3. \n
  3. 与第二部电影的类型属性数组中的每个值进行比较
    4. \n
\n

这会影响性能（嵌套循环和节点属性比较），查询也会更加复杂。

\n
//查找特定电影的类型\nMATCH (m:Movie {title:"The Matrix"})\nRETURN m.genre;\n\n//查找共享类型的电影\nMATCH (m1:Movie), (m2:Movie)\nWHERE any(x IN m1.genre WHERE x IN m2.genre)\nAND m1 <> m2\nRETURN m1, m2;\n

现在，相反，如果您将电影及其类型建模为单独的节点，并在它们之间创建一种关系，您将得到如图2所示的模型。\n\"image\"\n这将为流派创建一个完全独立的实体(节点)，允许您将所有具有共享流派的电影连接到该流派节点。让我们看看这如何改变我们的查询。为了找到特定电影的流派，它首先需要找到它正在寻找的电影节点(在本例中为“矩阵”)，然后找到通过IN_GENRE关系连接到该电影的节点。

\n

最大的区别在于第二个查询的语法，该查询用于查找哪些电影具有相同的类型。它比我们早期的版本简单得多，因为它使用自然的图形模式(实体-关系-实体)来查找所需的信息。首先，Cypher找到一部电影及其相关的类型，然后寻找同一类型的第二部电影。

\n
//find the genres for a particular movie\nMATCH (m:Movie {title:"The Matrix"}),\n      (m)-[:IN_GENRE]->(g:Genre)\nRETURN g.name;\n\n//find which movies share genres\nMATCH (m1:Movie)-[:IN_GENRE]->(g:Genre),\n      (m2:Movie)-[:IN_GENRE]->(g)\nRETURN m1, m2, g\n

数据模型的版本没有好坏之分，但是“最佳”选项很大程度上取决于您打算对数据运行的查询类型。

\n

如果您计划对单个项目进行分析，并且只返回关于该实体的详细信息(比如特定电影的类型)，那么第一个数据模型将非常适合您的需求。但是，如果您需要运行分析来寻找实体之间的共同点或者查看一组节点，那么第二个数据模型肯定会提高这些类型的查询的性能。

\n

复杂数据结构

\n

众所周知，不是所有的数据模型都简单直接。数据是混乱的，模型必须尝试更好地组织它以帮助我们看到模式并做出决策。

\n

漫威漫画数据是一个难以建模的复杂数据结构的典型例子。在漫威宇宙中，漫画中有角色出场或担任主角。漫画可以按特定时间的故事线或叙事组织成系列，重大事件可能发生在定义角色路径或系列的漫画中。创作者（包括作家、插画师等）是漫画的作者，定义故事线、角色改编和发生的事件。多个创作者也可以互换参与创作漫画或系列。

\n

这个数据集已经看起来很复杂，有多个实体和关系在起作用。在尝试对这里存在的层次结构和中间实体进行建模时，又增加了一层复杂性。

\n

如果您有时间，可以在 Vimeo 上观看 Peter 演讲的完整视频链接，但我们想强调 Peter 在数据集中讨论的两个关键挑战。

\n

首先，他发现漫画角色往往极其动态。许多角色无法通过名字、服装或任何特定属性来识别，因为这些都经常变化。

\n

其次，Peter 发现了时序问题。对于漫画宇宙的新手来说，有些人可能想确定从哪里开始或接下来看哪些漫画。然而，漫画期刊并不总是按顺序编号的，甚至有些故事情节会跨越多个系列来回出现。这使得分离某些故事块或事件以及角色的演绎变得极其困难。

\n

示例：中间节点

\n

在这个模型中有用的一种建模技术是超边的概念。超边通常用于建模存在于两个以上实体之间的关系。Neo4j 不支持两个以上节点之间的关系，而是使用中间节点来建模这种关系。它们通常用于表示多个实体在某个时间点的连接。

\n

这方面的一个常见例子是大学课程。同一门课程可能有多个开设班次，使用相同的教师在相同的建筑物中等。课程的每个部分（或开设班次）就成为课程的一个实例。

\n

Marvel 的 Peter 处理他们数据中的中间节点的方式是创建一个 Appearance 节点，该节点表示特定时间点上 Person 和 Alias 的交集。这个 Appearance 可以关联到多个 Moment 节点，在这些节点中人物和化身作为一个整体出现。这在下面的模型中表示（也在视频中）。\n\"image\"\n在关系型存储中，试图对所有这些复杂方面进行分类和关联将极其困难，并进一步使整体数据的分析和审查变得复杂。图模型允许他们对这个高度动态的宇宙进行建模，并跟踪其数据中所有不断变化的连接。对于这个用例，图是完美的选择。

\n

时间绑定数据和版本控制

\n

建模时间特定数据和关系的一种方式是在关系类型中包含数据。由于 Neo4j 专门针对实体之间的关系遍历进行了优化，因此您通常可以通过将日期指定为关系类型并仅遍历特定日期的关系来提高查询性能。

\n

一个常见的例子是对航空公司航班进行建模。航空公司在特定日期有从特定地点到特定地点的航班。我们可以从下面的图 4 所示的模型开始，展示航班如何在机场之间运行。\n\"image\"\n我们很快就会意识到，我们需要对存在于两个目的地之间的飞行实体进行建模，因为多架飞机可以在一天内多次往返于两个目的地之间。

\n

然而，您的查询可能仍然显示了该模型在过滤特定机场的所有航班方面的弱点——特别是对于伦敦和其他主要城市，这些城市在任何时间跨度内都有数百个航班连接到某个机场节点。检查每个航班节点的几个属性在资源上可能是昂贵的。

\n

如果我们要为特定的机场日创建一个节点，并在类型中创建一个带有日期的关系，那么我们可以编写查询来查找任何指定日期(或日期范围)从机场起飞的航班。这样，您就不需要检查每个航班与机场的关系。相反，你只会关注那些你在乎的日期的关系。这个模型结果如下图所示。\n\"image\"\n版本控制类似于上面的模型，我们创建了一个日期关系类型，我们也可以用它来跟踪数据的版本。跟踪数据结构的变化或显示当前和过去的值对于审计、趋势分析等非常重要。

\n

例如，如果您想在一个人和他的当前地址之间创建一个新的有生效日期的关系，但是还想保留过去的地址，那么您可以使用相同的原则在关系类型中包含一个日期。为了找到这个人的当前地址，查询将查找最近的关系。

\n

有时，您可能会发现一个模型对于您需要的一个场景确实很好，但是另一个模型对于其他场景更好。例如，一些模型可以更好地处理写查询，而另一些模型可以更好地处理读查询。这两种能力对您的用例都很重要，那么您会怎么做呢？

\n

在这些情况下，您可以将这两种模式结合起来，利用各自的优势。是的，您可以在您的图表中使用多个数据模型！

\n

代价是现在您需要维护两个模型。每当您创建一个新的节点或关系，或者更新图的一部分时，您都需要进行更改以适应这两种模型。这也会影响查询性能，因为更新每个模型可能需要两倍的语法。

\n

虽然这肯定是一个可能的选择，但是您应该知道维护成本，并评估这些成本是否能够被您将看到的每个所需查询的性能改进所抵消。如果是这样，能够使用多个数据模型是一个很好的解决方案！

\n
","title":"Neo4j官方教程：第22节，数据建模设计","last_reply_at":"2025-05-16T09:09:50.219Z","good":true,"top":false,"reply_count":0,"visit_count":2814,"create_at":"2025-05-16T09:09:50.219Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"6826fa35b13f67342db8ad68","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/data-modeling/tutorial-refactoring/

\n

教程：重构图数据模型

\n

重构是更改数据模型和图的过程。需要重构数据模型的主要原因包括：

\n\n

为了满足这些需求，本教程将指导您设计、实现和测试一个经过重构的数据模型，并更新 Cypher 查询。

\n

前置条件

\n

本教程是《教程：创建图数据模型》的后续内容。在继续之前，您需要完成该教程中创建的数据模型。

\n

或者，您也可以现在从头开始创建。选择您喜欢的部署方法，并使用以下代码添加数据：

\n
CREATE (Apollo13:Movie {title: 'Apollo 13', tmdbID: 568, released: '1995-06-30', imdbRating: 7.6, genres: ['Drama', 'Adventure', 'IMAX']})\nCREATE (TomH:Person {name: 'Tom Hanks', tmdbID: 31, born: '1956-07-09'})\nCREATE (MegR:Person {name: 'Meg Ryan', tmdbID: 5344, born: '1961-11-19'})\nCREATE (DannyD:Person {name: 'Danny DeVito', tmdbID: 518, born: '1944-11-17'})\nCREATE (JackN:Person {name: 'Jack Nicholson', tmdbID: 514, born: '1937-04-22'})\nCREATE (SleeplessInSeattle:Movie {title: 'Sleepless in Seattle', tmdbID: 858, released: '1993-06-25', imdbRating: 6.8, genres: ['Comedy', 'Drama', 'Romance']})\nCREATE (Hoffa:Movie {title: 'Hoffa', tmdbID: 10410, released: '1992-12-25', imdbRating: 6.6, genres: ['Crime', 'Drama']})\n\nMERGE (TomH)-[:ACTED_IN {roles:'Jim Lovell'}]->(Apollo13)\nMERGE (TomH)-[:ACTED_IN {roles:'Sam Baldwin'}]->(SleeplessInSeattle)\nMERGE (MegR)-[:ACTED_IN {roles:'Annie Reed'}]->(SleeplessInSeattle)\nMERGE (DannyD)-[:DIRECTED]->(Hoffa)\nMERGE (DannyD)-[:ACTED_IN {roles:'Robert "Bobby" Ciaro'}]->(Hoffa)\nMERGE (JackN)-[:ACTED_IN {roles:'Hoffa'}]->(Hoffa)\n\nCREATE (Sandy:User {name: 'Sandy Jones', userID: 1})\nCREATE (Clinton:User {name: 'Clinton Spencer', userID: 2})\n\nMERGE (Sandy)-[:RATED {rating:5}]->(Apollo13)\nMERGE (Sandy)-[:RATED {rating:4}]->(SleeplessInSeattle)\nMERGE (Clinton)-[:RATED {rating:3}]->(Apollo13)\nMERGE (Clinton)-[:RATED {rating:3}]->(SleeplessInSeattle)\nMERGE (Clinton)-[:RATED {rating:3}]->(Hoffa)\n

剩余或新用例

\n

假设您想知道有哪些电影可以用某种语言观看。

\n

要回答这个问题，您需要先将此信息添加到图中。然而，添加新数据会带来重复的风险，进而影响图的性能。

\n

为演示这种情况，向 ‘Movie’ 节点添加新的 languages 属性及其对应值：

\n
MATCH (Apollo13:Movie {title:'Apollo 13'})\nMATCH (SleeplessInSeattle:Movie {title:'Sleepless in Seattle'})\nMATCH (Hoffa:Movie {title:'Hoffa'})\nSET Apollo13.languages = ['English']\nSET SleeplessInSeattle.languages = ['English']\nSET Hoffa.languages = ['English', 'Italian', 'Latin']\n

结果：\n\"image\"\n要检索所有英语电影，执行此查询：

\n
MATCH (m:Movie)\nWHERE 'English' IN m.languages\nRETURN m.title\n

结果将返回电影 “Apollo 13”、“Sleepless in Seattle” 和 “Hoffa”。

\n

此查询检索所有 Movie 节点然后测试 languages 属性是否包含值 English。这种方法没错，但随着图的扩展可能遇到两个问题：

\n
    \n
  1. 查询必须检索所有 Movie 节点 → 随着图的扩展，这种建模方式会降低查询性能
    2. \n
  2. language 属性值在多个 Movie 节点中重复 → 如果多个节点共享相同的属性值，说明该属性值可以作为新实体（如节点或关系）
    3. \n
\n

解决方案是将 languages 属性重构为节点，并用新关系将其连接到 Movie 节点。\n现在：\n\"image\"\n重构：\n\"image\"

\n

消除重复数据

\n

要将节点属性 languages 重构为节点，可以使用以下查询：

\n
MATCH (m:Movie)\nWITH m, m.languages AS languages\nUNWIND languages AS language\nMERGE (l:Language {name: language})\nMERGE (m)-[:IN_LANGUAGE]->(l)\nREMOVE m.languages\n

查询分解说明：

\n
    \n
  1. UNWIND Movie 节点的 languages 属性，将其条目转换为新的 Language 节点
    2. \n
  2. 创建 IN_LANGUAGE 关系连接 Movie 节点与其对应的 Language 节点
    3. \n
  3. 移除 Movie 节点的 languages 属性\n如图：\n\"image\"\n重构后，图中应只有一个值为 “English” 的 Language 节点，相关电影与其相连。这消除了大量重复并提高了图扩展时的性能。
    4. \n
\n

处理复杂数据

\n

假设出现了需要每部电影制片公司信息的新用例。制片公司数据包括物理地址，这可以视为复杂数据。

\n

可以通过创建 ProductionCompany 节点和地址属性将此信息添加到图中：

\n
CREATE (p:ProductionCompany {name:'Imagine Entertainment', country:'US', postalCode:90212, state:'CA', city:'Beverly Hills', address1:'10351 Santa Monica Blvd'})\nMERGE (Apollo13:Movie {title:'Apollo 13'})\nCREATE (p)-[:PRODUCED]->(Apollo13)\nCREATE (jerseyFilms:ProductionCompany {name:'Jersey Films', country:'US', postalCode:90049, state:'CA', city:'Los Angeles', address1:'10351 Santa Monica Blvd'})\nMERGE (hoffa:Movie {title:'Hoffa'})\nCREATE (jerseyFilms)-[:PRODUCED]->(hoffa)\n

\"image\"\n在节点上存储复杂数据的问题\n以这种方式在节点上存储复杂数据可能存在以下问题：

\n
    \n
  1. 数据重复\n多个制片公司可能位于相同位置，导致信息在多个节点上重复\n示例：之前我们将’languages’属性重构为节点，就是为了避免"English"在所有 Movie 节点上重复
    2. \n
  2. 过度获取\n查询节点信息时需要不必要地检索更多同类节点\n示例：要查找位于加利福尼亚的制片公司时，需要扫描所有 ProductionCompany 节点的属性来获取 state 值。而如果将加利福尼亚作为独立节点，就能提供更短的访问路径，避免获取多余信息\n替代方案：可以创建索引
    3. \n
\n

数据建模目标

\n

数据建模的核心目标是减少查询时需要访问的图数据量。如果出现以下情况，需要考虑重构模型：

\n

图中包含大量重复数据\n查询仍在过度获取数据\n当前模型分析\n目前模型中新增了 ProductionCompany 节点标签，包含多个地址属性。这些属性值存在大量重复，不够理想。为提高效率，应：

\n

检查重复的键值\n考虑将其转换为新实体（节点或关系）\n重构示例\n由于两家制片公司都在加利福尼亚，可以：

\n

将州属性转换为 State 节点\n通过新的 LOCATED_AT 关系连接制片公司\n移除制片公司节点上的 state 属性\n重构效果\n按州查询制片公司时可直接基于 State.name 值过滤\n避免评估所有 ProductionCompany 节点的 state 属性\n\"image\"\n总结\n处理复杂数据的重构方式取决于：

\n

需要解答的问题\n图扩展时查询的性能表现\n下一步是通过测试来衡量图中的性能表现。

\n

使用特定关系

\n

当项目有需要经常检索某些信息的重复用例时，可以使用特定关系作为重构策略。好处包括：

\n\n

例如，如果经常需要检索 1995 年的演员信息，查询可以从：

\n
MATCH (p:Person)-[:ACTED_IN]-(m:Movie)\nWHERE p.name = 'Tom Hanks' AND m.released STARTS WITH '1995'\nRETURN DISTINCT m.title AS Movie\n

优化为：

\n
MATCH (p:Person)-[:ACTED_IN_1995]-(m:Movie)\nWHERE p.name = 'Tom Hanks'\nRETURN m.title AS Movie\n

重新测试图

\n

重新测试图的用例查询

\n

以下是需要重新检查的用例查询列表：

\n

1. 哪些人参演了某部电影？

\n
MATCH (p:Person)-[:ACTED_IN]->(m:Movie {title:'Hoffa'})\nRETURN p\n

2. 谁导演了某部电影？

\n
MATCH (p:Person)-[:DIRECTED]->(m:Movie {title:'Hoffa'})\nRETURN p\n

3. 某人参演了哪些电影？

\n
MATCH (p:Person {name:'Tom Hanks'})-[:ACTED_IN]->(m:Movie)\nRETURN m\n

4. 有多少用户为某部电影评分？

\n
MATCH (m:Movie {title: 'Apollo 13'})\nRETURN COUNT {(:User)-[:RATED]->(m)} AS `Number of reviewers`\n

5. 谁是某部电影中最年轻的演员？

\n
MATCH (p:Person)-[:ACTED_IN]-(m:Movie)\nWHERE m.title = 'Hoffa'\nRETURN p.name AS Actor, p.born as `Year Born` \nORDER BY p.born DESC LIMIT 1\n

6. 某人在电影中扮演什么角色？

\n
MATCH (p:Person {name:'Tom Hanks'})-[a:ACTED_IN]->(m:Movie {title: 'Apollo 13'})\nRETURN a.roles\n

7. 某年按 IMDB 评分最高的电影是哪部？

\n
MATCH (m:Movie)\nWHERE m.released STARTS WITH '1995'\nRETURN m.title as Movie, m.imdbRating as Rating \nORDER BY m.imdbRating DESC LIMIT 1\n

8. 某演员参演了哪些剧情片？

\n
MATCH (p:Person)-[:ACTED_IN]-(m:Movie)\nWHERE p.name = 'Tom Hanks' AND\n'Drama' IN m.genres\nRETURN m.title AS Movie\n

9. 哪些用户给某部电影打了5分？

\n
MATCH (u:User)-[r:RATED]-(m:Movie)\nWHERE m.title = 'Apollo 13' AND\nr.rating = 5\nRETURN u.name as Reviewer\n

10. 哪些电影是英语电影？

\n
MATCH (m:Movie)\nWHERE m.languages = 'English'\nRETURN m.title as Movie in English\n

说明

\n

需要检查以上每个查询，看是否可以利用重构后的数据模型进行优化。比如最后一个查询"哪些电影是英语电影？“就可以使用新的 Language 节点和 IN_LANGUAGE 关系进行重写。\n重构后，应重新检查所有用例查询。例如用例"哪些电影是英语的？”：

\n

重构前：

\n
MATCH (m:Movie)\nWHERE m.languages = 'English'\nRETURN m.title as Movie in English\n

重构后：

\n
MATCH (m:Movie)-[:IN_LANGUAGE]->(l:Language)\nWHERE l.name = 'English'\nRETURN m.title as Movie in English\n

性能检查

\n

在实际应用中，特别是图完全扩展时，可以通过 PROFILE 检查新查询的性能改进：

\n
PROFILE MATCH (n:Person)\nRETURN n\n

结果：\n\"image\"

\n

持续学习

\n

大多数重构工作是为了重新利用或添加更多信息到图中。

\n

可以在 GraphAcademy 的 Graph Data Modeling Fundamentals 交互式课程中学习更多重构策略，如将 Person 节点拆分为 Actor 和 Director 节点、将 Movie 节点的 genre 属性转换为节点等。

\n
","title":"Neo4j官方教程：第21节，重构图数据模型","last_reply_at":"2025-05-16T08:41:25.211Z","good":true,"top":false,"reply_count":0,"visit_count":2339,"create_at":"2025-05-16T08:41:25.211Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"680df39fb13f67342db8ad62","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/data-modeling/tutorial-data-modeling/

\n

教程：创建图数据模型

\n

本教程旨在帮助您根据预期用途对数据进行建模。您将使用电影示例数据集作为主要资源。

\n

有关数据建模基础的交互式课程，请参阅 GraphAcademy。

\n
\n

定义领域

\n

在本教程中，您将使用电影示例数据集。领域包括电影、出演或导演电影的人，以及对电影进行评分的用户。通过这些实体之间的连接（关系），您可以发现领域中的洞察。

\n
\n

定义用例

\n

在定义领域后，您需要确定应用程序的用例。换句话说，您需要回答哪些问题？

\n

您可以列出问题来帮助确定应用程序的用例。这些问题将帮助您定义应用程序的需求以及图中必须包含的数据。

\n

在本教程中，您的应用程序应能够回答以下问题：

\n\n
\n

定义目的

\n

在为应用程序设计图数据模型时，您可能需要数据模型和实例模型。

\n

数据模型

\n

数据模型描述了领域中的节点和关系，包括标签、类型和属性。它不包含任何数据，但显示了回答用例所需的信息。

\n

在此阶段，您可以选择使用无代码工具来可视化您的计划。例如，使用 Arrows.app，您可以绘制包含节点标签、关系类型和属性的数据模型：

\n

示例数据模型包括表示人和电影的两个节点，通过两种关系连接。\n\"image\"\n根据示例领域和初始问题，您可以列出初始模型中需要的信息：

\n\n

注意，在模型中，标签、关系类型和属性键遵循特定语法。在 Cypher® 中，这些称为标识符，区分大小写，字符串值也区分大小写。

\n

推荐的命名规范：

\n\n

在创建初始模型时，专注于模型的高层设计，即实体如何连接。更详细的分配信息将在“定义实体”步骤中描述。

\n

实例模型

\n

实例模型是存储和处理实际数据的表示。您可以使用实例模型测试用例。

\n

要创建实例模型，您需要一些示例数据并将其加载到所选的部署中。以下是一个小型但具有代表性的数据集：\n\"image\"

\n
CREATE (Apollo13:Movie {title: 'Apollo 13', tmdbID: 568, released: '1995-06-30', imdbRating: 7.6, genres: ['Drama', 'Adventure', 'IMAX']})\nCREATE (TomH:Person {name: 'Tom Hanks', tmdbID: 31, born: '1956-07-09'})\nCREATE (MegR:Person {name: 'Meg Ryan', tmdbID: 5344, born: '1961-11-19'})\nCREATE (DannyD:Person {name: 'Danny DeVito', tmdbID: 518, born: '1944-11-17'})\nCREATE (JackN:Person {name: 'Jack Nicholson', tmdbID: 514, born: '1937-04-22'})\nCREATE (SleeplessInSeattle:Movie {title: 'Sleepless in Seattle', tmdbID: 858, released: '1993-06-25', imdbRating: 6.8, genres: ['Comedy', 'Drama', 'Romance']})\nCREATE (Hoffa:Movie {title: 'Hoffa', tmdbID: 10410, released: '1992-12-25', imdbRating: 6.6, genres: ['Crime', 'Drama']})\n

建议手动使用 Cypher 添加数据以练习数据建模。

\n
\n

定义实体

\n

实例模型帮助您预览数据将如何存储为节点、关系和属性。下一步是通过更多细节完善模型。

\n

标签

\n

应用程序用例中的主要名词在模型中表示为节点，并可用作节点标签。例如：

\n\n

初始模型中的节点为 Person、Movie 和 User。请注意，创建模型是一个迭代过程，经过重构后，模型可能会有所不同。

\n

节点属性

\n

您可以使用节点属性来：

\n\n

以下是一些示例用例及其查询：

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
用例步骤查询示例
哪些人出演了一部电影？检索电影标题，返回演员姓名。MATCH (m:Movie {title:'Hoffa'})<-[r:ACTED_IN]-(p:Person) RETURN p.name
哪个人导演了一部电影？检索电影标题，返回导演姓名。MATCH (m:Movie {title:'Hoffa'})<-[r:DIRECTED]-(p:Person) RETURN p.name
某人出演了哪些电影？检索演员姓名，返回电影标题。MATCH (p:Person {name:'Tom Hanks'})-[:ACTED_IN]->(m:Movie) RETURN m.title
谁是出演电影的最年轻的人？检索电影标题，评估演员年龄，返回最年轻演员姓名。MATCH (m:Movie {title:'Sleepless in Seattle'})<-[r:ACTED_IN]-(p:Person) RETURN p.name, p.born ORDER BY p.born ASC LIMIT 1
某一年 IMDb 评分最高的电影是哪部？检索某年发布的所有电影，评估 IMDb 评分，返回评分最高的电影标题。MATCH (m:Movie {release:date('1995')}) RETURN m.title, m.imdbRating ORDER BY m.imdbRating DESC LIMIT 1
\n

唯一标识符

\n

在 Cypher 中，可以创建两个具有完全相同数据的节点。然而，从数据管理和模型角度来看，不同的节点应包含不同的数据。您可以使用唯一标识符确保每个节点都是独立且可区分的实体。

\n

例如，Movie.tmdbID 是一个很好的唯一标识符，因为数据库中可能有不同的电影具有相同的标题，但 tmdbID 属性将不同，从而充当唯一标识符。

\n

建议通过使用唯一性约束来强制执行唯一标识符。有关更多信息，请参阅 Cypher → 创建属性唯一性约束.

\n
\n

关系

\n

关系是节点之间的连接，这些连接是用例中的动词：

\n\n

命名

\n

为图中的关系选择好的名称（类型）非常重要，并尽可能具体，以便 Neo4j 仅遍历相关连接。

\n

例如，与其使用通用的关系类型（如 CONNECTED_TO），更倾向于使用更具体且直观的方式描述实体之间的连接。

\n

在本教程示例中，您可以定义以下关系：

\n\n

关系方向

\n

所有关系必须有方向。在创建时，关系需要显式指定方向，或者通过模式的从左到右顺序推断方向。\n\"image\"\n在示例用例中，ACTED_IN 关系必须从 Person 节点指向 Movie 节点：

\n
MERGE (TomH)-[:ACTED_IN]->(Apollo13)\nMERGE (TomH)-[:ACTED_IN]->(SleeplessInSeattle)\nMERGE (MegR)-[:ACTED_IN]->(SleeplessInSeattle)\nMERGE (DannyD)-[:ACTED_IN]->(Hoffa)\nMERGE (DannyD)-[:DIRECTED]->(Hoffa)\nMERGE (JackN)-[:ACTED_IN]->(Hoffa)\n

\"image\"

\n

关系属性

\n

关系属性用于丰富两个节点之间的关系。当您需要知道两个节点之间的关系方式而不仅仅是它们存在关系时，可以使用关系属性进一步定义关系。\n\"image\"\n例如，问题“某人在电影中扮演了什么角色？”可以通过 ACTED_IN 关系中的属性 roles 来回答：

\n
MERGE (TomH)-[:ACTED_IN {roles:'Jim Lovell'}]->(Apollo13)\nMERGE (TomH)-[:ACTED_IN {roles:'Sam Baldwin'}]->(SleeplessInSeattle)\nMERGE (MegR)-[:ACTED_IN {roles:'Annie Reed'}]->(SleeplessInSeattle)\nMERGE (DannyD)-[:ACTED_IN {roles:'Robert "Bobby" Ciaro'}]->(Hoffa)\nMERGE (JackN)-[:ACTED_IN {roles:'Hoffa'}]->(Hoffa)\n

查询示例：

\n
MATCH (p:Person {name:'Tom Hanks'})-[r:ACTED_IN]->(m:Movie {title:'Apollo 13'})\nRETURN r.roles\n
\n

添加更多数据

\n

现在您已经创建了节点之间的初始连接，是时候向图中添加更多信息了。例如：

\n\n

为此，您需要在图中添加用户及其评分信息，这意味着数据模型的更改。\n\"image\"

\n

添加用户节点

\n
MERGE (Sandy:User {name: 'Sandy Jones', userID: 1})\nMERGE (Clinton:User {name: 'Clinton Spencer', userID: 2})\n

建议将用户信息与演员和导演分开，因为它们与电影节点的关系不同。

\n

添加评分关系

\n
MERGE (Sandy)-[:RATED {rating:5}]->(Apollo13)\nMERGE (Sandy)-[:RATED {rating:4}]->(SleeplessInSeattle)\nMERGE (Clinton)-[:RATED {rating:3}]->(Apollo13)\nMERGE (Clinton)-[:RATED {rating:3}]->(SleeplessInSeattle)\nMERGE (Clinton)-[:RATED {rating:3}]->(Hoffa)\n

\"image\"

\n

测试模型

\n

在填充图以实现数据模型并使用一小组测试数据后，您现在应该测试它以确保满足每个用例。

\n

例如，测试用例“哪些人出演了一部电影？”可以运行以下查询：

\n
MATCH (p:Person)-[:ACTED_IN]-(m:Movie)\nWHERE m.title = 'Sleepless in Seattle'\nRETURN p.name\n

测试时，请确保 Cypher 语句正确。错误的查询可能导致错误地认为数据模型失败。

\n
\n

重构

\n

完成测试后，下一步是进行调整。有关说明，请参阅 教程：重构。

\n
","title":"Neo4j官方教程：第20节，创建图数据模型","last_reply_at":"2025-04-27T09:06:39.613Z","good":true,"top":false,"reply_count":0,"visit_count":2943,"create_at":"2025-04-27T09:06:39.613Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"680b51dfb13f67342db8ad61","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/data-modeling

\n

图数据建模是什么？

\n

数据建模是一种定义查询逻辑和存储数据结构的实践。一个设计良好的模型是充分利用图数据库优势的关键，因为它可以提高查询性能、支持灵活查询并优化存储。

\n
\n

如何创建图数据模型

\n

要将数据组织成数据模型，首先需要思考你想回答哪些问题。

\n

例如，假设你为一家零售公司工作，并希望了解客户购买了哪些产品。为此，你需要：

\n
    \n
  1. 拥有关于已售产品和购买它们的客户的数据：这个过程称为“实体提取”。
    2. \n
  2. 理解这些实体之间的关系。
    3. \n
  3. 思考需要提供哪些其他细节，即需要为这些实体添加哪些属性（例如客户姓名）。
    4. \n
  4. 可选：在创建模型之前，使用无代码数据建模工具可视化模型。
    5. \n
  5. 如果满意，可以开始将数据写入数据库。
    6. \n
\n

在这个虚构的场景中，你可以通过以下方式将信息添加到图中：

\n
CREATE (c:Customer {name: "John"})\nCREATE (p:Product {name: "Camera"})\nCREATE (c)-[:BUYS]->(p)\n

然后，你可以通过查询测试这个模型（例如，John 买了什么）：

\n
MATCH (c:Customer {name: "John"})-[b:BUYS]->(p)\nRETURN p\n

请记住，图数据建模是一个迭代的过程。你的初始图数据模型只是一个起点。随着你对用例的深入了解或用例的变化，模型需要进行调整。

\n

此外，你可能会发现，尤其是在图规模扩大时，需要重构模型以确保它与业务需求保持一致。

\n
\n

总结

\n

创建数据模型的过程包括以下步骤：

\n
    \n
  1. 理解领域并为应用程序定义具体的用例（问题）。
    2. \n
  2. 通过提取实体并决定它们之间的关系，开发初始图数据模型。
    3. \n
  3. 根据初始数据模型测试用例。
    4. \n
  4. 使用 Cypher® 创建包含测试数据的图。
    5. \n
  5. 测试用例，包括图的性能。
    6. \n
  6. 由于关键用例的变化或性能原因，重构图数据模型。
    7. \n
\n
\n

持续学习

\n

如果想要更深入地学习数据建模，可以尝试以下资源：

\n\n
","title":"Neo4j官方教程：第19节， 图数据建模是什么","last_reply_at":"2025-04-25T09:11:59.084Z","good":true,"top":false,"reply_count":0,"visit_count":2461,"create_at":"2025-04-25T09:11:59.084Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"6800a9ffa755994623e85dc9","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/cypher-intro/resources/

\n

Cypher 资源

\n

Cypher 基础和文档

\n\n

面向 SQL 开发人员的 Cypher

\n\n

其他资源

\n\n

使用 GRAPHACADEMY 学习

\n

\"badge\"

\n

Cypher 基础课程

\n

本课程通过视频、测验和动手练习,用尽可能少的时间教您使用 Neo4j 强大的查询语言 Cypher 的基础知识。

\n

使用 GraphAcademy 学习 Cypher

\n
","title":"Neo4j官方教程：第18节， Cypher 资源","last_reply_at":"2025-04-17T07:13:03.371Z","good":true,"top":false,"reply_count":0,"visit_count":2679,"create_at":"2025-04-17T07:13:03.371Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"6800a7d2a755994623e85dc8","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/cypher-intro/load-csv/

\n

教程：导入数据

\n

本教程演示如何使用 LOAD CSV 从 CSV 文件导入数据。

\n

通过组合 Cypher® 子句 LOAD CSV、MERGE 和 CREATE，您可以将数据导入到 Neo4j 中。LOAD CSV 允许您访问数据值并对其执行操作。

\n

数据文件

\n

在本教程中，您将从以下 CSV 文件导入数据：

\n

persons.csv 内容:

\n
id,name\n1,Charlie Sheen  \n2,Michael Douglas\n3,Martin Sheen\n4,Morgan Freeman\n

persons.csv 文件包含 id 和 name 两列。每行代表一个人,具有唯一 id 和姓名。

\n

movies.csv 内容:

\n
id,title,country,year\n1,Wall Street,USA,1987\n2,The American President,USA,1995\n3,The Shawshank Redemption,USA,1994\n

movies.csv 文件包含 id、title、country 和 year 列。每行代表一部电影,具有唯一 id、标题、原产国和发行年份。

\n

roles.csv 内容:

\n
personId,movieId,role\n1,1,Bud Fox\n3,1,Carl Fox \n2,1,Gordon Gekko\n3,2,A.J. MacInerney\n2,2,President Andrew Shepherd\n4,3,Ellis Boyd 'Red' Redding\n

roles.csv 文件包含 personId、movieId 和 role 列。每行代表一个角色，包含人物 id(来自 persons.csv)和电影 id(来自 movies.csv)的关系数据。

\n

图模型

\n

数据模型如下所示：

\n

\"image\"(插入图1)

\n

基于 CSV 文件数据的结果图：

\n

\"image\"(插入图2)

\n

前提条件

\n

本教程使用 Linux 或 macOS 压缩包安装。

\n

假设您的当前工作目录是压缩包安装的 <neo4j-home> 目录，且 CSV 文件位于默认导入目录中。

\n

其他安装的默认目录请参见操作手册 → 文件位置。

\n

导入位置可以通过操作手册 → server.directories.import 配置。

\n

准备数据库

\n

导入数据之前，您应该通过创建索引和约束来准备要使用的数据库。

\n

您应该通过在 Person 和 Movie 节点上创建约束来确保它们具有唯一的 id 属性。

\n

创建唯一约束也会隐式创建索引。通过为 id 属性建立索引，节点查找(如通过 MATCH)将快得多。

\n

另外，为 country 名称创建索引以实现快速查找也是个好主意。

\n
    \n
  1. 启动 neo4j：
    2. \n
\n
bin/neo4j start\n

默认用户名是 neo4j，密码是 neo4j。

\n
    \n
  1. 创建约束使每个 Person 节点具有唯一的 id 属性：
    2. \n
\n

使用 Neo4j Browser：

\n
CREATE CONSTRAINT personIdConstraint FOR (person:Person) REQUIRE person.id IS UNIQUE\n

或使用 Neo4j Cypher Shell：

\n
bin/cypher-shell --database=neo4j "CREATE CONSTRAINT personIdConstraint FOR (person:Person) REQUIRE person.id IS UNIQUE"\n
    \n
  1. 创建约束使每个 Movie 节点具有唯一的 id 属性：
    2. \n
\n

使用 Neo4j Browser：

\n
CREATE CONSTRAINT movieIdConstraint FOR (movie:Movie) REQUIRE movie.id IS UNIQUE\n

或使用 Neo4j Cypher Shell：

\n
bin/cypher-shell --database=neo4j "CREATE CONSTRAINT movieIdConstraint FOR (movie:Movie) REQUIRE movie.id IS UNIQUE"\n
    \n
  1. 为 Country 节点的 name 属性创建索引：
    2. \n
\n

使用 Neo4j Browser：

\n
CREATE INDEX FOR (c:Country) ON (c.name)\n

或使用 Neo4j Cypher Shell：

\n
bin/cypher-shell --database=neo4j "CREATE INDEX FOR (c:Country) ON (c.name)"\n

使用 LOAD CSV 导入数据

\n
    \n
  1. 从 persons.csv 文件加载数据：
    2. \n
\n

使用 Neo4j Browser：

\n
LOAD CSV WITH HEADERS FROM "file:///persons.csv" AS csvLine\nCREATE (p:Person {id: toInteger(csvLine.id), name: csvLine.name})\n
    \n
  1. 从 movies.csv 文件加载数据：
    2. \n
\n
LOAD CSV WITH HEADERS FROM "file:///movies.csv" AS csvLine\nMERGE (country:Country {name: csvLine.country})\nCREATE (movie:Movie {id: toInteger(csvLine.id), title: csvLine.title, year:toInteger(csvLine.year)})\nCREATE (movie)-[:ORIGIN]->(country)\n
    \n
  1. 从 roles.csv 文件加载数据：
    2. \n
\n
:auto LOAD CSV WITH HEADERS FROM 'file:///roles.csv' AS csvLine\nCALL {\n WITH csvLine\n MATCH (person:Person {id: toInteger(csvLine.personId)}), (movie:Movie {id: toInteger(csvLine.movieId)})\nCREATE (person)-[:ACTED_IN {role: csvLine.role}]->(movie)\n} IN TRANSACTIONS OF 2 ROWS\n

导入数据

\n

使用以下命令检查具有关系的所有节点：

\n

使用 Neo4j Browser：

\n
MATCH (n)-[r]->(m) RETURN n, r, m\n

或使用 Neo4j Cypher Shell：

\n
bin/cypher-shell --database=neo4j 'MATCH (n)-[r]->(m) RETURN n, r, m'\n

输出将显示所有节点及其关系。

\n
","title":"Neo4j官方教程：第17节， 导入数据","last_reply_at":"2025-04-17T07:03:46.501Z","good":true,"top":false,"reply_count":0,"visit_count":5160,"create_at":"2025-04-17T07:03:46.501Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"67fcc77da755994623e85dc7","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/cypher-intro/procedures-functions/

\n

如何扩展 Cypher

\n

本指南介绍了如何创建、使用和部署用户定义的程序和函数，这是 Cypher®（Neo4j 的查询语言）的扩展机制。

\n

扩展 Cypher

\n

Cypher 是一种强大且富有表达力的语言，具有一流的图模式和集合支持。但有时您需要做更多的事情，如额外的图算法、并行化或自定义转换。

\n

Cypher 可以通过用户定义的程序和函数进行扩展，详见 Java 参考 → 用户定义程序和 Java 参考 → 用户定义函数。

\n

Neo4j 本身提供并使用自定义程序。Neo4j 浏览器公开的许多监控、自检和安全功能都是使用程序实现的。\n\"image\"

\n

Neo4j 中的程序和函数

\n\n

要调用数据库中部署的程序，请使用 CALL 子句(详见 Cypher 手册 → CALL 程序)。

\n

列出和使用 Neo4j 的函数和程序

\n

Neo4j 带有多个内置程序。要了解更多信息，请参阅操作手册 → 程序。

\n

要列出 DBMS 中所有可用的函数和程序，使用以下 Cypher 命令：

\n
SHOW FUNCTIONS\nSHOW PROCEDURES\n

您可以参考 Cypher 速查表以快速了解如何使用这些命令。

\n

每个程序返回一列或多列数据。通过 YIELD 子句，可以选择这些列并设置别名，然后在 Cypher 查询中使用。

\n

像其他 Cypher 管理命令一样，SHOW PROCEDURES 可以与 Cypher 子句的子集一起使用，如下所示，我们按 ‘db.’ 前缀过滤并按名称排序返回结果：

\n
SHOW PROCEDURES\nYIELD name, signature, description as text\nWHERE name STARTS WITH 'db.'\nRETURN * ORDER BY name ASC\n

下面是另一个示例，展示如何按选定的类别（例如包）对可用程序进行分组：

\n
SHOW PROCEDURES \nYIELD name, signature, description\nRETURN split(name,".")[0..-1] AS package, count(*) AS count,\n       collect(split(name,".")[-1]) AS names\nORDER BY count DESC\n

可用程序集取决于您的安装类型和配置设置。结果可能如下：

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
packagecountnames
[“dbms”]20[“checkConfigValue”, “components”, “info”,…]
[“db”]16[“awaitIndex”, “awaitIndexes”, “checkpoint”,…]
[“db”,“stats”]6[“clear”, “collect”, “retrieve”,…]
[“dbms”, “cluster”]6[“checkConnectivity”, “cordonServer”, “protocols”,…]
[“db”, “index”, “fulltext”]4[“awaitEventuallyConsistentIndexRefresh”, “listAvailableAnalyzers”,…]
\n

用户定义的函数用 Java 编写，部署到数据库中，其调用方式与其他 Cypher 函数相同。可以开发和使用两种主要类型的函数：

\n\n

详细信息请参见 Cypher 手册 → 用户定义函数。

\n

您可以将任何程序库部署到自管理服务器，以使用其他程序和函数。

\n

另请查看 Neo4j Java 参考中的程序部分。

\n

部署程序和函数

\n

如果您构建自己的程序或从社区项目下载程序，它们会打包在 JAR 文件中。您可以将该文件复制到 Neo4j 服务器的 $NEO4J_HOME/plugins 目录并重启。

\n

由于程序和函数使用低级 Java API，它们可以访问所有 Neo4j 内部组件以及文件系统和机器。这就是为什么您应该了解部署哪些程序以及原因。只安装来自可信源的程序。如果它们是开源的，请检查其源代码，最好自己构建。

\n

有关如何确保这些附加组件安全性的最佳实践，请参见操作手册 → 保护扩展。

\n

某些程序和函数可用于自管理的 Neo4j 企业版和社区版。\n本节中描述的自定义代码与 AuraDB 不兼容。\n在 Neo4j AuraDB 中，可用的程序和函数仅限于内置程序和函数以及 APOC Core 库的子集。

\n

程序和函数库

\n

APOC Core 库为您提供了一组有用的 Cypher 程序，以增强数据集成、图算法和数据转换等领域的功能。

\n

例如，用于格式化和解析不同分辨率时间戳的函数：

\n
RETURN apoc.date.format(timestamp()) as time,\n       apoc.date.format(timestamp(),'ms','yyyy-MM-dd') as date,\n       apoc.date.parse('13.01.1975','s','dd.MM.yyyy') as unixtime,\n       apoc.date.parse('2017-01-05 13:03:07') as millis\n
\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
timedateunixtimemillis
“2017-01-05 13:06:39”“2017-01-05”1588032001483621387000
\n

在我们的 Neo4j Labs 项目中，您可以找到由社区和员工构建的库集。看看已有的内容，很多需求已经被覆盖，例如：

\n\n

社区和 Neo4j Labs 项目不受官方支持，我们不提供任何 SLA 或向后兼容性和弃用的保证。

\n

开发自己的程序和函数

\n

您可以在 Neo4j Java 参考中找到有关编写和测试程序的详细信息。

\n

示例 GitHub 存储库包含详细的文档和注释，您可以直接克隆并用作起点。

\n

以下是一些初步提示。

\n

用户定义的函数比较简单，让我们从它们开始：

\n\n

用户定义的程序类似：

\n\n

这些特性对两者都有效：

\n\n
","title":"Neo4j官方教程：第16节， 如何扩展 Cypher","last_reply_at":"2025-04-14T08:29:49.725Z","good":true,"top":false,"reply_count":0,"visit_count":2348,"create_at":"2025-04-14T08:29:49.725Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"67fcc47aa755994623e85dc6","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/cypher-intro/dates-datetimes-durations/

\n

日期、日期时间和持续时间

\n

创建和更新值

\n

让我们首先创建一些具有 Datetime 属性的节点。我们可以通过执行以下 Cypher® 查询来执行此操作：

\n
UNWIND [\n    { title: "Cypher Basics I",\n      created: datetime("2019-06-01T18:40:32.142+0100"),\n      datePublished: date("2019-06-01"),\n      readingTime: {minutes: 2, seconds: 15} },\n    { title: "Cypher Basics II",\n      created: datetime("2019-06-02T10:23:32.122+0100"),\n      datePublished: date("2019-06-02"),\n      readingTime: {minutes: 2, seconds: 30} },\n    { title: "Dates, Datetimes, and Durations in Neo4j",\n      created: datetime(),\n      datePublished: date(),\n      readingTime: {minutes: 3, seconds: 30} }\n] AS articleProperties\n\nCREATE (article:Article {title: articleProperties.title})\nSET article.created = articleProperties.created,\n    article.datePublished = articleProperties.datePublished,\n    article.readingTime = duration(articleProperties.readingTime)\n

在此查询中：

\n\n

也许我们想对此文章节点进行一些更改以更新 datePublished 和 readingTime 属性。

\n

我们已决定在下周而不是今天发布该文章，因此我们想进行更改。如果我们想使用支持的格式创建一个新的 Date 类型，我们可以使用以下查询来执行此操作：

\n
MATCH (article:Article {title: "Dates, Datetimes, and Durations in Neo4j"})\nSET article.datePublished = date("2019-09-30")\n

但是，如果我们想基于不支持的格式创建 Date 类型怎么办？为此，我们将使用 APOC 库中的函数来解析字符串。

\n

以下查询将不支持的数据格式解析为基于毫秒的时间戳，从该时间戳创建一个 Datetime，然后从该 Datetime 创建一个 Date：

\n
WITH apoc.date.parse("Sun, 29 September 2019", "ms", "EEE, dd MMMM yyyy") AS ms\nMATCH (article:Article {title: "Dates, Datetimes, and Durations in Neo4j"})\nSET article.datePublished = date(datetime({epochmillis: ms}))\n

我们可以使用相同的方法来更新 created 属性。我们唯一需要更改的是我们不需要将 Datetime 类型转换为 Date：

\n
WITH apoc.date.parse("25 September 2019 06:29:39", "ms", "dd MMMM yyyy HH:mm:ss") AS ms\nMATCH (article:Article {title: "Dates, Datetimes, and Durations in Neo4j"})\nSET article.created = datetime({epochmillis: ms})\n

也许我们还决定阅读时间实际上将比我们最初想象的要多一分钟。我们可以使用以下查询更新 readingTime 属性：

\n
MATCH (article:Article {title: "Dates, Datetimes, and Durations in Neo4j"})\nSET article.readingTime =  article.readingTime + duration({minutes: 1})\n

格式化值

\n

现在我们要编写一个查询来返回我们的文章。我们可以通过执行以下查询来执行此操作：

\n
MATCH (article:Article)\nRETURN article.title AS title,\n       article.created AS created,\n       article.datePublished AS datePublished,\n       article.readingTime AS readingTime\n

表 1. 结果

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
titlecreateddatePublishedreadingTime
“Dates, Datetimes, and Durations in Neo4j”2019-09-25T06:29:39Z2019-09-29P0M0DT270S
\n

如果我们想格式化这些值，我们可以使用 APOC 库中的时间函数。以下查询将每个时间类型格式化为更友好的格式：

\n
MATCH (article:Article)\nRETURN article.title AS title,\n       apoc.temporal.format(article.created, "dd MMMM yyyy HH:mm") AS created,\n       apoc.temporal.format(article.datePublished,"dd MMMM yyyy") AS datePublished,\n       apoc.temporal.format(article.readingTime, "mm:ss") AS readingTime\n

表 2. 结果

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
titlecreateddatePublishedreadingTime
“Dates, Datetimes, and Durations in Neo4j”“25 September 2019 06:29”“29 September 2019”“04:30”
\n

比较和过滤值

\n

如果我们想根据这些时间值过滤我们的文章怎么办？

\n

让我们首先找到 2019 年 6 月 1 日发布的文章。以下查询执行此操作：

\n
MATCH (article:Article)\nWHERE article.datePublished = date({year: 2019, month: 6, day: 1})\nRETURN article.title AS title,\n       article.created AS created,\n       article.datePublished AS datePublished,\n       article.readingTime AS readingTime\n

表 3. 结果

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
titlecreateddatePublishedreadingTime
“Cypher Basics I”2019-06-01T18:40:32.142+01:002019-06-01P0M0DT135S
\n

如果我们想找到 2019 年 6 月发布的所有文章怎么办？我们可以编写以下查询来执行此操作：

\n
MATCH (article:Article)\nWHERE article.datePublished = date({year: 2019, month: 6})\nRETURN article.title AS title,\n       article.created AS created,\n       article.datePublished AS datePublished,\n       article.readingTime AS readingTime\n

如果我们运行此查询，我们将获得以下结果：

\n

表 4. 结果

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
titlecreateddatePublishedreadingTime
“Cypher Basics I”2019-06-01T18:40:32.142+01:002019-06-01P0M0DT135S
\n

这似乎不对 - 2019 年 6 月 2 日发布的 Cypher Basics II 文章呢？我们这里的问题是 date({year: 2019, month:6}) 返回 2019-06-01，所以我们只找到了 2019 年 6 月 1 日发布的文章。

\n

我们需要调整我们的查询以查找 2019 年 6 月 1 日至 2019 年 7 月 1 日之间发布的文章。以下查询执行此操作：

\n
MATCH (article:Article)\nWHERE date({year: 2019, month: 7}) > article.datePublished >= date({year: 2019, month: 6})\nRETURN article.title AS title,\n       article.created AS created,\n       article.datePublished AS datePublished,\n       article.readingTime AS readingTime\n

表 5. 结果

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
titlecreateddatePublishedreadingTime
“Cypher Basics I”2019-06-01T18:40:32.142+01:002019-06-01P0M0DT135S
“Cypher Basics II”2019-06-02T10:23:32.122+01:002019-06-02P0M0DT150S
\n

如果我们想根据 created 属性（存储 Datetime 值）进行过滤怎么办？我们需要在过滤 Datetime 值时采用与处理 Date 值相同的方法。以下查询查找 2019 年 7 月之后创建的文章：

\n
MATCH (article:Article)\nWHERE article.created > datetime({year: 2019, month: 7})\nRETURN article.title AS title,\n       article.created AS created,\n       article.datePublished AS datePublished,\n       article.readingTime AS readingTime\n

表 6. 结果

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
titlecreateddatePublishedreadingTime
“Dates, Datetimes, and Durations in Neo4j”2019-09-25T06:04:39.072Z2019-09-25P0M0DT210S
\n

最后过滤持续时间。我们可能对可以在 3 分钟或更短时间内阅读的文章感兴趣。

\n

我们将从以下查询开始：

\n
MATCH (article:Article)\nWHERE article.readingTime <= duration("PT3M")\nRETURN article.title AS title,\n       article.created AS created,\n       article.datePublished AS datePublished,\n       article.readingTime AS readingTime\n

但是，该查询会导致以下输出：没有更改，没有记录。

\n

如果我们想比较持续时间，我们需要通过将这些持续时间添加到日期来进行比较。我们并不真正关心查询的日期，所以我们将使用当前时间来解决这个问题。我们可以通过调用 datetime() 函数来获取当前时间。

\n

我们更新后的查询如下所示：

\n
MATCH (article:Article)\nWHERE datetime() + article.readingTime <= datetime() + duration("PT3M")\nRETURN article.title AS title,\n       article.created AS created,\n       article.datePublished AS datePublished,\n       article.readingTime AS readingTime\n

表 7. 结果

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
titlecreateddatePublishedreadingTime
“Cypher Basics I”“01 June 2019 18:40”“01 June 2019”“02:15”
“Cypher Basics II”“02 June 2019 10:23”“02 June 2019”“02:30”
\n

资源

\n

本节介绍了如何使用 APOC 库更有效地处理时间类型。以下是有关在 Neo4j 中使用时间类型的更多信息的资源：

\n\n
","title":"Neo4j官方教程：第15节，日期、日期时间和持续时间","last_reply_at":"2025-04-14T08:16:58.841Z","good":true,"top":false,"reply_count":0,"visit_count":2667,"create_at":"2025-04-14T08:16:58.841Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"67fcc2eba755994623e85dc5","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/cypher-intro/schema/

\n

定义模式

\n

示例图

\n

首先创建一些数据以用于我们的示例：

\n
CREATE (forrestGump:Movie {title: 'Forrest Gump', released: 1994})\nCREATE (robert:Person:Director {name: 'Robert Zemeckis', born: 1951})\nCREATE (tom:Person:Actor {name: 'Tom Hanks', born: 1956})\nCREATE (tom)-[:ACTED_IN {roles: ['Forrest']}]->(forrestGump)\nCREATE (robert)-[:DIRECTED]->(forrestGump)\n

这是生成的图：

\n

\"image\"\n(插入图表链接)

\n

使用索引

\n

在图数据库中使用索引的主要原因是找到图遍历的起点。一旦找到该起点，遍历就会依赖于图内结构来实现高性能。

\n\n

以下查询创建一个索引，以加快在数据库中按名称查找演员的速度：

\n
CREATE INDEX example_index_1 FOR (a:Actor) ON (a.name)\n

在大多数情况下，在查询数据时无需指定索引，因为将自动使用适当的索引。

\n

可以使用索引提示在特定查询中指定要使用的索引。这是查询调优的几个选项之一，在 Cypher® 手册 → 查询调优 中有详细描述。

\n

例如，以下查询将自动使用 example_index_1：

\n
MATCH (actor:Actor {name: 'Tom Hanks'})\nRETURN actor\n

复合索引是针对具有特定标签的所有节点的多个属性的索引。例如，以下语句将创建一个复合索引，该索引针对所有带有 Actor 标签并且同时具有 name 和 born 属性的节点。请注意，由于带有 Actor 标签且名称为“Keanu Reeves”的节点没有 born 属性。因此，该节点不会添加到索引中。

\n
CREATE INDEX example_index_2 FOR (a:Actor) ON (a.name, a.born)\n

您可以使用 SHOW INDEXES 查询数据库，以找出定义了哪些索引。

\n
SHOW INDEXES YIELD name, labelsOrTypes, properties, type\n
Rows: 2\n\n+----------------------------------------------------------------+\n| name              | labelsOrTypes | properties       | type    |\n+----------------------------------------------------------------+\n| 'example_index_1' | ['Actor']     | ['name']         | 'BTREE' |\n| 'example_index_2' | ['Actor']     | ['name', 'born'] | 'BTREE' |\n+----------------------------------------------------------------+\n

在 Cypher 手册 → 索引 中了解有关索引的更多信息。

\n

使用约束

\n

约束用于确保数据符合域的规则。例如：

\n

“如果一个节点具有 Actor 标签和 name 属性，则 name 的值在所有具有 Actor 标签的节点中必须是唯一的”。

\n

示例 1. 唯一性约束

\n

此示例显示了如何为具有 Movie 标签和 title 属性的节点创建约束。该约束指定 title 属性必须是唯一的。

\n

添加唯一性约束将隐式地在该属性上添加索引。如果删除约束，但仍然需要索引，则必须显式创建索引。

\n
CREATE CONSTRAINT constraint_example_1 FOR (movie:Movie) REQUIRE movie.title IS UNIQUE\n

Neo4j 4.4 中更改了语法，旧语法是：

\n
CREATE CONSTRAINT constraint_example_1 ON (movie:Movie) ASSERT movie.title IS UNIQUE Deprecated\n

可以将约束添加到数据库中已存在数据的数据库。这要求现有数据符合正在添加的约束。

\n

您可以使用 SHOW CONSTRAINTS Cypher 语法查询数据库以找出定义了哪些约束。

\n

示例 2. 约束查询

\n

此示例显示了一个 Cypher 查询，该查询返回为数据库定义的约束。

\n
SHOW CONSTRAINTS YIELD id, name, type, entityType, labelsOrTypes, properties, ownedIndexId\n
Rows: 1\n\n+-----------------------------------------------------------------------------------------------------+\n| id | name                   | type         | entityType | labelsOrTypes | properties | ownedIndexId |\n+-----------------------------------------------------------------------------------------------------+\n| 4  | 'constraint_example_1' | 'UNIQUENESS' | 'NODE'     | ['Movie']     | ['title']  | 3            |\n+-----------------------------------------------------------------------------------------------------+\n

上述约束适用于所有版本的 Neo4j。其他约束可用于 Neo4j 企业版。

\n

在 Cypher 手册 → 约束 中了解有关约束的更多信息。

\n

Similar code found with 2 license types

\n
","title":"Neo4j官方教程：第14节，定义模式","last_reply_at":"2025-04-14T08:10:19.597Z","good":true,"top":false,"reply_count":0,"visit_count":2453,"create_at":"2025-04-14T08:10:19.597Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"67fcc245a755994623e85dc4","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/cypher-intro/subqueries/

\n

Cypher 中的子查询

\n

回顾我们的示例图

\n

我们所有的代码示例将继续使用我们之前使用过的其中一个图示例，但包括更多数据以用于此页面上的查询。下图是新图，一个由人员、他们工作的公司以及他们喜欢的技术组成的网络。

\n

我们添加了一个 Person 节点（蓝色），该节点 WORKS_FOR 一个 Company 节点（红色）并且 LIKES 一个 Technology 节点（绿色）：Ryan 为 Company Z 工作并且喜欢 Python。您可以在图的右侧找到此数据。

\n

回顾一下，每个人也可能与其他人有多个 IS_FRIENDS_WITH 关系。

\n

\"image\"

\n

图 1. 人员、他们工作的公司以及他们喜欢的技术的网络

\n

您可以使用以下 Cypher® 查询创建此数据集：

\n
CREATE (diana:Person {name: "Diana"})-[:LIKES]->(query:Technology {type: "Query Languages"})\nCREATE (melissa:Person {name: "Melissa", twitter: "@melissa"})-[:LIKES]->(query)\nCREATE (dan:Person {name: "Dan", twitter: "@dan", yearsExperience: 6})-[:LIKES]->(etl:Technology {type: "Data ETL"})<-[:LIKES]-(melissa)\nCREATE (xyz:Company {name: "XYZ"})<-[:WORKS_FOR]-(sally:Person {name: "Sally", yearsExperience: 4})-[:LIKES]->(integrations:Technology {type: "Integrations"})<-[:LIKES]-(dan)\nCREATE (sally)<-[:IS_FRIENDS_WITH]-(john:Person {name: "John", yearsExperience: 5, birthdate: "1985-04-04"})-[:LIKES]->(java:Technology {type: "Java"})\nCREATE (john)<-[:IS_FRIENDS_WITH]-(jennifer:Person {name: "Jennifer", twitter: "@jennifer", yearsExperience: 5, birthdate: "1988-01-01"})-[:LIKES]->(java)\nCREATE (john)-[:WORKS_FOR]->(xyz)\nCREATE (sally)<-[:IS_FRIENDS_WITH]-(jennifer)-[:IS_FRIENDS_WITH]->(melissa)\nCREATE (joe:Person {name: "Joe", birthdate: "1988-08-08"})-[:LIKES]->(query)\nCREATE (mark:Person {name: "Mark", twitter: "@mark"})\nCREATE (ann:Person {name: "Ann"})\nCREATE (x:Company {name: "Company X"})<-[:WORKS_FOR]-(diana)<-[:IS_FRIENDS_WITH]-(joe)-[:IS_FRIENDS_WITH]->(mark)-[:LIKES]->(graphs:Technology {type: "Graphs"})<-[:LIKES]-(jennifer)-[:WORKS_FOR]->(:Company {name: "Neo4j"})\nCREATE (ann)<-[:IS_FRIENDS_WITH]-(jennifer)-[:IS_FRIENDS_WITH]->(mark)\nCREATE (john)-[:LIKES]->(:Technology {type: "Application Development"})<-[:LIKES]-(ann)-[:IS_FRIENDS_WITH]->(dan)-[:WORKS_FOR]->(abc:Company {name: "ABC"})\nCREATE (ann)-[:WORKS_FOR]->(abc)\nCREATE (a:Company {name: "Company A"})<-[:WORKS_FOR]-(melissa)-[:LIKES]->(graphs)<-[:LIKES]-(diana)\nCREATE (:Technology {type: "Python"})<-[:LIKES]-(:Person {name: "Ryan"})-[:WORKS_FOR]->(:Company {name: "Company Z"})\n

子查询简介

\n

子查询是在 Neo4j 4.0 中引入的。

\n

有关如何使用它们的详细信息，请转到 Cypher 手册 → 子查询。

\n

以下类型的子查询在 Neo4j 中是可能的：

\n\n

EXISTS、COUNT 和 CALL {…​} 子查询在本节中介绍。

\n

要了解有关使用 CALL {…​} IN TRANSACTIONS 的更多信息，请参阅以下教程中的代码示例，了解如何将 CSV 数据导入到 Neo4j 数据库中：

\n\n

COLLECT 子查询是在 Neo4j 5.6 中引入的。这是一种新型的子查询，用于将子查询的结果收集到列表中，以便可以执行进一步的操作，如 DISTINCT、ORDER BY、LIMIT 和 SKIP。COLLECT 子查询与 COUNT 和 EXISTS 子查询的不同之处在于，最终的 RETURN 子句是强制性的。COLLECT 子查询中的 RETURN 子句必须只返回一列。

\n

Cypher 子查询

\n

子查询是在其自身范围内执行的一组 Cypher 语句。子查询通常从外部封闭查询中调用。

\n

以下是关于子查询的一些重要事项：

\n\n

在获取正确的结果一章的过滤模式部分中，您学习了如何基于模式进行过滤。例如，您可以编写以下查询来查找为 Neo4j 工作的人的朋友：

\n
MATCH (p:Person)-[r:IS_FRIENDS_WITH]->(friend:Person)\nWHERE exists((p)-[:WORKS_FOR]->(:Company {name: 'Neo4j'}))\nRETURN p, r, friend\n

如果您在 Neo4j 浏览器中运行此查询，将返回以下图：

\n

\"image\"

\n

图 2. 图格式的输出

\n

Cypher 子查询支持更强大的模式过滤。您可以不使用 WHERE 子句中的 exists 函数，而是使用 EXISTS 子查询。您可以使用以下查询重现前面的示例：

\n
MATCH (p:Person)-[r:IS_FRIENDS_WITH]->(friend:Person)\nWHERE EXISTS {\n  MATCH (p)-[:WORKS_FOR]->(:Company {name: 'Neo4j'})\n}\nRETURN p, r, friend\n

您将获得相同的结果，这很好，但到目前为止，您所实现的只是用更多的代码做同样的事情！

\n

接下来，让我们编写一个子查询，该子查询的过滤能力比单独使用 WHERE 子句或 exists 函数所能实现的更强大。

\n

假设：

\n\n

您可以尝试使用以下查询来回答这个问题：

\n
MATCH (person:Person)-[:WORKS_FOR]->(company)\nWHERE company.name STARTS WITH "Company"\nAND (person)-[:LIKES]->(t:Technology)\nAND COUNT { (t)<-[:LIKES]-() } >= 3\nRETURN person.name as person, company.name AS company;\n

如果您运行此查询，您将看到以下输出：

\n
Variable `t` not defined (line 4, column 25 (offset: 112))\n"AND (person)-[:LIKES]->(t:Technology)"\n                         ^\n

您可以找到喜欢某项技术的人，但您无法检查是否至少有其他三个人也喜欢该技术，因为变量 t 不在 WHERE 子句的范围内。让我们将两个 AND 语句移动到 EXISTS 子查询块中，从而得到以下查询：

\n
MATCH (person:Person)-[:WORKS_FOR]->(company)\nWHERE company.name STARTS WITH "Company"\nAND EXISTS {\n  MATCH (person)-[:LIKES]->(t:Technology)\n  WHERE COUNT { (t)<-[:LIKES]-() } >= 3\n}\nRETURN person.name as person, company.name AS company;\n

现在您可以成功运行查询，该查询返回以下结果：

\n
person\tcompany\n"Melissa"\t"CompanyA"\n"Diana"\t"CompanyX"\n

如果您回忆起本指南开头的图可视化，Ryan 是唯一另一个为名称以“Company”开头的公司工作的人。他已在此查询中被过滤掉，因为他喜欢的唯一技术是 Python，并且没有其他三个人喜欢 Python。

\n

结果返回子查询

\n

到目前为止，您已经学习了如何使用子查询来过滤掉结果，但这并没有完全显示它们的强大功能。您还可以使用子查询来返回结果。

\n

假设您要编写一个查询，查找喜欢 Java 或有多个朋友的人。除此之外，您希望按出生日期降序对结果进行排序。这可以使用 UNION 子句和 COUNT 子查询部分实现：

\n
MATCH (p:Person)-[:LIKES]->(:Technology {type: "Java"})\nRETURN p.name AS person, p.birthdate AS dob\nORDER BY dob DESC\n\nUNION\n\nMATCH (p:Person)\nWHERE COUNT { (p)-[:IS_FRIENDS_WITH]->() } > 1\nRETURN p.name AS person, p.birthdate AS dob\nORDER BY dob DESC;\n

如果您运行该查询，您将看到以下输出：

\n
person\tdob\n"Jennifer"\t"1988-01-01"\n"John"\t"1985-04-04"\n"Joe"\t"1988-08-08"\n

您得到了正确的人。但是 UNION 方法只允许我们按 UNION 子句对结果进行排序，而不是对所有行进行排序。

\n

您可以尝试另一种方法，即分别执行每个子查询，并使用 collect() 函数从每个部分收集人员。有些人喜欢 Java 并且有多个朋友，因此您需要在 RETURN 子句中使用 DISTINCT 运算符来删除重复项：

\n
// Find people who like Java\nMATCH (p:Person)-[:LIKES]->(:Technology {type: "Java"})\nWITH collect(p) AS peopleWhoLikeJava\n\n// Find people with more than one friend\nMATCH (p:Person)\nWHERE COUNT { (p)-[:IS_FRIENDS_WITH]->() } > 1\nWITH collect(p) AS popularPeople, peopleWhoLikeJava\nWITH popularPeople + peopleWhoLikeJava AS people\n\n// Unpack the collection of people and order by birthdate\nUNWIND people AS p\nRETURN DISTINCT p.name AS person, p.birthdate AS dob\nORDER BY dob DESC\n

如果您运行该查询，您将获得以下输出：

\n
person\tdob\n"Joe"\t"1988-08-08"\n"Jennifer"\t"1988-01-01"\n"John"\t"1985-04-04"\n

这种方法有效，但更难编写，因为您必须不断地将查询的各个部分传递到它的下一部分。

\n

CALL {…​} 子句为您提供了两全其美的优势：

\n\n

我们使用 CALL {…​} 子句的查询如下所示：

\n
CALL {\n\tMATCH (p:Person)-[:LIKES]->(:Technology {type: "Java"})\n\tRETURN p\n\n\tUNION\n\n\tMATCH (p:Person)\n\tWHERE COUNT { (p)-[:IS_FRIENDS_WITH]->() } > 1\n\tRETURN p\n}\nRETURN p.name AS person, p.birthdate AS dob\nORDER BY dob DESC;\n

如果您运行该查询，您将获得以下输出：

\n
person\tdob\n"Joe"\t"1988-08-08"\n"Jennifer"\t"1988-01-01"\n"John"\t"1985-04-04"\n

您可以进一步扩展查询以返回这些人喜欢的技术以及他们拥有的朋友。以下查询显示了如何执行此操作：

\n
CALL {\n\tMATCH (p:Person)-[:LIKES]->(:Technology {type: "Java"})\n\tRETURN p\n\n\tUNION\n\n\tMATCH (p:Person)\n\tWHERE COUNT { (p)-[:IS_FRIENDS_WITH]->() } > 1\n\tRETURN p\n}\nWITH p,\n     [(p)-[:LIKES]->(t) | t.type] AS technologies,\n     [(p)-[:IS_FRIENDS_WITH]->(f) | f.name] AS friends\n\nRETURN p.name AS person, p.birthdate AS dob, technologies, friends\nORDER BY dob DESC;\n
person\tdob\ttechnologies\tfriends\n"Joe"\t"1988-08-08"\t["Query Languages"]\t["Mark", "Diana"]\n"Jennifer"\t"1988-01-01"\t["Graphs", "Java"]\t["Sally", "Mark", "John", "Ann", "Melissa"]\n"John"\t"1985-04-04"\t["Java", "Application Development"]\t["Sally"]\n

您还可以将聚合函数应用于子查询的结果。以下查询返回喜欢 Java 或有多个朋友的人中最年轻和最年长的人。

\n
CALL {\n\tMATCH (p:Person)-[:LIKES]->(:Technology {type: "Java"})\n\tRETURN p\n\n\tUNION\n\n\tMATCH (p:Person)\n\tWHERE COUNT { (p)-[:IS_FRIENDS_WITH]->() } > 1\n\tRETURN p\n}\nRETURN min(p.birthdate) AS oldest, max(p.birthdate) AS youngest\n
oldest\tyoungest\n"1985-04-04"\t"1988-08-08"\n

总结

\n

您已经了解了如何使用 EXISTS {} 子查询编写复杂的过滤模式，以及如何使用 CALL {} 子句执行返回结果的子查询。

\n

Similar code found with 1 license type

\n
","title":"Neo4j官方教程：第13节， Cypher 中的子查询","last_reply_at":"2025-04-14T08:07:33.738Z","good":true,"top":false,"reply_count":0,"visit_count":2647,"create_at":"2025-04-14T08:07:33.738Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"67f869905885e744204e1839","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/cypher-intro/large-statements/

\n

编写大型语句

\n

示例图

\n

我们继续使用与之前相同的示例数据：

\n
CREATE (matrix:Movie {title: 'The Matrix', released: 1997})\nCREATE (cloudAtlas:Movie {title: 'Cloud Atlas', released: 2012})\nCREATE (forrestGump:Movie {title: 'Forrest Gump', released: 1994})\nCREATE (keanu:Person {name: 'Keanu Reeves', born: 1964})\nCREATE (robert:Person {name: 'Robert Zemeckis', born: 1951})\nCREATE (tom:Person {name: 'Tom Hanks', born: 1956})\nCREATE (tom)-[:ACTED_IN {roles: ['Forrest']}]->(forrestGump)\nCREATE (tom)-[:ACTED_IN {roles: ['Zachry']}]->(cloudAtlas)\nCREATE (robert)-[:DIRECTED]->(forrestGump)\n

这是生成的图：\n\"image\"\n(插入图表链接)

\n

图 1. 电影图

\n

UNION

\n

如果要组合具有相同结果结构的两个语句的结果，可以使用 UNION [ALL]。

\n

例如，以下查询列出了演员和导演：

\n
MATCH (actor:Person)-[r:ACTED_IN]->(movie:Movie)\nRETURN actor.name AS name, type(r) AS type, movie.title AS title\nUNION\nMATCH (director:Person)-[r:DIRECTED]->(movie:Movie)\nRETURN director.name AS name, type(r) AS type, movie.title AS title\n
Rows: 3\n\n+-------------------------------------------------+\n| name              | type       | title          |\n+-------------------------------------------------+\n| 'Tom Hanks'       | 'ACTED_IN' | 'Cloud Atlas'  |\n| 'Tom Hanks'       | 'ACTED_IN' | 'Forrest Gump' |\n| 'Robert Zemeckis' | 'DIRECTED' | 'Forrest Gump' |\n+-------------------------------------------------+\n

请注意，返回的列必须在所有子句中以相同的方式设置别名。

\n

上面的查询等效于这个更紧凑的查询：

\n
MATCH (actor:Person)-[r:ACTED_IN|DIRECTED]->(movie:Movie)\nRETURN actor.name AS name, type(r) AS type, movie.title AS title\n

WITH

\n

在 Cypher® 中，您可以将语句片段链接在一起，类似于在数据流管道中完成的方式。每个片段都处理前一个片段的输出，并且其结果可以馈送到下一个片段中。只有在 WITH 子句中声明的列才在后续查询部分中可用。

\n

WITH 子句用于组合各个部分并声明数据从一个部分流向另一个部分。WITH 类似于 RETURN 子句。不同之处在于 WITH 子句不会完成查询，而是为下一部分准备输入。表达式、聚合、排序和分页可以以与 RETURN 子句相同的方式使用。唯一的区别是所有列都必须设置别名。

\n

在以下示例中，收集某人出演的电影，然后过滤掉仅出现在一部电影中的电影。

\n
MATCH (person:Person)-[:ACTED_IN]->(m:Movie)\nWITH person, count(*) AS appearances, collect(m.title) AS movies\nWHERE appearances > 1\nRETURN person.name, appearances, movies\n
Rows: 1\n\n+-------------------------------------------------------------+\n| person.name | appearances | movies                          |\n+-------------------------------------------------------------+\n| 'Tom Hanks' | 2           | ['Cloud Atlas', 'Forrest Gump'] |\n+-------------------------------------------------------------+\n

使用 WITH 子句，您可以将值从查询的一部分传递到另一部分。这允许您在查询中执行一些中间计算或操作以供以后使用。

\n

以下数据集用于演示下面的示例：\n\"image\"\n(插入图表链接)

\n

图 2. 图：人员、他们喜欢的技术以及他们工作的公司

\n

要重现该图，请运行 Cypher 代码：

\n
CREATE (diana:Person {name: "Diana"})\nCREATE (melissa:Person {name: "Melissa", twitter: "@melissa"})\nCREATE (dan:Person {name: "Dan", twitter: "@dan", yearsExperience: 6})\nCREATE (sally:Person {name: "Sally", yearsExperience: 4})\nCREATE (john:Person {name: "John", twitter: "@jennifer", yearsExperience: 5})\nCREATE (joe:Person {name: "Joe"})\nCREATE (mark:Person {name: "Mark", twitter: "@mark"})\nCREATE (ann:Person {name: "Ann"})\nCREATE (xyz:Company {name: "XYZ"})\nCREATE (x:Company {name: "Company X"})\nCREATE (a:Company {name: "Company A"})\nCREATE (Neo4j:Company {name: "Neo4j"})\nCREATE (abc:Company {name: "ABC"})\nCREATE (query:Technology {type: "Query Languages"})\nCREATE (etl:Technology {type: "Data ETL"})\nCREATE (integrations:Technology {type: "Integrations"})\nCREATE (graphs:Technology {type: "Graphs"})\nCREATE (dev:Technology {type: "Application Development"})\nCREATE (java:Technology {type: "Java"})\nCREATE (diana)-[:LIKES]->(query)\nCREATE (melissa)-[:LIKES]->(query)\nCREATE (dan)-[:LIKES]->(etl)<-[:LIKES]-(melissa)\nCREATE (xyz)<-[:WORKS_FOR]-(sally)-[:LIKES]->(integrations)<-[:LIKES]-(dan)\nCREATE (sally)<-[:IS_FRIENDS_WITH]-(john)-[:LIKES]->(java)\nCREATE (john)<-[:IS_FRIENDS_WITH]-(jennifer)-[:LIKES]->(java)\nCREATE (john)-[:WORKS_FOR]->(xyz)\nCREATE (sally)<-[:IS_FRIENDS_WITH]-(jennifer)-[:IS_FRIENDS_WITH]->(melissa)\nCREATE (joe)-[:LIKES]->(query)\nCREATE (x)<-[:WORKS_FOR]-(diana)<-[:IS_FRIENDS_WITH]-(joe)-[:IS_FRIENDS_WITH]->(mark)-[:LIKES]->(graphs)<-[:LIKES]-(jennifer)-[:WORKS_FOR]->(Neo4j)\nCREATE (ann)<-[:IS_FRIENDS_WITH]-(jennifer)-[:IS_FRIENDS_WITH]->(mark)\nCREATE (john)-[:LIKES]->(dev)<-[:LIKES]-(ann)-[:IS_FRIENDS_WITH]->(dan)-[:WORKS_FOR]->(abc)\nCREATE (ann)-[:WORKS_FOR]->(abc)\nCREATE (a)<-[:WORKS_FOR]-(melissa)-[:LIKES]->(graphs)<-[:LIKES]-(diana)\n

您必须在 WITH 子句中指定您以后要使用的变量。只有这些变量会传递到查询的下一部分。有多种方法可以使用此功能（例如，计数、收集、过滤、限制结果）。

\n

有关如何使用 WITH 的更多信息，请参阅 Cypher 手册部分。

\n
//Query1: find and list the technologies people like\nMATCH (a:Person)-[r:LIKES]-(t:Technology)\nWITH a.name AS name, collect(t.type) AS technologies\nRETURN name, technologies;\n

Query1 结果：

\n
Rows: 9\n\n+----------------------------------------------------------+\n| name        | technologies                               |\n+----------------------------------------------------------+\n| 'Sally'     | ['Integrations']                           |\n| 'Dan'       | ['Data ETL', 'Integrations']               |\n| 'John'      | ['Java', 'Application Development']        |\n| 'Diana'     | ['Query Languages', 'Graphs']              |\n| 'Jennifer'  | ['Java', 'Graphs']                         |\n| 'Ann'       | ['Application Development']                |\n| 'Mark'      | ['Graphs']                                 |\n| 'Joe'       | ['Query Languages']                        |\n| 'Melissa'   | ['Query Languages', 'Data ETL', 'Graphs']  |\n+----------------------------------------------------------+\n
//Query2: find number of friends who have other friends\nMATCH (p:Person)-[:IS_FRIENDS_WITH]->(friend:Person)\nWITH p, collect(friend.name) AS friendsList, count{(friend)-[:IS_FRIENDS_WITH]-(:Person)} AS numberOfFoFs\nWHERE numberOfFoFs > 1\nRETURN p.name, friendsList, numberOfFoFs;\n

Query2 结果：

\n
Rows: 3\n\n+---------------------------------------------------+-----------------+\n| p.name        | friendList                        | numberOfFoFs    |\n+---------------------------------------------------+-----------------+\n| 'Joe'         | ['Mark']                          | 2               |\n| 'Jennifer'    | ['Sally', 'John', 'Ann', 'Mark']  | 2               |\n| 'John'        | ['Sally']                         | 2               |\n+---------------------------------------------------+-----------------+\n

在第一个查询中，传递了人员姓名和收集的技术类型列表。因此，只有这些项目可以在 RETURN 子句中引用。关系 ® 和人员出生日期都不能使用，因为这些值没有传递。

\n

在第二个查询中，只能引用 p 及其任何属性（姓名、出生日期、工作年限、Twitter）、朋友的集合（作为一个整体，而不是每个值）以及朋友的朋友的数量。由于这些值已在 WITH 子句中传递，因此可以在 WHERE 或 RETURN 子句中使用它们。

\n

WITH 要求传递的所有值都具有变量（如果它们还没有变量）。Person 节点在 MATCH 子句中被赋予变量 §，因此不需要在那里分配变量。

\n

WITH 对于在查询之前设置参数也非常有用。在导入数据时，通常对参数键、URL 字符串和其他查询变量很有用。

\n
//Find people with 2-6 years of experience\nWITH 2 AS experienceMin, 6 AS experienceMax\nMATCH (p:Person)\nWHERE experienceMin <= p.yearsExperience <= experienceMax\nRETURN p\n
","title":"Neo4j官方教程：第12节，编写大型语句","last_reply_at":"2025-04-11T01:00:00.228Z","good":true,"top":false,"reply_count":0,"visit_count":2464,"create_at":"2025-04-11T01:00:00.228Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"67f867115885e744204e1838","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自:https://neo4j.com/docs/getting-started/cypher-intro/updating/

\n

更新数据

\n

之前您学习了如何在 Cypher® 中表示节点、关系、标签、属性和模式。本节通过介绍如何使用 Cypher 更新和删除数据，在您的知识中添加另一个层次。

\n

虽然这些是标准的 CRUD（创建、读取、更新和删除）操作，但与在其他类型的数据库中相比，某些功能在图中有所不同。当我们进行时，您可能会认识到一些相似之处和不同之处。

\n

使用 Cypher 更新数据

\n

您可能已经在数据中有一个节点或关系，但您想修改其属性。您可以通过匹配要查找的模式并使用 SET 关键字来添加、删除或更新属性来执行此操作。

\n

我们继续使用以下数据集：\n\"image\"

\n

图 1. 图：人员、他们工作的公司以及他们喜欢的技术

\n

要创建上述图，请运行 Cypher 查询：

\n
CREATE (diana:Person {name: "Diana"})\nCREATE (melissa:Person {name: "Melissa", twitter: "@melissa"})\nCREATE (dan:Person {name: "Dan", twitter: "@dan", yearsExperience: 6})\nCREATE (sally:Person {name: "Sally", yearsExperience: 4})\nCREATE (john:Person {name: "John", yearsExperience: 5})\nCREATE (jennifer:Person {name: "Jennifer", twitter: "@jennifer", yearsExperience: 5})\nCREATE (joe:Person {name: "Joe"})\nCREATE (mark:Person {name: "Mark", twitter: "@mark"})\nCREATE (ann:Person {name: "Ann"})\nCREATE (xyz:Company {name: "XYZ"})\nCREATE (x:Company {name: "Company X"})\nCREATE (a:Company {name: "Company A"})\nCREATE (Neo4j:Company {name: "Neo4j"})\nCREATE (abc:Company {name: "ABC"})\nCREATE (query:Technology {type: "Query Languages"})\nCREATE (etl:Technology {type: "Data ETL"})\nCREATE (integrations:Technology {type: "Integrations"})\nCREATE (graphs:Technology {type: "Graphs"})\nCREATE (dev:Technology {type: "Application Development"})\nCREATE (java:Technology {type: "Java"})\nCREATE (diana)-[:LIKES]->(query)\nCREATE (melissa)-[:LIKES]->(query)\nCREATE (dan)-[:LIKES]->(etl)<-[:LIKES]-(melissa)\nCREATE (xyz)<-[:WORKS_FOR]-(sally)-[:LIKES]->(integrations)<-[:LIKES]-(dan)\nCREATE (sally)<-[:IS_FRIENDS_WITH]-(john)-[:LIKES]->(java)\nCREATE (john)<-[:IS_FRIENDS_WITH]-(jennifer)-[:LIKES]->(java)\nCREATE (john)-[:WORKS_FOR]->(xyz)\nCREATE (sally)<-[:IS_FRIENDS_WITH]-(jennifer)-[:IS_FRIENDS_WITH]->(melissa)\nCREATE (joe)-[:LIKES]->(query)\nCREATE (x)<-[:WORKS_FOR]-(diana)<-[:IS_FRIENDS_WITH]-(joe)-[:IS_FRIENDS_WITH]->(mark)-[:LIKES]->(graphs)<-[:LIKES]-(jennifer)-[:WORKS_FOR]->(Neo4j)\nCREATE (ann)<-[:IS_FRIENDS_WITH]-(jennifer)-[:IS_FRIENDS_WITH]->(mark)\nCREATE (john)-[:LIKES]->(dev)<-[:LIKES]-(ann)-[:IS_FRIENDS_WITH]->(dan)-[:WORKS_FOR]->(abc)\nCREATE (ann)-[:WORKS_FOR]->(abc)\nCREATE (a)<-[:WORKS_FOR]-(melissa)-[:LIKES]->(graphs)<-[:LIKES]-(diana)\n

到目前为止，使用上面的示例数据集，您可以更新 Jennifer 的节点以添加她的出生日期。下一个 Cypher 语句显示了如何执行此操作。

\n\n
MATCH (p:Person {name: 'Jennifer'})\nSET p.birthdate = date('1980-01-01')\nRETURN p\n

查询结果：

\n
Set Properties: 1\nRows: 1\n\n+------------------------------------------------------+\n| p                                                    |\n+------------------------------------------------------+\n|(Person: {birthdate: '1980-01-01', name: 'Jennifer'}) |\n+------------------------------------------------------+\n

有关使用 date() 和其他时间函数的更多信息，请访问 Cypher 手册 → 时间函数。

\n

如果要更改 Jennifer 的出生日期，可以使用上面的同一查询再次找到 Jennifer 的节点，并在 SET 子句中放入不同的日期。

\n

您还可以使用 Company 节点更新 Jennifer 的 WORKS_FOR 关系，以包括她开始在那里工作的年份。为此，您可以使用与上面类似的语法来更新节点。

\n
MATCH (:Person {name: 'Jennifer'})-[rel:WORKS_FOR]-(:Company {name: 'Neo4j'})\nSET rel.startYear = date({year: 2018})\nRETURN rel\n

查询结果：

\n
Set Properties: 1\nRows: 1\n\n+-----------------------------------------+\n| rel                                     |\n+-----------------------------------------+\n| [:WORKS_FOR {startYear: '2018-01-01'}]  |\n+-----------------------------------------+\n

如果要返回上述查询的图视图，可以将变量添加到节点 p:Person 和 c:Company，并将返回行写为 RETURN p, rel, c。

\n

使用 Cypher 删除数据

\n

要介绍的另一个操作是如何在 Cypher 中删除数据。对于此操作，Cypher 使用 DELETE 关键字删除节点和关系。它与其他语言（如 SQL）中删除数据非常相似，但有一个例外。

\n

由于 Neo4j 符合 ACID，因此如果节点仍具有关系，则无法删除该节点。如果可以这样做，那么您最终可能会得到指向空的关系和不完整的图。

\n

删除关系

\n

要删除关系，您需要找到要删除的关系的开始和结束节点，然后使用 DELETE 关键字，如下面的代码块所示。让我们继续删除 Jennifer 和 Mark 之间的 IS_FRIENDS_WITH 关系。我们稍后将在练习中重新添加此关系。

\n
MATCH (j:Person {name: 'Jennifer'})-[r:IS_FRIENDS_WITH]->(m:Person {name: 'Mark'})\nDELETE r\n

查询结果：

\n
+-----------------------------------------+\n| Deleted Relationships: 1                |\n| Rows: 0                                 |\n+-----------------------------------------+\n

删除节点

\n

要删除没有任何关系的节点，您需要找到要删除的节点，然后使用 DELETE 关键字，就像您对上面的关系所做的那样。您可以暂时删除 Mark 的节点，稍后再将其恢复。

\n
MATCH (m:Person {name: 'Mark'})\nDELETE m\n

查询结果：

\n
+-----------------------------------------+\n| Deleted Nodes: 1                        |\n| Rows: 0                                 |\n+-----------------------------------------+\n

如果您错误地创建了一个空节点并且需要删除它，您可以使用以下 Cypher 语句来执行此操作：

\n
MATCH (n)\nWHERE id(n) = 5\nDETACH DELETE n\n

此语句不仅删除节点，还删除它具有的所有关系。要运行该语句，您应该知道节点的内部 ID。

\n

删除节点及其关系

\n

您可以运行单个语句来删除节点及其关系，而不是运行最后两个查询来删除 IS_FRIENDS_WITH 关系和 Mark 的 Person 节点。如上所述，Neo4j 符合 ACID，因此不允许删除仍具有关系的节点。使用 DETACH DELETE 语法告诉 Cypher 删除节点具有的任何关系，并删除节点本身。

\n

该语句如下面的代码所示。首先，您在数据库中找到 Mark 的节点。然后，DETACH DELETE 行删除 Mark 节点具有的任何现有关系，然后再删除该节点。

\n
MATCH (m:Person {name: 'Mark'})\nDETACH DELETE m\n

删除属性

\n

您还可以删除属性，但您可以使用其他几种方法，而不是使用 DELETE 关键字。

\n\n

为了向您展示这两种选择，让我们看一下每种方法的代码。

\n
//delete property using REMOVE keyword\nMATCH (n:Person {name: 'Jennifer'})\nREMOVE n.birthdate\n\n//delete property with SET to null value\nMATCH (n:Person {name: 'Jennifer'})\nSET n.birthdate = null\n

查询结果：

\n
+-----------------------------------------+\n| Set Properties: 1                       |\n| Rows: 0                                 |\n+-----------------------------------------+\n

使用 MERGE 避免重复数据

\n

前面简要提到了 Cypher 中有一些方法可以避免创建重复数据。其中一种方法是使用 MERGE 关键字。MERGE 执行“选择或插入”操作，该操作首先检查数据库中是否存在数据。如果存在，则 Cypher 按原样返回它，或者对现有节点或关系进行您指定的任何更新。如果数据不存在，则 Cypher 将使用您指定的信息创建它。

\n

在节点上使用 MERGE

\n

首先，让我们通过使用下面的查询将 Mark 添加回我们的数据库来查看一个示例。您可以使用 MERGE 来确保 Cypher 检查数据库中是否存在 Mark 的现有节点。由于您在前面的示例中删除了 Mark 的节点，因此 Cypher 将找不到现有匹配项，并将使用设置为“Mark”的名称属性创建一个新节点。

\n
MERGE (mark:Person {name: 'Mark'})\nRETURN mark\n

查询结果：\n\"image\"\n(插入图表链接)

\n

如果再次运行相同的语句，Cypher 这次将找到一个名称属性设置为 Mark 的现有节点，因此它将返回匹配的节点，而不会进行任何更改。

\n

在关系上使用 MERGE

\n

就像您使用 MERGE 在 Cypher 中查找或创建节点一样，您可以执行相同的操作来查找或创建关系。让我们重新创建我们在先前示例中拥有的 Mark 和 Jennifer 之间的 IS_FRIENDS_WITH 关系。

\n
MATCH (j:Person {name: 'Jennifer'})\nMATCH (m:Person {name: 'Mark'})\nMERGE (j)-[r:IS_FRIENDS_WITH]->(m)\nRETURN j, r, m\n

请注意，此处使用 MATCH 在使用 MERGE 查找或创建它们之间关系之前查找 Mark 的节点和 Jennifer 的节点。

\n

为什么我们不使用单个语句？

\n

MERGE 查找您指定的整个模式，以查看是返回现有模式还是创建新模式。如果整个模式（节点、关系和任何指定的属性）不存在，则 Cypher 会创建它。

\n

Cypher 永远不会在模式中产生匹配和创建的部分混合。为避免匹配和创建的混合，您需要在对可能要创建的任何元素执行合并之前，首先匹配模式的任何现有元素，就像我们在上面的语句中所做的那样。\n\"image\"\n(插入图表链接)

\n

仅供参考，导致重复项的 Cypher 语句如下。由于此模式（Jennifer IS_FRIENDS_WITH Mark）在数据库中不存在，因此 Cypher 会创建一个全新的模式 - 两个节点以及它们之间的关系。

\n
//this statement will create duplicate nodes for Mark and Jennifer\nMERGE (j:Person {name: 'Jennifer'})-[r:IS_FRIENDS_WITH]->(m:Person {name: 'Mark'})\nRETURN j, r, m\n

处理 MERGE 标准

\n

也许您想使用 MERGE 来确保您不创建重复项，但是如果创建了模式，您想初始化某些属性，如果仅匹配了模式，则要更新其他属性。在这种情况下，您可以将 ON CREATE 或 ON MATCH 与 SET 关键字一起使用来处理这些情况。

\n

让我们看一个例子。

\n
MERGE (m:Person {name: 'Mark'})-[r:IS_FRIENDS_WITH]-(j:Person {name:'Jennifer'})\n  ON CREATE SET r.since = date('2018-03-01')\n  ON MATCH SET r.updated = date()\nRETURN m, r, j\n

资源

\n\n
","title":"Neo4j官方教程：第11节，更新数据","last_reply_at":"2025-04-11T00:49:21.036Z","good":true,"top":false,"reply_count":0,"visit_count":3150,"create_at":"2025-04-11T00:49:21.036Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"67f5db4e455186f56d9f4135","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/cypher-intro/results/

\n

获取正确的结果

\n

示例图

\n

在本节中，使用了两个示例数据集。第一个图基于电影数据库。以下代码块可帮助您创建用于探索 Cypher® 查询的数据：

\n
CREATE (matrix:Movie {title: 'The Matrix', released: 1997})\nCREATE (cloudAtlas:Movie {title: 'Cloud Atlas', released: 2012})\nCREATE (forrestGump:Movie {title: 'Forrest Gump', released: 1994})\nCREATE (keanu:Person {name: 'Keanu Reeves', born: 1964})\nCREATE (robert:Person {name: 'Robert Zemeckis', born: 1951})\nCREATE (tom:Person {name: 'Tom Hanks', born: 1956})\nCREATE (tom)-[:ACTED_IN {roles: ['Forrest']}]->(forrestGump)\nCREATE (tom)-[:ACTED_IN {roles: ['Zachry']}]->(cloudAtlas)\nCREATE (robert)-[:DIRECTED]->(forrestGump)\n

这是生成的图：\n\"image\"\n\"cypher

\n

第二个数据集是一个由人员、他们工作的公司以及他们喜欢的技术组成的小型网络。您可以在以下章节中找到它的图像。

\n

过滤结果

\n

到目前为止，您已经匹配了图中的模式，并且总是返回您找到的所有结果。现在让我们看看过滤结果并仅返回您感兴趣的数据子集的选项。这些过滤器条件使用 WHERE 子句表示。此子句允许使用任意数量的布尔表达式、谓词，并与 AND、OR、XOR 和 NOT 组合。最简单的谓词是比较；尤其是相等。

\n
MATCH (m:Movie)\nWHERE m.title = 'The Matrix'\nRETURN m\n
Rows: 1\n\n+------------------------------------------------+\n| m                                              |\n+------------------------------------------------+\n| (:Movie {title: 'The Matrix', released: 1997}) |\n+------------------------------------------------+\n

上面的查询使用 WHERE 子句，等效于此查询，该查询在模式匹配中包含条件：

\n
MATCH (m:Movie {title: 'The Matrix'})\nRETURN m\n

Cypher 旨在具有灵活性，因此通常有多种编写查询的方法。

\n

其他选项包括数值比较、匹配正则表达式以及检查列表中是否存在值。

\n

以下示例中的 WHERE 子句包括正则表达式匹配、大于比较以及测试以查看列表中是否存在值：

\n
MATCH (p:Person)-[r:ACTED_IN]->(m:Movie)\nWHERE p.name =~ 'K.+' OR m.released > 2000 OR 'Neo' IN r.roles\nRETURN p, r, m\n

基于给定的逻辑运算符 OR 和图模式 (p:Person)-[r:ACTED_IN]->(m:Movie)，查询结果必须满足以下要求之一：

\n\n

在我们的例子中，只有第二个条件匹配图模式 (p:Person)-[r:ACTED_IN]->(m:Movie)，因此输出如下：

\n
Rows: 1\n\n+-------------------------------------------------------------------------------------------------------------------------------+\n| p                                         | r                               | m                                               |\n+-------------------------------------------------------------------------------------------------------------------------------+\n| (:Person {name: 'Tom Hanks', born: 1956}) | [:ACTED_IN {roles: ['Zachry']}] | (:Movie {title: 'Cloud Atlas', released: 2012}) |\n+-------------------------------------------------------------------------------------------------------------------------------+\n

一个高级方面是模式可以用作谓词。MATCH 扩展了匹配的模式的数量和形状，而模式谓词限制了当前结果集。它只允许满足指定模式的路径通过。正如您可以预期的那样，NOT 的使用只允许不满足指定模式的路径通过。

\n
MATCH (p:Person)-[:ACTED_IN]->(m)\nWHERE NOT (p)-[:DIRECTED]->()\nRETURN p, m\n
Rows: 2\n\n+----------------------------------------------------------------------------------------------+\n| p                                         | m                                                |\n+----------------------------------------------------------------------------------------------+\n| (:Person {name: 'Tom Hanks', born: 1956}) | (:Movie {title: 'Cloud Atlas', released: 2012})  |\n| (:Person {name: 'Tom Hanks', born: 1956}) | (:Movie {title: 'Forrest Gump', released: 1994}) |\n+----------------------------------------------------------------------------------------------+\n

在这里，您可以找到演员，因为他们支持 ACTED_IN 关系，然后跳过那些曾经 DIRECTED 任何电影的演员。

\n

还有更高级的过滤方法，例如列表谓词，这将在本节后面讨论。

\n

查询值范围

\n

经常有查询想要查找特定范围内的数据。日期或数字范围可用于检查特定时间线、年龄值或其他用途中的事件。

\n

此标准的语法与 SQL 和其他编程语言逻辑结构非常相似，用于检查值的范围。

\n

以下数据集用于演示这些情况的 Cypher 查询。\n\"image\"\n\"people

\n

要重现数据集，请运行以下 Cypher 查询：

\n
CREATE (diana:Person {name: "Diana"})\nCREATE (melissa:Person {name: "Melissa", twitter: "@melissa"})\nCREATE (dan:Person {name: "Dan", twitter: "@dan", yearsExperience: 6})\nCREATE (sally:Person {name: "Sally", yearsExperience: 4})\nCREATE (john:Person {name: "John", yearsExperience: 5})\nCREATE (jennifer:Person {name: "Jennifer", twitter: "@jennifer", yearsExperience: 5})\nCREATE (joe:Person {name: "Joe"})\nCREATE (mark:Person {name: "Mark", twitter: "@mark"})\nCREATE (ann:Person {name: "Ann"})\nCREATE (xyz:Company {name: "XYZ"})\nCREATE (x:Company {name: "Company X"})\nCREATE (a:Company {name: "Company A"})\nCREATE (Neo4j:Company {name: "Neo4j"})\nCREATE (abc:Company {name: "ABC"})\nCREATE (query:Technology {type: "Query Languages"})\nCREATE (etl:Technology {type: "Data ETL"})\nCREATE (integrations:Technology {type: "Integrations"})\nCREATE (graphs:Technology {type: "Graphs"})\nCREATE (dev:Technology {type: "Application Development"})\nCREATE (java:Technology {type: "Java"})\nCREATE (diana)-[:LIKES]->(query)\nCREATE (melissa)-[:LIKES]->(query)\nCREATE (dan)-[:LIKES]->(etl)<-[:LIKES]-(melissa)\nCREATE (xyz)<-[:WORKS_FOR]-(sally)-[:LIKES]->(integrations)<-[:LIKES]-(dan)\nCREATE (sally)<-[:IS_FRIENDS_WITH]-(john)-[:LIKES]->(java)\nCREATE (john)<-[:IS_FRIENDS_WITH]-(jennifer)-[:LIKES]->(java)\nCREATE (john)-[:WORKS_FOR]->(xyz)\nCREATE (sally)<-[:IS_FRIENDS_WITH]-(jennifer)-[:IS_FRIENDS_WITH]->(melissa)\nCREATE (joe)-[:LIKES]->(query)\nCREATE (x)<-[:WORKS_FOR]-(diana)<-[:IS_FRIENDS_WITH]-(joe)-[:IS_FRIENDS_WITH]->(mark)-[:LIKES]->(graphs)<-[:LIKES]-(jennifer)-[:WORKS_FOR {startYear: 2017}]->(Neo4j)\nCREATE (ann)<-[:IS_FRIENDS_WITH]-(jennifer)-[:IS_FRIENDS_WITH]->(mark)\nCREATE (john)-[:LIKES]->(dev)<-[:LIKES]-(ann)-[:IS_FRIENDS_WITH]->(dan)-[:WORKS_FOR]->(abc)\nCREATE (ann)-[:WORKS_FOR]->(abc)\nCREATE (a)<-[:WORKS_FOR]-(melissa)-[:LIKES]->(graphs)<-[:LIKES]-(diana)\n

假设您想知道谁拥有三到七年的经验。以下代码块显示了这种情况的 Cypher 查询。

\n
MATCH (p:Person)\nWHERE 3 <= p.yearsExperience <= 7\nRETURN p\n

\"image\"\n\"cypher

\n

测试属性是否存在

\n

您可能只对节点或关系上是否存在属性感兴趣。例如，您可能想检查系统中的哪些客户拥有 Twitter 句柄，以便您可以显示相关内容。或者，您可以检查您的所有员工是否都具有开始日期属性，以验证哪些实体可能需要更新。

\n

请记住：在 Neo4j 中，只有当属性具有值时，该属性才存在（存储）。不会存储空属性。这确保仅为您的节点和关系保留有价值的必要信息。

\n

要在 Neo4j v5 中编写这种类型的存在检查，您需要使用 IS NOT NULL 谓词来仅包含属性存在的节点或关系。

\n

Cypher 代码写在下面的块中。

\n
//Query1: find all users who have a twitter property\nMATCH (p:Person)\nWHERE p.twitter IS NOT NULL\nRETURN p.name;\n\n//Query2: find all WORKS_FOR relationships that have a startYear property\nMATCH (p:Person)-[rel:WORKS_FOR]->(c:Company)\nWHERE rel.startYear IS NOT NULL\nRETURN p, rel, c;\n

Query1 结果：

\n
Rows: 4\n\n+------------------------+\n| p.name                 |\n+------------------------+\n| 'Melissa'              |\n| 'Dan'                  |\n| 'Jennifer'             |\n| 'Mark'                 |\n+------------------------+\n

Query2 结果：\n\"image\"\n\"cypher

\n

检查字符串 - 部分值、模糊搜索

\n

某些场景需要查询语法来匹配字符串中的部分值或广泛类别。要执行这种类型的查询，您需要一些灵活性以及用于字符串匹配和搜索的选项。无论您是寻找以某个值开头、结尾还是包含某个值的字符串，Cypher 都可以轻松且高效地处理它。

\n

Cypher 中有一些关键字与 WHERE 子句一起使用来测试字符串属性值。STARTS WITH 关键字允许您检查属性的值是否以您指定的字符串开头。使用 CONTAINS 关键字，您可以检查指定的字符串是否是属性值的一部分。ENDS_WITH 关键字检查属性字符串的末尾是否包含您指定的值。

\n

以下 Cypher 块中包含每个示例。

\n
//check if a property starts with 'M'\nMATCH (p:Person)\nWHERE p.name STARTS WITH 'M'\nRETURN p.name;\n\n//check if a property contains 'a'\nMATCH (p:Person)\nWHERE p.name CONTAINS 'a'\nRETURN p.name;\n\n//check if a property ends with 'n'\nMATCH (p:Person)\nWHERE p.name ENDS WITH 'n'\nRETURN p.name;\n

您还可以使用正则表达式来测试字符串的值。例如，您可以查找共享名字的所有 Person 节点，或者您可以找到所有具有特定部门代码的类。

\n

让我们看一个例子。

\n
MATCH (p:Person)\nWHERE p.name =~ 'Jo.*'\nRETURN p.name\n
Rows: 2\n\n+--------------------------------+\n| p.name                         |\n+--------------------------------+\n| 'John'                         |\n| 'Joe'                          |\n+--------------------------------+\n

就像在 SQL 和其他语言中一样，您可以检查属性值是否是列表中的值。IN 关键字允许您指定一个值数组，并根据列表中的每个值验证属性的内容。

\n

这是一个例子：

\n
MATCH (p:Person)\nWHERE p.yearsExperience IN [1, 5, 6]\nRETURN p.name, p.yearsExperience\n
Rows: 3\n\n+--------------+-----------------+\n| p.name       | p.yearsExp      |\n+--------------+-----------------+\n| 'Jennifer'   | 5               |\n| 'Dan'        | 6               |\n| 'John'       | 5               |\n+--------------+-----------------+\n

过滤模式

\n

使图独一无二的一件事是它对关系的关注。就像您可以根据节点标签或属性过滤查询一样，您也可以根据关系或模式过滤结果。这允许您测试模式是否也具有某种关系或没有，或者是否存在另一种模式。

\n

以下 Cypher 代码显示了如何完成此操作。

\n
//Query1: find which people are friends of someone who works for Neo4j\nMATCH (p:Person)-[r:IS_FRIENDS_WITH]->(friend:Person)\nWHERE exists((p)-[:WORKS_FOR]->(:Company {name: 'Neo4j'}))\nRETURN p, r, friend;\n\n//Query2: find Jennifer's friends who do not work for a company\nMATCH (p:Person)-[r:IS_FRIENDS_WITH]->(friend:Person)\nWHERE p.name = 'Jennifer'\nAND NOT exists((friend)-[:WORKS_FOR]->(:Company))\nRETURN friend.name;\n

Query1 结果：\n\"image\"\n\"cypher

\n

Query2 结果：

\n
Rows: 1\n\n+--------------------------------+\n| friend.name                    |\n+--------------------------------+\n| 'Mark'                         |\n+--------------------------------+\n

可选模式

\n

在某些情况下，您可能想要从模式中检索结果，即使它们不匹配整个模式或所有条件。这就是 SQL 中外部联接的工作方式。在 Cypher 中，您可以使用 OPTIONAL MATCH 模式尝试匹配它，但如果它没有找到结果，则这些行将为这些值返回 null。

\n

您可以通过查询名称以特定字母开头并且可能为公司工作的人员来查看这在 Cypher 中的外观。

\n
//Find all people whose name starts with J and who may work for a company.\nMATCH (p:Person)\nWHERE p.name STARTS WITH 'J'\nOPTIONAL MATCH (p)-[:WORKS_FOR]-(other:Company)\nRETURN p.name, other.name;\n
Rows: 3\n\n+--------------------------------+\n| p.name      | other.name       |\n+--------------------------------+\n| 'Jennifer'  | 'Neo4j'          |\n| 'John'      | 'XYZ'            |\n| 'Joe'       | null             |\n+--------------------------------+\n

请注意，Joe 会被返回，因为他的名字以字母“J”开头，但他的公司名称为 null。那是因为他没有与 COMPANY 节点的 WORKS_FOR 关系。由于您使用了 OPTIONAL MATCH，因此他的 Person 节点仍然从第一个匹配项返回，但未找到第二个匹配项，因此返回 null。

\n

要查看差异，请尝试在第二个匹配项的前面运行没有 OPTIONAL 的查询。您可以看到不再返回 Joe 的行。那是因为 Cypher 使用 AND 匹配读取语句，因此该人必须匹配第一个条件（名称以“J”开头）和第二个条件（该人为公司工作）。

\n

更复杂的模式

\n

即使在这一点上，您也能够处理许多简单的图查询。但是，当您想要将模式扩展到单个关系之外时会发生什么？如果您想知道除了 Jennifer 之外还有谁喜欢图，该怎么办？

\n

我们通过简单地添加到我们的第一个模式或匹配其他模式来处理此功能和许多其他功能。让我们看几个例子。

\n
//Query1: find who likes graphs besides Jennifer\nMATCH (j:Person {name: 'Jennifer'})-[r:LIKES]-(graph:Technology {type: 'Graphs'})-[r2:LIKES]-(p:Person)\nRETURN p.name;\n\n//Query2: find who likes graphs besides Jennifer that she is also friends with\nMATCH (j:Person {name: 'Jennifer'})-[:LIKES]->(:Technology {type: 'Graphs'})<-[:LIKES]-(p:Person),\n      (j)-[:IS_FRIENDS_WITH]-(p)\nRETURN p.name;\n

Query1 结果：

\n
Rows: 3\n\n+-----------------------+\n| p.name                |\n+-----------------------+\n| 'Diana'               |\n| 'Mark'                |\n| 'Melissa'             |\n+-----------------------+\n

Query2 结果：

\n
Rows: 2\n\n+-----------------------+\n| p.name                |\n+-----------------------+\n| 'Mark'                |\n| 'Melissa'             |\n+-----------------------+\n

请注意，在第二个查询中，在第一个 MATCH 行之后使用逗号，并在下一行添加另一个模式以进行匹配。这允许您将模式链接在一起，类似于您上面使用的 WHERE exists(<pattern>) 语法。使用此结构，您可以添加多个不同的模式并将它们链接在一起，从而允许您使用某些模式遍历图的各个部分。

\n

返回结果

\n

到目前为止，您已经通过它们的变量直接返回了节点、关系和路径。但是，RETURN 子句可以返回任意数量的表达式。但是 Cypher 中的表达式是什么？

\n

最简单的表达式是文字值。文字值的示例包括：数字、字符串、数组（例如：[1,2,3]）和映射（例如：{name: 'Tom Hanks', born:1964, movies: ['Forrest Gump', ...], count: 13}）。可以使用点语法访问任何节点、关系或映射的各个属性，例如：n.name。可以使用下标检索数组的各个元素或切片，例如：names[0] 和 movies[1..-1]。每个函数评估，例如：length(array)、toInteger('12')、substring('2014-07-01', 0, 4) 和 coalesce(p.nickname, 'n/a') 也是一个表达式。

\n

WHERE 子句中使用的谓词计为布尔表达式。

\n

可以组合和连接简单表达式以形成更复杂的表达式。

\n

默认情况下，表达式本身用作列的标签，在许多情况下，您希望使用更易于理解的名称通过 expression AS alias 为其设置别名。别名可以随后用于引用该列。

\n
MATCH (p:Person)\nRETURN\n  p,\n  p.name AS name,\n  toUpper(p.name),\n  coalesce(p.nickname, 'n/a') AS nickname,\n  {name: p.name, label: head(labels(p))} AS person\n
Rows: 3\n\n+-------------------------------------------------------------------------------------------------------------------------------------------------+\n| p                                               | name              | toUpper(p.name)   | nickname | person                                     |\n+-------------------------------------------------------------------------------------------------------------------------------------------------+\n| (:Person {name: 'Keanu Reeves', born: 1964})    | 'Keanu Reeves'    | 'KEANU REEVES'    | 'n/a'    | {name: 'Keanu Reeves', label: 'Person'}    |\n| (:Person {name: 'Robert Zemeckis', born: 1951}) | 'Robert Zemeckis' | 'ROBERT ZEMECKIS' | 'n/a'    | {name: 'Robert Zemeckis', label: 'Person'} |\n| (:Person {name: 'Tom Hanks', born: 1956})       | 'Tom Hanks'       | 'TOM HANKS'       | 'n/a'    | {name: 'Tom Hanks', label: 'Person'}       |\n+-------------------------------------------------------------------------------------------------------------------------------------------------+\n

如果您希望仅显示唯一结果，则可以在 RETURN 之后使用 DISTINCT 关键字：

\n
MATCH (n)\nRETURN DISTINCT labels(n) AS Labels\n
Rows: 2\n\n+------------+\n| Labels     |\n+------------+\n| ['Movie']  |\n| ['Person'] |\n+------------+\n

返回唯一结果

\n

您可以使用 Cypher 中的 DISTINCT 关键字返回唯一结果。由于节点的多个路径或满足多个条件的节点，您的某些查询可能会返回重复的结果。这种冗余会使结果混乱，并且难以筛选长列表以找到您需要的内容。

\n

要删除重复的实体，您可以使用 DISTINCT 关键字。

\n
//Query: find people who have a twitter and like graphs or query languages\nMATCH (user:Person)\nWHERE user.twitter IS NOT null\nWITH user\nMATCH (user)-[:LIKES]-(t:Technology)\nWHERE t.type IN ['Graphs','Query Languages']\nRETURN DISTINCT user.name\n
Query results:\n\nRows: 3\n\n+-----------------------+\n| user.name             |\n+-----------------------+\n| 'Jennifer'            |\n| 'Melissa'             |\n| 'Mark'                |\n+-----------------------+\n

对于前面的查询，用例是您正在为 Cypher 推出一个新的 Twitter 帐户，其中包含提示和技巧，并且您想要通知拥有 Twitter 帐户并且喜欢图或查询语言的用户。查询的前两行查找具有 Twitter 句柄的 Person 节点。然后，您使用 WITH 将这些用户传递到下一个 MATCH，您可以在其中找出该人是否喜欢图或查询语言。请注意，在没有 DISTINCT 关键字的情况下运行此语句会导致“Melissa”显示两次。这是因为她喜欢图，而且她也喜欢查询语言。当使用 DISTINCT 时，您只会检索唯一用户。

\n

限制结果数

\n

有时您想要一个抽样集，或者您只想一次提取这么多结果来更新或处理。LIMIT 关键字获取查询的输出，并根据您指定的数字限制返回的卷。

\n

例如，您可以找到图中每个人的朋友数。如果该图有成千上万或数百万个节点和关系，则返回的结果数将是巨大的。如果您只关心拥有最多朋友的前三个人怎么办？让我们为此编写一个查询！

\n
//Query: find the top 3 people who have the most friends\nMATCH (p:Person)-[r:IS_FRIENDS_WITH]-(other:Person)\nRETURN p.name, count(other.name) AS numberOfFriends\nORDER BY numberOfFriends DESC\nLIMIT 3\n
Rows: 3\n\n+--------------------------------+\n| p.name      | numberOfFriends  |\n+--------------------------------+\n| 'Jennifer'  | 5                |\n| 'Mark'      | 2                |\n| 'Ann'       | 2                |\n+--------------------------------+\n

该查询提取人员以及他们连接的朋友，并返回人员姓名和他们的朋友的计数。您可以只运行查询的那么多内容并返回名称和朋友计数的混乱列表，但您可能想要根据每个人拥有的朋友数量（从顶部最大的数字开始 (DESC)）对列表进行排序。您也可以运行查询的那么多内容以查看所有排序的朋友和计数，但在上面的示例中，已从图中提取了拥有最多朋友的前三个人。LIMIT 从排序列表中提取顶部结果。

\n

尝试通过删除 ORDER BY 和 LIMIT 行来混合查询，然后分别添加每一行。请注意，仅删除 ORDER BY 行会从列表中提取起始三个值，从而获得返回结果的随机抽样。

\n

聚合信息

\n

在许多情况下，我们希望在遍历图中的模式时聚合或分组遇到的数据。在 Cypher 中，聚合发生在 RETURN 子句中，同时计算最终结果。支持许多常见的聚合函数，例如 count、sum、avg、min 和 max，但还有更多。

\n

可以通过以下方式实现计算电影数据库中的人数：

\n
MATCH (:Person)\nRETURN count(*) AS people\n
Rows: 1\n\n+--------+\n| people |\n+--------+\n| 3      |\n+--------+\n

如果要跳过空值，请使用函数 count(variable)。

\n

要仅聚合唯一值，请使用 DISTINCT 运算符，例如：count(DISTINCT role)。

\n

聚合在 Cypher 中隐式工作。您指定要聚合的结果列。Cypher 使用所有非聚合列作为分组键。

\n

聚合会影响在排序或后续查询部分中仍然可见的数据。

\n

以下语句找出演员和导演一起工作的频率：

\n
MATCH (actor:Person)-[:ACTED_IN]->(movie:Movie)<-[:DIRECTED]-(director:Person)\nRETURN actor, director, count(*) AS collaborations\n
Rows: 1\n\n+--------------------------------------------------------------------------------------------------------------+\n| actor                                     | director                                        | collaborations |\n+--------------------------------------------------------------------------------------------------------------+\n| (:Person {name: 'Tom Hanks', born: 1956}) | (:Person {name: 'Robert Zemeckis', born: 1951}) | 1              |\n+--------------------------------------------------------------------------------------------------------------+\n

有三种不同的方法可以使用 count() 函数：

\n\n

在数据集“人员、技术和公司”中，某些 Person 节点具有 Twitter 句柄，而另一些则没有。如果您运行下面的第一个示例查询，您将看到 twitter 属性对四个人有一个值，而对其他五个人则为 null。第二个和第三个查询显示了如何使用不同的计数选项。

\n
//Query1: see the list of Twitter handle values for Person nodes\nMATCH (p:Person)\nRETURN p.twitter;\n

Query1 结果：

\n
Rows: 9\n\n+--------------+\n| p.twitter    |\n+--------------+\n| '@jennifer'  |\n| '@melissa'   |\n| null         |\n| '@mark'      |\n| '@dan'       |\n| null         |\n| null         |\n| null         |\n| null         |\n+--------------+\n
//Query2: count of the non-null `twitter` property of the Person nodes\nMATCH (p:Person)\nRETURN count(p.twitter);\n

Query2 结果：

\n
Rows: 1\n\n+-------------------+\n| count(p.twitter)  |\n+-------------------+\n| 4                 |\n+-------------------+\n
//Query3: count on the Person nodes\nMATCH (p:Person)\nRETURN count(*);\n

Query3 结果：

\n
Rows: 1\n\n+-------------------+\n| count(*)          |\n+-------------------+\n| 9                 |\n+-------------------+\n

收集聚合

\n

一个非常有用的聚合函数是 collect(expression)，它返回由表达式返回的值的单个聚合列表。这在许多情况下非常有用，因为在聚合时不会丢失任何详细信息。

\n

collect() 非常适合检索典型的父子结构，其中每行返回一个核心实体（父级、根或头），所有依赖信息都在使用 collect() 创建的关联列表中。这意味着无需为每个子行重复父信息，也无需运行 n+1 个语句来单独检索父及其子项。

\n

以下语句可用于检索数据库中每部电影的演员阵容：

\n
MATCH (m:Movie)<-[:ACTED_IN]-(a:Person)\nRETURN m.title AS movie, collect(a.name) AS cast, count(*) AS actors\n
Rows: 2\n\n+-----------------------------------------+\n| movie          | cast          | actors |\n+-----------------------------------------+\n| 'Forrest Gump' | ['Tom Hanks'] | 1      |\n| 'Cloud Atlas'  | ['Tom Hanks'] | 1      |\n+-----------------------------------------+\n

由 collect() 创建的列表可以从使用 Cypher 结果的客户端使用，也可以直接在具有任何列表函数或谓词的语句中使用。

\n

循环遍历列表值

\n

如果您有一个想要检查或分离值的列表，Cypher 提供了 UNWIND 子句。这与 collect() 的作用相反，并将列表分离为单独行上的各个值。

\n

在导入数据以及日常数组和其他类型的列表时，UNWIND 经常用于循环遍历 JSON 和 XML 对象。让我们看几个示例，我们假设某人喜欢的技术也意味着他们对每项技术都有一些经验。如果您有兴趣雇用熟悉图或查询语言的人员，您可以编写以下查询来查找要面试的人员。

\n
//Query1: for a list of techRequirements, look for people who have each skill\nWITH ['Graphs','Query Languages'] AS techRequirements\nUNWIND techRequirements AS technology\nMATCH (p:Person)-[r:LIKES]-(t:Technology {type: technology})\nRETURN t.type, collect(p.name) AS potentialCandidates;\n

Query1 结果：

\n
Rows: 2\n\n+-------------------+------------------------------------------+\n| t.type            | potentialCandidates                      |\n+-------------------+------------------------------------------+\n| 'Graphs'          | ['Diana', 'Mark', 'Melissa', 'Jennifer'] |\n| 'Query Languages' | ['Diana', 'Melissa', 'Joe']              |\n+-------------------+------------------------------------------+\n
//Query2: for numbers in a list, find candidates who have that many years of experience\nWITH [4, 5, 6, 7] AS experienceRange\nUNWIND experienceRange AS number\nMATCH (p:Person)\nWHERE p.yearsExp = number\nRETURN p.name, p.yearsExp;\n

Query2 结果：

\n
Rows: 4\n\n+--------------+-----------------+\n| p.name       | p.yearsExp      |\n+--------------+-----------------+\n| 'Sally'      | 4               |\n| 'Jennifer'   | 5               |\n| 'John'       | 5               |\n| 'Dan'        | 6               |\n+--------------+-----------------+\n

排序和分页

\n

通常在使用 count(x) 聚合后进行排序和分页。

\n

排序是使用 ORDER BY expression [ASC|DESC] 子句完成的。该表达式可以是任何表达式，只要它可以从返回的信息中计算出来。

\n

例如，如果您返回 person.name，您仍然可以 ORDER BY person.age，因为两者都可以从 person 引用访问。您不能按未返回的内容排序。这对于聚合和 DISTINCT 返回值尤其重要，因为两者都会删除聚合数据的可见性。

\n

分页是使用 SKIP {offset} 和 LIMIT {count} 子句完成的。

\n

一个常见的模式是聚合计数（分数或频率），按其排序，并且仅返回前 n 个条目。

\n

例如，要找到最多产的演员，您可以这样做：

\n
MATCH (a:Person)-[:ACTED_IN]->(m:Movie)\nRETURN a, count(*) AS appearances\nORDER BY appearances DESC LIMIT 10\n
Rows: 1\n\n+---------------------------------------------------------+\n| a                                         | appearances |\n+---------------------------------------------------------+\n| (:Person {name: 'Tom Hanks', born: 1956}) | 2           |\n+---------------------------------------------------------+\n

排序结果

\n

如果您可以按最多或最少的经验对我们先前示例中的潜在招聘候选人列表进行排序，那么它可能会更有用。或者，您可能想要按年龄对我们所有的人员进行排名。

\n

ORDER BY 关键字根据您在升序或降序中指定的值对结果进行排序（升序是默认值）。让我们使用与 UNWIND 相同的示例查询，看看如何对候选人进行排序。

\n
//Query1: for a list of techRequirements, look for people who have each skill\nWITH ['Graphs','Query Languages'] AS techRequirements\nUNWIND techRequirements AS technology\nMATCH (p:Person)-[r:LIKES]-(t:Technology {type: technology})\nWITH t.type AS technology, p.name AS personName\nORDER BY technology, personName\nRETURN technology, collect(personName) AS potentialCandidates;\n

Query1 结果：

\n
Rows: 2\n\n+-------------------+------------------------------------------+\n| technology        | potentialCandidates                      |\n+-------------------+------------------------------------------+\n| 'Graphs'          | ['Diana', 'Jennifer', 'Mark', 'Melissa'] |\n| 'Query Languages' | ['Diana', 'Joe']                           |\n+-------------------+------------------------------------------+\n
//Query2: for numbers in a list, find candidates who have that many years of experience\nWITH [4, 5, 6, 7] AS experienceRange\nUNWIND experienceRange AS number\nMATCH (p:Person)\nWHERE p.yearsExp = number\nRETURN p.name, p.yearsExp ORDER BY p.yearsExp DESC;\n

Query2 结果：

\n
Rows: 4\n\n+--------------+-----------------+\n| p.name       | p.yearsExp      |\n+--------------+-----------------+\n| 'Dan'        | 6               |\n| 'Jennifer'   | 5               |\n| 'John'       | 5               |\n| 'Sally'      | 4               |\n+--------------+-----------------+\n

请注意，第一个查询必须先按人员姓名排序，然后才能将值收集到列表中。如果您不先排序（将 ORDER BY 放在 RETURN 子句之后），您将根据列表的大小而不是列表中值的首字母进行排序。结果也被排序为两个值：技术，然后是人。这允许您对技术进行排序，以便将喜欢某项技术的所有人员列在一起。

\n

您可以通过运行以下查询来尝试按两个值或一个值进行排序的差异：

\n
//only sorted by person's name in alphabetical order\nWITH ['Graphs','Query Languages'] AS techRequirements\nUNWIND techRequirements AS technology\nMATCH (p:Person)-[r:LIKES]-(t:Technology {type: technology})\nWITH t.type AS technology, p.name AS personName\nORDER BY personName\nRETURN technology, personName;\n
//only sorted by technology (person names are out of order)\nWITH ['Graphs','Query Languages'] AS techRequirements\nUNWIND techRequirements AS technology\nMATCH (p:Person)-[r:LIKES]-(t:Technology {type: technology})\nWITH t.type AS technology, p.name AS personName\nORDER BY technology\nRETURN technology, personName;\n
//sorted by technology, then by person's name\nWITH ['Graphs','Query Languages'] AS techRequirements\nUNWIND techRequirements AS technology\nMATCH (p:Person)-[r:LIKES]-(t:Technology {type: technology})\nWITH t.type AS technology, p.name AS personName\nORDER BY technology, personName\nRETURN technology, personName;\n

计算列表中的值

\n

如果您有一个值列表，您还可以使用 size() 函数查找该列表中的项目数或计算表达式的大小。以下示例返回找到的项目数。

\n
//Query1: find number of items in collected list\nMATCH (p:Person)-[:IS_FRIENDS_WITH]->(friend:Person)\nRETURN p.name, size(collect(friend.name)) AS numberOfFriends;\n

Query1 结果：

\n
Rows: 4\n\n+--------------+-----------------+\n| p.name       | numberOfFriends |\n+--------------+-----------------+\n| 'John'       | 1               |\n| 'Jennifer'   | 5               |\n| 'Ann'        | 1               |\n| 'Joe'        | 2               |\n+--------------+-----------------+\n

在 Neo4j v5 中，如果您需要查找关系模式的数量，请使用 COUNT {} 表达式。请看以下 Cypher 查询示例。

\n
//Query2: find number of friends who have other friends\nMATCH (p:Person)-[:IS_FRIENDS_WITH]->(friend:Person)\nWHERE count{(friend)-[:IS_FRIENDS_WITH]-(:Person)} > 1\nRETURN p.name, collect(friend.name) AS friends, count{(friend)-[:IS_FRIENDS_WITH]-(:Person)} AS numberOfFoFs;\n

Query2 结果：

\n
Rows: 3\n\n+--------------+----------------------------------+---------------+\n| p.name       | friends                          | numberOfFoFs  |\n+--------------+----------------------------------+---------------+\n| 'Joe'        | ['Mark']                         | 2             |\n| 'Jennifer'   | ['Mark', 'John', 'Sally', 'Ann'] | 2             |\n| 'John'       | ['Sally']                        | 2             |\n+--------------+----------------------------------+---------------+\n

资源

\n\n
","title":"Neo4j官方教程：第10节，获取正确的结果","last_reply_at":"2025-04-09T02:28:30.489Z","good":true,"top":false,"reply_count":0,"visit_count":3223,"create_at":"2025-04-09T02:28:30.489Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"67f5d4a0455186f56d9f4134","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/cypher-intro/patterns-in-practice/

\n

实践中的模式

\n

创建和返回数据

\n

让我们首先看看允许您创建数据的子句。

\n

要添加数据，您只需使用您已经知道的模式。通过提供模式，您可以指定哪些图结构、标签和属性要成为图的一部分。

\n

显然，最简单的子句称为 CREATE。它创建您指定的模式。

\n

对于您到目前为止所看到的模式，这可能如下所示：

\n
CREATE (:Movie {title: 'The Matrix', released: 1997})\n

如果您运行此语句，Cypher® 将返回更改的数量：在本例中，添加一个节点、一个标签和两个属性。

\n
Created Nodes: 1\nAdded Labels: 1\nSet Properties: 2\nRows: 0\n

由于您从一个空数据库开始，因此您现在有一个数据库，其中包含一个节点：\n\"image\"\n\"cypher

\n

如果您还想返回创建的数据，您可以添加一个 RETURN 子句，该子句引用您已分配给模式元素的变量。\nCypher 中的 RETURN 关键字指定您可能希望从 Cypher 查询返回的值或结果。\n您可以告诉 Cypher 返回节点、关系、节点和关系属性或查询结果中的模式。\n执行写入过程时不需要 RETURN，但读取时需要。\n当使用 RETURN 时，前面讨论的节点和关系变量变得很重要。

\n
CREATE (p:Person {name: 'Keanu Reeves', born: 1964})\nRETURN p\n

这是返回的内容：

\n
Created Nodes: 1\nAdded Labels: 1\nSet Properties: 2\nRows: 1\n\n+----------------------------------------------+\n| p                                            |\n+----------------------------------------------+\n| (:Person {name: 'Keanu Reeves', born: 1964}) |\n+----------------------------------------------+\n

如果要创建多个元素，可以用逗号分隔元素或使用多个 CREATE 语句。

\n

当然，您还可以创建更复杂的结构，例如包含有关角色的信息的 ACTED_IN 关系，或导演的 DIRECTED 关系。

\n
CREATE (a:Person {name: 'Tom Hanks', born: 1956})-[r:ACTED_IN {roles: ['Forrest']}]->(m:Movie {title: 'Forrest Gump', released: 1994})\nCREATE (d:Person {name: 'Robert Zemeckis', born: 1951})-[:DIRECTED]->(m)\nRETURN a, d, r, m\n

这是更新后的图的一部分：\n\"image\"\n\"cypher

\n

在大多数情况下，您希望将新数据添加到现有结构。这需要知道如何在图数据中查找现有模式，这将在下一节中介绍。

\n

匹配模式

\n

匹配模式是 MATCH 语句的任务。您将到目前为止使用的相同类型的模式传递给 MATCH，以描述您要查找的内容。它类似于按示例查询，只是您的示例还包括结构。要返回节点、关系、属性或模式，您需要在 MATCH 子句中为要返回的数据指定变量。

\n

MATCH 语句搜索您指定的模式，并为每个成功的模式匹配返回一行。

\n

要查找您到目前为止创建的数据，您可以开始查找所有带有 Movie 标签的节点。

\n
MATCH (m:Movie)\nRETURN m\n

结果如下：\n\"image\"

\n

\"cypher

\n

这应该显示《黑客帝国》和《阿甘正传》。

\n

您还可以查找特定的人，例如基努·里维斯。

\n
MATCH (p:Person {name: 'Keanu Reeves'})\nRETURN p\n

此查询返回匹配的节点：\n\"image\"\n\"cypher

\n

请注意，您只提供足够的信息来查找节点，并非所有属性都是必需的。在大多数情况下，您都有关键属性，例如 SSN、ISBN、电子邮件、登录名、地理位置或产品代码来查找。

\n

您还可以找到更有趣的连接，例如，汤姆·汉克斯出演的电影的标题和他扮演的角色。

\n
MATCH (p:Person {name: 'Tom Hanks'})-[r:ACTED_IN]->(m:Movie)\nRETURN m.title, r.roles\n
Rows: 1\n\n+------------------------------+\n| m.title        | r.roles     |\n+------------------------------+\n| 'Forrest Gump' | ['Forrest'] |\n+------------------------------+\n

在本例中，您只返回了您感兴趣的节点和关系的属性。您可以通过点表示法 identifier.property 在任何地方访问它们。

\n

当然，这只列出了汤姆·汉克斯在《阿甘正传》中扮演的 Forrest 角色，因为这就是您添加的所有数据。

\n

现在您已经知道足够多的知识来将新节点添加到现有节点，并且可以将 MATCH 和 CREATE 组合起来以将结构附加到图中。

\n

Cypher 示例

\n

让我们看一些使用 MATCH 和 RETURN 关键字的示例。每个后续示例都比前一个示例更复杂。最后两个示例首先解释了我们试图实现的目标。如果您单击每个 Cypher 代码段下方的“运行查询”按钮，您可以在图或表的格式中查看结果。

\n

示例 1：查找图中带有标签 Person 的节点。请注意，如果要检索 RETURN 子句中的节点，则必须为 Person 节点使用一个变量，例如 p。

\n
MATCH (p:Person)\nRETURN p\nLIMIT 1\n

示例 2：查找图中名称为“Tom Hanks”的 Person 节点。请记住，您可以随意命名您的变量，只要您稍后引用相同的名称即可。

\n
MATCH (tom:Person {name: 'Tom Hanks'})\nRETURN tom\n

示例 3：查找汤姆·汉克斯导演的电影。

\n

说明：首先，您应该找到汤姆·汉克斯的 Person 节点，然后找到他连接到的 Movie 节点。为此，您必须从汤姆·汉克斯的 Person 节点到 Movie 节点遵循 DIRECTED 关系。您还指定了 Movie 的标签，以便查询仅查看带有该标签的节点。由于您只关心在此查询中返回电影，因此您需要为该节点提供一个变量（movie），但不需要为 Person 节点或 DIRECTED 关系提供变量。

\n
MATCH (:Person {name: 'Tom Hanks'})-[:DIRECTED]->(movie:Movie)\nRETURN movie\n

示例 4：查找汤姆·汉克斯导演的电影，但这次只返回电影的标题。

\n

说明：此查询与上一个查询类似。示例 3 返回了整个 Movie 节点及其所有属性。对于此示例，您仍然需要找到汤姆的电影，但现在您只关心它们的标题。您应该使用语法 variable.property 访问节点的 title 属性以返回名称值。

\n
MATCH (:Person {name: 'Tom Hanks'})-[:DIRECTED]->(movie:Movie)\nRETURN movie.title\n

别名返回值

\n

并非所有属性都像上面示例中的 movie.title 那样简单。由于属性长度、多字描述、开发人员术语和其他快捷方式，某些属性的名称很差。这些命名约定可能难以阅读，尤其是在报告和其他面向用户的界面上。

\n

命名不佳的属性

\n
// 命名不佳的属性\nMATCH (tom:Person {name:'Tom Hanks'})-[rel:DIRECTED]-(movie:Movie)\nRETURN tom.name, tom.born, movie.title, movie.released\n

就像 SQL 一样，您可以使用 AS 关键字重命名返回结果，并使用更清晰的名称为属性设置别名。

\n

使用别名获得更清晰的结果

\n
// 使用别名获得更清晰的打印结果\nMATCH (tom:Person {name:'Tom Hanks'})-[rel:DIRECTED]-(movie:Movie)\nRETURN tom.name AS name, tom.born AS `Year Born`, movie.title AS title, movie.released AS `Year Released`\n

您可以通过在别名前后使用反引号字符来指定包含空格的返回别名（movie.released AS Year Released）。如果您没有包含空格的别名，则无需使用反引号。

\n

附加结构

\n

要使用新信息扩展图，首先要匹配现有的连接点，然后使用关系将新创建的节点附加到它们。像这样可以为汤姆·汉克斯添加一部新电影《云图》：

\n
MATCH (p:Person {name: 'Tom Hanks'})\nCREATE (m:Movie {title: 'Cloud Atlas', released: 2012})\nCREATE (p)-[r:ACTED_IN {roles: ['Zachry']}]->(m)\nRETURN p, r, m\n

这是数据库中的结构：\n\"image\"\n\"cypher

\n

重要的是要记住，您可以为节点和关系分配变量，并在以后使用它们，无论它们是创建的还是匹配的。

\n

可以在单个 CREATE 子句中附加节点和关系。但是，为了提高可读性，将它们分开是有帮助的。

\n

MATCH 和 CREATE 组合的一个棘手方面是，每个匹配的模式都会得到一行。这会导致后续的 CREATE 语句为每一行执行一次。在许多情况下，这正是您想要的。如果不是有意的，请将 CREATE 语句移动到 MATCH 之前，或者使用稍后讨论的方法更改查询的基数，或者使用下一个子句的获取或创建语义：MERGE。

\n

完成模式

\n

每当您从外部系统获取数据或不确定某些信息是否已存在于图中时，您都希望能够表达可重复（幂等）的更新操作。在 Cypher 中，MERGE 子句具有此功能。它的作用类似于 MATCH 或 CREATE 的组合，它在创建数据之前检查数据是否存在。使用 MERGE，您可以定义要查找或创建的模式。通常，与 MATCH 一样，您只想在核心模式中包含要查找的关键属性。MERGE 允许您提供要在 ON CREATE 上设置的其他属性。

\n

如果您不知道您的图是否已经包含《云图》，您可以再次合并它。

\n
MERGE (m:Movie {title: 'Cloud Atlas'})\nON CREATE SET m.released = 2012\nRETURN m\n
Created Nodes: 1\nAdded Labels: 1\nSet Properties: 2\nRows: 1\n\n+-------------------------------------------------+\n| m                                               |\n+-------------------------------------------------+\n| (:Movie {title: 'Cloud Atlas', released: 2012}) |\n+-------------------------------------------------+\n

在这两种情况下，您都会得到一个结果：要么是图中已经存在的数据（可能不止一行），要么是一个新创建的 Movie 节点。

\n

没有任何先前分配变量的 MERGE 子句要么匹配完整模式，要么创建完整模式。它永远不会产生模式中匹配和创建的部分混合。要实现部分匹配/创建，请确保对不应受影响的部分使用已定义的变量。

\n

因此，最重要的是，MERGE 确保您不能创建重复的信息或结构，但它需要首先检查现有匹配项的成本。尤其是在大型图上，扫描一组带有标签的节点以查找特定属性可能代价高昂。您可以通过创建支持索引或约束来缓解这种情况，这将在后面的章节中讨论。但这仍然不是免费的，因此，只要您确定不会创建重复数据，请使用 CREATE 而不是 MERGE。

\n

MERGE 还可以断言仅创建一次关系。为此，您必须从先前的模式匹配中传入两个节点。

\n
MATCH (m:Movie {title: 'Cloud Atlas'})\nMATCH (p:Person {name: 'Tom Hanks'})\nMERGE (p)-[r:ACTED_IN]->(m)\nON CREATE SET r.roles =['Zachry']\nRETURN p, r, m\n

\"image\"\n\"cypher

\n

如果关系的方向是任意的，您可以省略箭头。MERGE 检查任一方向的关系，如果没有匹配的关系，则创建一个新的有向关系。

\n

如果您选择仅从前面的子句中传入一个节点，则 MERGE 提供了一个有趣的功能。它仅在给定模式的提供的节点的直接邻域内匹配，如果未找到该模式，则创建它。这对于创建树结构非常有用。

\n
CREATE (y:Year {year: 2014})\nMERGE (y)<-[:IN_YEAR]-(m10:Month {month: 10})\nMERGE (y)<-[:IN_YEAR]-(m11:Month {month: 11})\nRETURN y, m10, m11\n

这是创建的图结构：\n\"image\"\n\"cypher

\n

这里没有对两个 Month 节点进行全局搜索；仅在 2014 Year 节点的上下文中搜索它们。

\n

代码挑战

\n

现在了解了基础知识，请使用下面的部分构建一个 Cypher 语句，以查找汤姆·汉克斯 DIRECTED 的每个 Movie 的标题和发行年份。单击这些部分以按顺序添加它们，完成后，单击“运行查询”以查看您是否正确。您可以单击代码块内的任何查询部分以将其删除。

\n

从下面的选项中选择以完成查询：

\n
{name:})-[:MovieRETURNPerson"Tom Hanks")m.title, m.released]->(m:DIRECTED(p:MATCH\n
","title":"Neo4j官方教程：第9节，实践中的模式","last_reply_at":"2025-04-09T02:00:00.826Z","good":true,"top":false,"reply_count":0,"visit_count":2965,"create_at":"2025-04-09T02:00:00.826Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}},{"id":"67f5cf0f455186f56d9f4133","author_id":"5813fc27151711bf08e3384e","tab":"share","content":"

教程目录\n引自：https://neo4j.com/docs/getting-started/cypher/

\n

模式

\n

Neo4j 的属性图由节点和关系组成，它们都可以具有属性。节点表示实体，例如概念、事件、地点和事物。关系连接成对的节点。

\n

但是，节点和关系可以被认为是低级构建块。属性图的真正优势在于它能够编码连接的节点和关系的模式。单个节点或关系通常编码的信息很少，但是节点和关系的模式可以编码任意复杂的想法。

\n

Cypher®（Neo4j 的查询语言）强烈基于模式。具体来说，模式用于匹配所需的图结构。一旦找到或创建了匹配的结构，Neo4j 就可以使用它进行进一步处理。

\n

一个简单的模式（只有一个关系）连接一对节点（或者，偶尔，一个节点连接到自身）。例如，一个人 LIVES_IN 一个城市，或者一个城市是 PART_OF 一个国家。

\n

使用多个关系的复杂模式可以表达任意复杂的概念，并支持各种有趣的用例。例如，我们可能想要匹配一个人 LIVES_IN 一个国家的实例。以下 Cypher 代码将两个简单的模式组合成一个稍微复杂的模式，该模式执行此匹配：

\n
(:Person) -[:LIVES_IN]-> (:City) -[:PART_OF]-> (:Country)\n

由图标和箭头组成的图通常用于可视化图。文本注释提供标签，定义属性等。

\n

节点语法

\n

Cypher 使用一对括号来表示一个节点：()。这让人联想到一个圆形或一个带有圆形端盖的矩形。以下是一些节点的示例，提供了不同类型和数量的详细信息：

\n
()\n(matrix)\n(:Movie)\n(matrix:Movie)\n(matrix:Movie {title: 'The Matrix'})\n(matrix:Movie {title: 'The Matrix', released: 1997})\n

最简单的形式 () 表示一个匿名的、未表征的节点。如果我们要稍后引用该节点，我们可以添加一个变量，例如：(matrix)。变量仅限于单个语句。它在另一个语句中可能具有不同的含义或没有意义。

\n

:Movie 模式声明节点的标签。这允许我们限制模式，防止它匹配（例如）此位置具有 Actor 节点的结构。

\n

节点的属性（例如 title）表示为键值对的列表，括在一对大括号内，例如：{name: 'Keanu Reeves'}。属性可用于存储信息和/或限制模式。

\n

关系语法

\n

Cypher 使用一对破折号 (--) 来表示无向关系。有向关系在一端有一个箭头 (<--，-->)。带括号的表达式 ([...]) 可用于添加详细信息。这可能包括变量、属性和类型信息：

\n
-->\n-[role]->\n-[:ACTED_IN]->\n-[role:ACTED_IN]->\n-[role:ACTED_IN {roles: ['Neo']}]->\n

在关系的括号对中找到的语法和语义与节点括号之间使用的语法和语义非常相似。可以定义一个变量（例如，role），以便在语句中的其他地方使用。关系类型（例如，:ACTED_IN）类似于节点的标签。属性（例如，roles）与节点属性完全等效。

\n

模式语法

\n

结合节点和关系的语法，我们可以表达模式。以下可能是此域中的一个简单模式（或事实）：

\n
(keanu:Person:Actor {name: 'Keanu Reeves'})-[role:ACTED_IN {roles: ['Neo']}]->(matrix:Movie {title: 'The Matrix'})\n

与节点标签等效，:ACTED_IN 模式声明关系的类型。变量（例如，role）可以在语句中的其他地方使用以引用该关系。

\n

与节点属性一样，关系属性表示为括在一对大括号内的键/值对的列表，例如：{roles: ['Neo']}。在这种情况下，我们对角色使用了数组属性，允许指定多个角色。属性可用于存储信息和/或限制模式。

\n

模式变量

\n

为了提高模块化并减少重复，Cypher 允许将模式分配给变量。这允许检查匹配的路径，在其他表达式中使用等。

\n
acted_in = (:Person)-[:ACTED_IN]->(:Movie)\n

acted_in 变量将包含每个找到或创建的路径的两个节点和连接关系。有许多函数可以访问路径的详细信息，例如：nodes(path)、relationships(path) 和 length(path)。

\n

子句

\n

Cypher 语句通常具有多个子句，每个子句执行一个特定任务，例如：

\n\n

通过组合 Cypher 子句，您可以组成复杂的语句，表达您想要知道或创建的内容。

\n

有关 Cypher 子句及其使用的详细信息，请参阅 [Cypher 手册 → 子句](链接到 Cypher 手册 → 子句)。

\n

您还可以访问 [Cypher 速查表](链接到 Cypher 速查表) 以快速参考 Cypher 语法。

\n
","title":"Neo4j官方教程：第8节， 模式","last_reply_at":"2025-04-09T01:36:15.711Z","good":true,"top":false,"reply_count":0,"visit_count":3012,"create_at":"2025-04-09T01:36:15.711Z","author":{"loginname":"pangguoming","avatar_url":"https://avatars.githubusercontent.com/u/7269202?v=4&s=120"}}]}