1. neo4j介绍

neo4j的版本有企业版和社区版。企业版的Neo4j支持多个用户数据库，而社区版的Neo4j只有系统和一个用户数据库。在本教程中，都是使用社区版的Neo4j。

neo4j的官方网站：https://neo4j.com/

Neo4j的特点

• SQL就像简单的查询语言Neo4j CQL
• 它遵循属性图数据模型
• 它通过使用Apache Lucence支持索引
• 它支持UNIQUE约束
• 它包含一个用于执行CQL命令的UI：Neo4j数据浏览器
• 它支持完整的ACID（原子性，一致性，隔离性和持久性）规则
• 它采用原生图形库与本地GPE（图形处理引擎）
• 它支持查询的数据导出到JSON和XLS格式
• 它提供了REST API，可以被任何编程语言（如Java，Spring，Scala等）访问
• 它提供了可以通过任何UI MVC框架（如Node JS）访问的Java脚本
• 它支持两种Java API：Cypher API和Native Java API来开发Java应用程序

Neo4j的优点

• 它很容易表示连接的数据

• 检索/遍历/导航更多的连接数据是非常容易和快速的

• 它非常容易地表示半结构化数据

• Neo4j CQL查询语言命令是人性化的可读格式，非常容易学习

• 使用简单而强大的数据模型

• 它不需要复杂的连接来检索连接的/相关的数据，因为它很容易检索它的相邻节点或关系细节没有连接或索引

Neo4j的数据模型

Neo4j图数据库遵循属性图模型来存储和管理其数据。

图形数据库数据模型的主要构建块是：

• Nodes（节点）： 记录图形数据

• Relationships（关系）： 连接节点

• Properties（属性）： 数据值的名称

  

图形数据库是以图形结构的形式存储数据的数据库。它以节点、关系和属性的形式存储应用程序的数据。正如RDBMS以表的”行“、”列“的形式存储数据。

2. neo4j安装

在安装neo4j之前，都要确定是否在操作系统上已经安装了JAVA。

这里讲述neo4j在windows、linux的安装，以及使用Docker版本。

2.1 Windows 安装

**注意：**4.3.2的neo4j社区版需要的Java版本在11,同时需要移除JAVA 8的环境变量，才能运行neo4j。

2.1.1 安装JDK 11

参考：Windows下安装JDK11（详细版）https://blog.csdn.net/qq_22136439/article/details/103295019

（1）下载JDK安装文件

官方下载地址： https://www.oracle.com/java/technologies/javase-jdk11-downloads.html

需要Oracle账号才能下载。选择windows x64 的安装文件，进行下载。

（2） JDK安装

点击已下载的安装文件jdk-11.0.11_windows-x64_bin.exe

（3）设置环境变量

同时win+R打开运行窗口，载输入框中输入sysdm.cpl命令，目的是打开环境变量面板。

2.1.2 安装neo4j

（1）下载并解压

下载社区版neo4j: https://neo4j.com/artifact.php?name=neo4j-community-4.3.2-windows.zip

neo4j下载地址：https://neo4j.com/download-center/#community

解压下载文件neo4j-community-4.3.2-windows.zip,加压后目录如下图：

Neo4j是以服务器的应用来运行的，并基于网页来管理。

在neo4j的目录下，有以下的文件夹或文件：

• bin - 脚本和其他执行文件目录
• conf - 配置文件目录
• data - 数据库
• lib - 库
• plugins - 插件
• logs - 日志文件
• import - 导入CSV文件的位置

（2）启动neo4j: 打开一个终端，并转到neo4j的安装目录下，然后使用命令启动neo4j

• Windows 使用命令: bin\neo4j console
• Linux/Mac 使用命令: ./bin/neo4j console

按住win + R，输入cmd，打开终端。

# go to the bin directory of neo4j-community
d:
cd D:\neo4j-community-4.3.2\bin

# run the neo4j
neo4j.bat console

（2）启动neo4j: 使用浏览器打开： http://localhost:7474/

Neo4j Browser是一个命令驱动的客户端，就像基于web的shell环境一样。它非常适合运行特定的图查询，具有足够的能力来创建基于neo4j的应用程序原型。

（3）关闭neo4j, 在终端内同时按住Ctrl-C

2.2 使用ne4j docker

2.2.1 Docker

docker的相关学习，可以考虑查看菜鸟教程： https://www.runoob.com/docker/docker-tutorial.html

Docker的安装可以查看： https://docs.docker.com/get-docker/.

Docker Containers（容器）, Images（镜像） and Registry（仓库）:

• Containers： 镜像的运行，一个镜像可以同时让多个容器进行。容器的改变，不会影响镜像文件的改变。
• Registry (docker hub): 云存储镜像
• 一个镜像可以有多个容器来运行，但是一个容器只能运行一个镜像
• docker build 用来创建镜像
• docker pull 用来从Registry下载镜像
• docker run 运行一个镜像并形成容器

Docker命令示意图

2.2.2 neo4j docker

neo4j docker 网站：https://hub.docker.com/_/neo4j

neo4j docker镜像构建等：https://github.com/neo4j/docker-neo4j

运行neo4j (USER: root， 使用root用户的话，一般是因为docker在安装时使用root来安装的。)

docker run \
    --publish=7474:7474 --publish=7687:7687 \
    --volume=$HOME/neo4j/data:/data \
    neo4j

7474是用HTTP接入neo4j, 7687是用Bolt接入neo4j.

volume绑定在/data文件夹中，允许数据库跟容器外部连接

第一次登录：账户和密码都是neo4j

可以通过设置--env=NEO$J_AUTH=none取消身份验证

浏览器打开：http://localhost:7474/browser/

2.3 Linux 安装

安装教程查看： https://blog.csdn.net/weixin_40739969/article/details/103503426

3 neo4j配置

Neo4j的配置文件在 $NEO4J_HOME/conf/neo4j.conf.

社区版的neo4j只能支持一个用户数据库，所以，了解neo4j的配置，对于更改neo4j的数据库很有必要。

（1）设置数据库

Neo4j数据库，默认是放在 $NEO4J_HOME/data/databases 目录下。

Neo4j 4.+

# 设置数据库的名称为neo4j。如果以neo4j命名的数据库不在$NEO4J_HOME/data/database目录下，启动后会该目录下自动生成一个以neo4j命名的数据库
dbms.default_database=neo4j

Neo4j 3.+

# 设置数据库的名称为graph.db。如果以neo4j命名的数据库不在$NEO4J_HOME/data/database目录下，启动后会该目录下自动生成一个以neo4j命名的数据库
dbms.active_database=graph.db

(2) 设置最大内存

# 设置JVM初始堆内存和JVM最大堆内存
# 生产环境给的JVM最大堆内存越大越好，但是要小于机器的物理内存
dbms.memory.heap.initial_size=512m
dbms.memory.heap.max_size=512m

# 是缓存，如果机器配置高，这个越大越好
dbms.memory.pagecache.size=10g

# 限制所有正在运行的事务可以消耗的内存数量。  
# 默认没有限制。  
dbms.memory.transaction.global_max_size=256m

# 限制单个事务可以使用的内存数量。  
# 默认没有限制。  
dbms.memory.transaction.max_size=16m

（3） CSV文件导入的目录

# 默认下，需要导入的CSV文件应该放在 `$NEO4J_HOME/import`目录下才可以。如果想要任意路径下读取文件，需要在下面的语句前面加个#
dbms.directories.import=import

# 允许从远程url来load csv
dbms.security.allow_csv_import_from_file_urls=true

（4）网络设置

设置远程访问

# 去掉改行的#，可以远程通过ip访问neo4j数据库
dbms.connectors.default_listen_address=0.0.0.0

更改端口号

# 默认 bolt端口是7687，http端口是7474，https关口是7473

# Bolt connector
dbms.connector.bolt.enabled=true
#dbms.connector.bolt.tls_level=OPTIONAL
# 设置http端口为7687，端口可以自定义，只要不和其他端口冲突就行
dbms.connector.bolt.listen_address=:7687

# 设置http端口为7474，端口可以自定义，只要不和其他端口冲突就行
dbms.connector.http.enabled=true
dbms.connector.http.listen_address=:7474

# 设置http端口为7473，端口可以自定义，只要不和其他端口冲突就行
dbms.connector.https.enabled=true
dbms.connector.https.listen_address=:7473

Neo4j 运行数限制

# Number of Neo4j worker threads.
#dbms.threads.worker_count=

(5)插件的配置

neo4j的插件应该放在 $NEO4J_HOME/plugins.

# A comma separated list of procedures and user defined functions that are allowed
# full access to the database through unsupported/insecure internal APIs.
#dbms.security.procedures.unrestricted=my.extensions.example,my.procedures.*

# A comma separated list of procedures to be loaded by default.
# Leaving this unconfigured will load all procedures found.
#dbms.security.procedures.whitelist=apoc.coll.*,apoc.load.*

# 比如：增加 `apoc` 和`algo` 插件
dbms.security.procedures.unrestricted=algo.*,apoc.*

(6) 只读模式

# 设置数据库为只读模式。默认是false
dbms.read_only=true

(7) 允许使用neo4j-shell

# 允许使用neo4j-shell，类似于mysql 命令行之类的
dbms.shell.enabled=true

# 设置连接neo4j-shell的端口，一般都是localhost或者127.0.0.1，这样安全，其他地址的话，一般使用https就行
dbms.shell.host=127.0.0.1

# 设置neo4j-shell端口，端口可以自定义，只要不和其他端口冲突就行
dbms.shell.port=1337

4 neo4j的基本操作 - Cypher

4.1 Hellow world

// Hello World!
// 创建Database为标签、属性name的值为"Neo4j"的节点
// 创建Message为标签、属性name的值为"Hello World!"的节点
// 为这两个节点创建关系SAYS为标签的关系。
// 返回这两个节点及其关系
CREATE (database:Database {name:"Neo4j"})-[r:SAYS]->(message:Message {name:"Hello World!"}) RETURN database, message, r

4.2 Cypher介绍

Cypher是一种声明性图形查询语言，允许对图形进行表达性和高效的查询、更新和管理。

Neo4j主要使用的是Cypher查询语言，像Oracle数据库具有查询语言SQL。

Cypher：

• 是Neo4j图形数据库的查询语言

• 是一种声明性模式匹配语言

• 遵循SQL语法

• 语法简单且人性化，可读

• 以命令来执行neo4j数据库操作

• 支持多个子句像在那里、顺序等，以非常简单的方式编写非常复杂的查询

Cypher主要结构是：

• MATCH: 检索有关节点、关系和属性
• WHERE: 设置条件来进行筛选，是MATCH、OPTIONAL MATCH、WITH的一部分。
• RETURN： 返回结果

Cypher常用命令

命令	用法
CREATE	创建节点、关系和属性
MATCH	检索有关节点、关系和属性数据
RETURN	返回查询结果
WHERE	提供条件过滤检索数据
DELETE	删除节点和关系
REMOVE	删除节点和关系的属性
ORDER BY	对检索的数据进行排序
SET	添加或更新标签

Cypher数据类型

这些数据类型与Java语言类似。它们用于定义节点或关系的属性。

数据类型	用法
boolean	用于表示布尔文字：true、false
byte	用于表示8位整数
short	用于表示16位整数
int	用于表示32位整数
long	用于表示64位整数
float	用于表示32位浮点数
double	用于表示64位浮点数
char	用于表示16位字符
String	用于表示字符串

4.3 简单例子 - 创建节点和关系以及检索

创建Person标签、name属性值为’John’、 ‘Joe’、‘Steve’、‘Sara’、 'Maria’五个节点

创建关系：（1）John的朋友是Joe，Joe的朋友是Steve。（2）John的朋友是Sara， Sara的朋友是Maria

CREATE (john:Person {name: 'John'})
CREATE (joe:Person {name: 'Joe'})
CREATE (steve:Person {name: 'Steve'})
CREATE (sara:Person {name: 'Sara'})
CREATE (maria:Person {name: 'Maria'})
CREATE (john)-[:FRIEND]->(joe)-[:FRIEND]->(steve)
CREATE (john)-[:FRIEND]->(sara)-[:FRIEND]->(maria)

查找John和他的朋友以及他朋友的朋友，返回john的名字和和他朋友的朋友的名字

MATCH (john {name: 'John'})-[:FRIEND]->()-[:FRIEND]->(fof)
RETURN john.name, fof.name

查找Label为FRIEND的关系，其中user的name属性值得在’Joe’, ‘John’, ‘Sara’, ‘Maria’, 'Steve’其中之一，follower的name属性以S开头。

返回user的name值和follower的name值。

MATCH (user)-[:FRIEND]->(follower)
WHERE user.name IN ['Joe', 'John', 'Sara', 'Maria', 'Steve'] AND follower.name =~ 'S.*'
RETURN user.name, follower.name

4.4 检索和更新数据库

WITH

查询部分隐式的唯一模式是：显式地显示查询部分，使用WITH语句分隔各个部分。WITH就像是一个事件视界，它是计划和完成计划之间的障碍。

此处是：匹配John和朋友的关系（没有方向的额），然后使用WITH来保留John这个节点，以及计算friend的数量friendsCount，之后使用WHERE来筛选friendsCount大于3的，最后返回结果。

MATCH (n {name: 'John'})-[:FRIEND]-(friend)
WITH n, count(friend) AS friendsCount
WHERE friendsCount > 3
RETURN n, friendsCount

使用WITH，您可以指定希望聚合如何发生，以及必须在Cypher开始过滤之前完成聚合。

SET

设置新的属性friendsCount

MATCH (n {name: 'John'})-[:FRIEND]-(friend)
WITH n, count(friend) AS friendsCount
SET n.friendsCount = friendsCount
RETURN n.friendsCount

获取某些数据

// Get some data
MATCH (n1)-[r]->(n2) RETURN r, n1, n2 LIMIT 25

4.5 路径（path）匹配

Cypher路径匹配使用关系同构，同一关系不能在同一结果记录中返回多次。

• Homomorphism: 路径匹配时没有约束

• Node isomorphism: 对于每个路径匹配记录，同一节点不能返回多次

• Relationship isomorphism: 对于每个路径匹配记录，不能多次返回相同的关系。

Homomorphism

找出所有路径钟包含5个关系的路径

该图像含有节点a和b，关系是(a:Node)-[r:R]->(b:Node)

MATCH p = ()-[*5]-()
RETURN nodes(p)

返回的结果是[a,b,a,b,a,b]，等同于[b,a,b,a,b,a]

Node isomorphism

Constraints（约束）： 对于每个路径匹配记录，同一节点不能返回多次。

该图像含有节点a和b，关系是(a:Node)-[r:R]->(b:Node)

MATCH p = ()-[*1]-()
RETURN nodes(p)

返回的结果是[a,b]，等同于[b,a]

Relationship isomorphism

约束:同一关系不能为每个路径匹配记录返回一次。

该图像含有节点a和b，关系是(a:Node)-[r:R]->(b:Node)

MATCH p = ()-[*1]-()
RETURN nodes(p)

返回的结果是[a,b]，等同于[b,a]

例子

创建关系

CREATE
  (adam:User {name: 'Adam'}),
  (pernilla:User {name: 'Pernilla'}),
  (david:User {name: 'David'}),
  (adam)-[:FRIEND]->(pernilla),
  (pernilla)-[:FRIEND]->(david)

查询Adam朋友的朋友

MATCH (user:User {name: 'Adam'})-[r1:FRIEND]-()-[r2:FRIEND]-(friend_of_a_friend)
RETURN friend_of_a_friend.name AS fofName

在这个查询中，Cypher确保不返回模式关系r1和r2指向相同图关系的匹配项。

等同于

MATCH
  (user:User {name: 'Adam'})-[r1:FRIEND]-(friend),
  (friend)-[r2:FRIEND]-(friend_of_a_friend)
RETURN friend_of_a_friend.name AS fofName

多重MATCH

MATCH (user:User {name: 'Adam'})-[r1:FRIEND]-(friend)
MATCH (friend)-[r2:FRIEND]-(friend_of_a_friend)
RETURN friend_of_a_friend.name AS fofName

4.6 Cypher-帮助文档

Cypher
Cypher Queries
Set a parameter	:help param
Parameters	:help params
Query Plan	:help query plan
Cypher	:help template
Execution Plans
EXPLAIN	:help explain
PROFILE	:help profile
Cypher Help
CREATE	:help create
DELETE	:help delete
DETACH DELETE	:help detach delete
FOREACH	:help foreach
LOAD CSV	:help load csv
MATCH	:help match
MERGE	:help merge
REMOVE	:help remove
RETURN	:help return
SET	:help set
UNWIND	:help unwind
WHERE	:help where
WITH	:help with
Schema Clauses
CREATE CONSTRAINT ON	:help create constraint-on
CREATE INDEX ON	:help create index-on
DROP CONSTRAINT ON	:help drop constraint-on
DROP INDEX ON	:help drop index-on
SCHEMA	:help schema
Administration
ALTER USER	:help alter user
CREATE DATABASE	:help create database
CREATE USER	:help create user
DROP DATABASE	:help drop database
DROP USER	:help drop user
SHOW DATABASES	:help show databases
SHOW USERS	:help show users
Security
CREATE ROLE	:help create role
DENY	:help deny
DROP ROLE	:help drop role
GRANT	:help grant
GRANT ROLE	:help grant role
REVOKE	:help revoke
REVOKE ROLE	:help revoke role
SHOW PRIVILEGES	:help show privileges
SHOW ROLES	:help show roles
Cypher Predicates
CONTAINS	:help contains
ENDS WITH	:help ends with
STARTS WITH	:help starts with
Rest API Commands
REST	:help rest
REST DELETE	:help rest delete
REST GET	:help rest get
REST POST	:help rest post
REST PUT	:help rest put

Documentation

• Cypher速查表

4.7 例子2

（1）删除所有节点和关系

MATCH (n) DETACH DELETE n

再次查看是否还有节点

MATCH (n) RETURN n

（2）使用LOAD CSV 来创建节点

LOAD CSV WITH HEADERS FROM "http://data.neo4j.com/northwind/products.csv" AS row
CREATE (n:Product)
SET n = row,
n.unitPrice = toFloat(row.unitPrice),
n.unitsInStock = toInteger(row.unitsInStock), n.unitsOnOrder = toInteger(row.unitsOnOrder),
n.reorderLevel = toInteger(row.reorderLevel), n.discontinued = (row.discontinued <> "0")

LOAD CSV WITH HEADERS FROM "http://data.neo4j.com/northwind/categories.csv" AS row
CREATE (n:Category)
SET n = row

LOAD CSV WITH HEADERS FROM "http://data.neo4j.com/northwind/suppliers.csv" AS row
CREATE (n:Supplier)
SET n = row

（3）创建索引

CREATE INDEX ON :Product(productID)

CREATE INDEX ON :Category(categoryID)

CREATE INDEX ON :Supplier(supplierID)

（4）创建关系

MATCH (p:Product),(c:Category)
WHERE p.categoryID = c.categoryID
CREATE (p)-[:PART_OF]->(c)

MATCH (p:Product),(s:Supplier)
WHERE p.supplierID = s.supplierID
CREATE (s)-[:SUPPLIES]->(p)

4.8 数据概化

// 所有节点数量
MATCH (n)
RETURN count(n)

// 所有关系类型数目
MATCH ()-->() RETURN count(*);

// 所有约束和索引
:schema

// 节点标签列表
CALL db.labels()

// 关系类型列表
CALL db.relationshipTypes()

// 节点-关系（路径）类型
CALL db.schema.visualization()

// What kind of nodes exist
// Sample some nodes, reporting on property and relationship counts per node.
MATCH (n) WHERE rand() <= 0.1
RETURN
DISTINCT labels(n),
count(*) AS SampleSize,
avg(size(keys(n))) as Avg_PropertyCount,
min(size(keys(n))) as Min_PropertyCount,
max(size(keys(n))) as Max_PropertyCount,
avg(size( (n)-[]-() ) ) as Avg_RelationshipCount,
min(size( (n)-[]-() ) ) as Min_RelationshipCount,
max(size( (n)-[]-() ) ) as Max_RelationshipCount

4.9 通用程序

// List functions
CALL dbms.functions()

// List procedures
CALL dbms.procedures()

// List running queries
CALL dbms.listQueries()

// Schedule resampling of an index
// E.g. db.resampleIndex(":Person(name)")
CALL db.resampleIndex(<param>)

// Show meta-graph
CALL db.schema.visualization()

// Wait for index to come online
// E.g. db.awaitIndex(":Person(name)")
CALL db.awaitIndex(<param>)

4.10 数据库 - 可能是企业版的才能用

// 查看可以使用的数据库
:dbs

// 使用neo4j数据库
:use neo4j

5. neo4j的高级操作 - Cypher

5.1 命名原则

字母字符串：

• 应该以字母为第一个字母

• 包含"non-English"字符串，比如å, ä, ö, ü

数字

• 命名不能以数字开头
• 1first是不允许的，first1就可以

5.2 Cypher表达式

Cypher 中的表达式可以是：

• 十进制（整数或浮点数）文字：13, -40000,3.14
• 以科学记数法表示的十进制（整数或浮点数）文字：6.022E23.
• 十六进制整数文字（以 开头0x）：0x13af, 0xFC3A9, -0x66eff.
• 八进制整数文字（以0o或开头0）：0o1372, 02127, -0o5671.
• 字符串文字：'Hello', "World".
• 布尔文字：true, false.
• 一个变量：n, x, rel, myFancyVariable, A name with weird stuff in it[]!。
• 属性：n.prop, x.prop, rel.thisProperty, myFancyVariable.(weird property name)``。
• 动态属性：n["prop"], rel[n.city + n.zip], map[coll[0]]。
• 一个参数：$param, $0。
• 表达式列表：['a', 'b'], [1, 2, 3], ['a', 2, n.property, $param], [].
• 函数调用：length(p), nodes(p).
• 聚合函数：avg(x.prop), count(*).
• 路径模式：(a)-[r]->(b), (a)-[r]-(b), (a)--(b), (a)-->()<--(b)。
• 运算符应用程序：1 + 2, 3 < 4.
• 谓词表达式是返回 true 或 false 的表达式：a.prop = 'Hello', length(p) > 10, a.name IS NOT NULL。
• 一个存在的子查询是返回true或false的表达式： EXISTS { MATCH (n)-[r]→(p) WHERE p.name = 'Sven' }。
• 正则表达式：a.name =~ 'Tim.*'.
• 区分大小写的字符串匹配表达式：a.surname STARTS WITH 'Sven',a.surname ENDS WITH 'son'或a.surname CONTAINS 'son'。

5.3 CASE的使用

https://neo4j.com/docs/cypher-manual/4.3/syntax/expressions/

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

5.4 运算符

数学运算符	+,-,*,/,%,^
比较运算符	=,<>,<,>,<=,>=,IS NULL,IS NOT NULL
布尔运算符	AND,OR,XOR,NOT
字符串运算符	+用于连接，=~用于正则表达式匹配
时间运算符	+以及-持续时间和时间瞬间/持续时间之间的操作，*以及/持续时间和数字之间的操作
列出运算符	+用于连接，IN检查列表中元素的存在，[]用于动态访问元素

5.4.1 DISTINCT： 删除重复值

CREATE
  (a:Person {name: 'Anne', eyeColor: 'blue'}),
  (b:Person {name: 'Bill', eyeColor: 'brown'}),
  (c:Person {name: 'Carol', eyeColor: 'blue'})
WITH [a, b, c] AS ps
UNWIND ps AS p
RETURN DISTINCT p.eyeColor

5.4.2 属性运算符

属性运算符与节点或关系有关，包括：

• 使用点运算符静态访问节点或关系的属性： .
• 使用下标运算符动态访问节点或关系的属性： []
• =用于替换节点或关系的所有属性的属性替换
• +=用于设置节点或关系的特定属性的属性变异操作符

使用.运算符静态访问节点或关系的属性

CREATE
  (a:Person {name: 'Jane', livesIn: 'London'}),
  (b:Person {name: 'Tom', livesIn: 'Copenhagen'})
WITH a, b
MATCH (p:Person)
RETURN  p.name

使用[]运算符过滤动态计算的属性键

CREATE
  (a:Restaurant {name: 'Hungry Jo', rating_hygiene: 10, rating_food: 7}),
  (b:Restaurant {name: 'Buttercup Tea Rooms', rating_hygiene: 5, rating_food: 6}),
  (c1:Category {name: 'hygiene'}),
  (c2:Category {name: 'food'})
WITH a, b, c1, c2
MATCH (restaurant:Restaurant), (category:Category)
WHERE restaurant["rating_" + category.name] > 6
RETURN DISTINCT restaurant.name

使用=运算符替换节点或关系的所有属性

CREATE (a:Person {name: 'Jane', age: 20})
WITH a
MATCH (p:Person {name: 'Jane'})
SET p = {name: 'Ellen', livesIn: 'London'}
RETURN p.name, p.age, p.livesIn

使用+=运算符改变节点或关系的特定属性

CREATE (a:Person {name: 'Jane', age: 20})
WITH a
MATCH (p:Person {name: 'Jane'})
SET p += {name: 'Ellen', livesIn: 'London'}
RETURN p.name, p.age, p.livesIn

5.4.3 数学运算符

使用求幂运算符^

WITH 2 AS number, 3 AS exponent
RETURN number ^ exponent AS result

使用一元减运算符-

WITH -3 AS a, 4 AS b
RETURN b - a AS result

5.4.4 比较运算符

比较运算符包括：

• 平等： =
• 不等式： <>
• 少于： <
• 比…更棒： >
• 小于或等于： <=
• 大于或等于： >=
• IS NULL
• IS NOT NULL

特定于字符串的比较运算符包括：

• STARTS WITH: 对字符串执行区分大小写的前缀搜索
• ENDS WITH: 对字符串执行区分大小写的后缀搜索
• CONTAINS: 在字符串中执行区分大小写的包含搜索

比较两个数字

WITH 4 AS one, 3 AS two
RETURN one > two AS result

使用STARTS WITH以过滤器名称

WITH ['John', 'Mark', 'Jonathan', 'Bill'] AS somenames
UNWIND somenames AS names
WITH names AS candidate
WHERE candidate STARTS WITH 'Jo'
RETURN candidate

链式比较操作

比较可以任意链接，例如，x < y <= z等效于x < y AND y <= z。

MATCH (n) WHERE 21 < n.age <= 30 RETURN n

等同于

MATCH (n) WHERE 21 < n.age AND n.age <= 30 RETURN n

5.4.5 布尔运算符

布尔运算符 — 也称为逻辑运算符 — 包括：

• 连词： AND
• 分离：OR,
• 排他性分离： XOR
• 否定： NOT

WITH [2, 4, 7, 9, 12] AS numberlist
UNWIND numberlist AS number
WITH number
WHERE number = 4 OR (number > 6 AND number < 10)
RETURN number

5.4.6 字符串运算符

字符串运算符包括：

• 连接字符串： +
• 匹配正则表达式： =~

WITH ['mouse', 'chair', 'door', 'house'] AS wordlist
UNWIND wordlist AS word
WITH word
WHERE word =~ '.*ous.*'
RETURN word

5.5 注释

以//开始并一直到行尾

6 函数

各类函数的使用

6.1 判定函数

all()

all()对给定列表钟的所有元素都成立时，返回true。如果列表为空或其所有元素为空，则返回null

语法： all(variable IN list WHERE predicate)

MATCH p = (a)-[*1..3]->(b)
WHERE
  a.name = 'Alice'
  AND b.name = 'Daniel'
  AND all(x IN nodes(p) WHERE x.age > 30)
RETURN p

any()

any()对给定列表钟至少有一个元素是成立的，返回true。如果列表为空或其所有元素为空，则返回null

语法：any(variable IN list WHERE predicate)

MATCH (n)
WHERE any(color IN n.liked_colors WHERE color = 'yellow')
RETURN n

exists()

如果存在与给定模式匹配的对象（节点、关系或映射中存在指定的属性），则exists()函数返回true。

语法：exists(pattern-or-property)

MATCH (n)
WHERE exists(n.name)
RETURN
  n.name AS name,
  exists((n)-[:MARRIED]->()) AS is_married

MATCH
  (a),
  (b)
WHERE
  exists(a.name)
  AND NOT exists(b.name)
OPTIONAL MATCH (c:DoesNotExist)
RETURN
  a.name AS a_name,
  b.name AS b_name,
  exists(b.name) AS b_has_name,
  c.name AS c_name,
  exists(c.name) AS c_has_name
ORDER BY a_name, b_name, c_name
LIMIT 1

isEmpty()

如果给定的列表没有不包含元素，返回true

语法：isEmpty(list)

MATCH (n)
WHERE NOT isEmpty(n.liked_colors)
RETURN n

MATCH (n)
WHERE isEmpty(properties(n))
RETURN n

none()

如果不包含给定列表中的任何元素，返回true。否则返回null

语法：none(variable IN list WHERE predicate)

MATCH p = (n)-[*1..3]->(b)
WHERE
  n.name = 'Alice'
  AND none(x IN nodes(p) WHERE x.age = 25)
RETURN p

single()

如果在给定列表中的一个元素成立，返回true。

语法：single(variable IN list WHERE predicate)

MATCH p = (n)-->(b)
WHERE
  n.name = 'Alice'
  AND single(var IN nodes(p) WHERE var.eyes = 'blue')
RETURN p

6.2 标量函数

返回的是单个值。

coalesce()

返回给定表达式列表中的第一个非空值。

语法：coalesce(expression [, expression]*)

MATCH (a)
WHERE a.name = 'Alice'
RETURN coalesce(a.hairColor, a.eyes)

endNode()

返回关系中的最后一个节点

语法：endNode(relationship)

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

head()

返回列表中的第一个元素

语法：head(expression)

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

id()

返回由对象类型和数据库唯一的节点或关系标识符。

语法：id(expression)

MATCH (a)
RETURN id(a)

last()

返回列表中的最后一个元素。

语法：last(expression)

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

length()

返回路径的长度。

语法：length(path)

MATCH p = (a)-->(b)-->(c)
WHERE a.name = 'Alice'
RETURN length(p)

properties()

返回所有属性的映射，可用于关系或节点。

语法properties(expression)

CREATE (p:Person {name: 'Stefan', city: 'Berlin'})
RETURN properties(p)

randomUUID()

返回一个随机生成的全局唯一标识符(UUID)，也称为全局唯一标识符(GUID)

语法：randomUUID()

RETURN randomUUID() AS uuid

size()

针对列表

返回列表的元素数量

语法：size(list)

RETURN size(['Alice', 'Bob'])

针对路径

语法：size(pattern expression)

MATCH (a)
WHERE a.name = 'Alice'
RETURN size((a)-->()-->()) AS fof

针对字符串

语法：size(string)

MATCH (a)
WHERE size(a.name) > 6
RETURN size(a.name)

startNode()

返回路径的第一个节点。

语法：startNode(relationship)

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

timestamp()

返回当前时间和午夜之间以毫秒为单位的差值，

RETURN timestamp()

toBoolean()

将字符串、整数或布尔值转换为布尔值。

语法：toBoolean(expression)

RETURN toBoolean('true'), toBoolean('not a boolean'), toBoolean(0)

toBooleanOrNull()

将字符串、整数或布尔值转换为布尔值, 如果是其他值，则转换成null

语法：toBooleanOrNull(expression)

RETURN toBooleanOrNull('true'), toBooleanOrNull('not a boolean'), toBooleanOrNull(0), toBooleanOrNull(1.5)

toFloat()

将整数、浮点数或字符串值转换为浮点数。

语法：toFloat(expression)

RETURN toFloat('11.5'), toFloat('not a number')

toFloarOrNull()

将整数、浮点数或字符串值转换为浮点数，如果是其他值，则转换成null

语法：toFloatOrNull(expression)

RETURN toFloatOrNull('11.5'), toFloatOrNull('not a number'), toFloatOrNull(true)

toInteger()

将布尔型、整型、浮点型或字符串值转换为整型值。

语法：toInteger(expression)

RETURN toInteger('42'), toInteger('not a number'), toInteger(true)

toIntegerOrNull()

将布尔型、整型、浮点型或字符串值转换为整型值，如果是其他值，则转换成null

语法：toIntegerOrNull(expression)

RETURN toIntegerOrNull('42'), toIntegerOrNull('not a number'), toIntegerOrNull(true), toIntegerOrNull(['A', 'B', 'C'])

type()

返回关系类型

语法：type(relationship)

MATCH (n)-[r]->()
WHERE n.name = 'Alice'
RETURN type(r)

6.3 聚合函数

avg()

求平均数。

语法：avg(expression)

MATCH (n:Person)
RETURN avg(n.age)

collect()

返回单个集合列表。

语法：collect(expression)

MATCH (n:Person)
RETURN collect(n.age)

count()

返回节点数量。

MATCH (n {name: 'A'})-->(x)
RETURN labels(n), n.age, count(*)

使用count(*)统计关系类型

MATCH (n {name: 'A'})-[r]->()
RETURN type(r), count(*)

MATCH (n {name: 'A'})-->(x)
RETURN count(x)

统计没有重复的数量

语法：count(DISTINCT friend_of_friend)

MATCH (me:Person)-->(friend:Person)-->(friend_of_friend:Person)
WHERE me.name = 'A'
RETURN count(DISTINCT friend_of_friend), count(friend_of_friend)

max()

返回最大值

语法：max(expression)

UNWIND [1, 'a', null, 0.2, 'b', '1', '99'] AS val
RETURN max(val)

UNWIND [[1, 'a', 89], [1, 2]] AS val
RETURN max(val)

MATCH (n:Person)
RETURN max(n.age)

min()

返回最小值。

语法：min(expression)

UNWIND [1, 'a', null, 0.2, 'b', '1', '99'] AS val
RETURN min(val)

UNWIND ['d', [1, 2], ['a', 'c', 23]] AS val
RETURN min(val)

MATCH (n:Person)
RETURN min(n.age)

percentileCont()

计算给定值在一组中的百分比。

语法:percentileCont(expression, percentile)

MATCH (n:Person)
RETURN percentileCont(n.age, 0.4)

percentileDisc()

给定值在一组上的百分比，百分比从0.0到1.0。它使用四舍五入的方法来计算最接近百分位数的值。

语法：percentileDisc(expression, percentile)

MATCH (n:Person)
RETURN percentileDisc(n.age, 0.5)

stDev()

计算标准差。

MATCH (n)
WHERE n.name IN ['A', 'B', 'C']
RETURN stDev(n.age)

stDevP()

函数stDevP()返回给定值在组上的标准偏差。它使用标准的双通道方法，以N为分母，应该在计算整个总体的标准差时使用。当仅计算总体样本的标准变异时，应使用stDev。

MATCH (n)
WHERE n.name IN ['A', 'B', 'C']
RETURN stDevP(n.age)

sum()

求和。

MATCH (n:Person)
RETURN sum(n.age)

6.4 列表函数

keys()

Keys返回一个列表，其中包含节点、关系或映射的所有属性名的字符串表示形式。

MATCH (a) WHERE a.name = 'Alice'
RETURN keys(a)

labels()

返回标签。

语法：labels(node)

MATCH (a) WHERE a.name = 'Alice'
RETURN labels(a)

nodes()

返回一个列表，包含路径中所有节点。

语法：nodes(path)

MATCH p = (a)-->(b)-->(c)
WHERE a.name = 'Alice' AND c.name = 'Eskil'
RETURN nodes(p)

range()

返回一个列表，该列表包含起始值start和结束值end范围内的所有整数值

语法：range(start, end [, step])

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

reduce()

返回对列表中每个连续元素应用表达式所得到的值，以及到目前为止的计算结果。

语法：reduce(accumulator = initial, variable IN list | expression)

MATCH p = (a)-->(b)-->(c)
WHERE a.name = 'Alice' AND b.name = 'Bob' AND c.name = 'Daniel'
RETURN reduce(totalAge = 0, n IN nodes(p) | totalAge + n.age) AS reduction

relationships()

返回包含路径中所有关系的列表。

语法：relationships(path)

MATCH p = (a)-->(b)-->(c)
WHERE a.name = 'Alice' AND c.name = 'Eskil'
RETURN relationships(p)

reverse()

返回一个列表，其中原始列表中所有元素的顺序都被颠倒了。

语法：reverse(original)

WITH [4923,'abc',521, null, 487] AS ids
RETURN reverse(ids)

tail()

返回一个列表，除了不包含第一元素，其他都包含

MATCH (a) WHERE a.name = 'Eskil'
RETURN a.array, tail(a.array)

toBooleanList()

将列表中的值都转换成布尔值。

RETURN toBooleanList(null) as noList,
toBooleanList([null, null]) as nullsInList,
toBooleanList(['a string', true, 'false', null, ['A','B']]) as mixedList

toFloatList()

将列表中的值都转换成浮点型。

RETURN toFloatList(null) as noList,
toFloatList([null, null]) as nullsInList,
toFloatList(['a string', 2.5, '3.14159', null, ['A','B']]) as mixedList

toIntegerList()

将列表中的值都转换成整数型。

RETURN toIntegerList(null) as noList,
toIntegerList([null, null]) as nullsInList,
toIntegerList(['a string', 2, '5', null, ['A','B']]) as mixedList

toStringList()

将列表中的值都转换成字符串。

RETURN toStringList(null) as noList,
toStringList([null, null]) as nullsInList,
toStringList(['already a string', 2, date({year:1955, month:11, day:5}), null, ['A','B']]) as mixedList

6.5 数学函数 - 数字

abs() 求绝对值

MATCH (a), (e) WHERE a.name = 'Alice' AND e.name = 'Eskil' RETURN a.age, e.age, abs(a.age - e.age)

ceil() 求大于或等于给定值的最小整数

RETURN ceil(0.1)

floor() 求小于或等于给定值的最大整数

RETURN floor(0.9)

rand() 返回0-1之间的随机浮点数

RETURN rand()

round()求近似值

RETURN round(3.141592)

保留3位小数

RETURN round(3.141592, 3)

sign()求给定值的正负号函数

RETURN sign(-17), sign(0.1)

6.6 数学函数 - 对数

e() 返回自然对数E的底

RETURN e()

exp()求幂

RETURN exp(2)

log() 返回数字的自然对数。

RETURN log(27)

log10()返回以10为底的对数。

RETURN log10(27)

sqrt()求平方根

RETURN sqrt(256)

6.7 数学函数 - 三角函数

acos()求反余弦值

RETURN acos(0.5)

asin()求反正弦值

RETURN asin(0.5)

atan()反正切值

RETURN atan(0.5)

cos()求余弦值

RETURN cos(0.5)

cot()求余切值

RETURN cot(0.5)

degrees()转换为度数

RETURN degrees(3.14159)

pi() 返回常数Π

RETURN pi()

radians() 将度数转换成弧度

RETURN radians(180)

sin()求正弦值

RETURN sin(0.5)

tan()求正切值

RETURN tan(0.5)

6.8 字符串函数

left()

返回一个字符串，该字符串包含原始字符串中最左边的指定数量的字符

语法：left(original, length)

RETURN left('hello', 3)

lTrim()

返回删除前导空格的原始字符串

语法：lTrim(original)

RETURN lTrim('   hello')

replace()

返回一个字符串，其中原始字符串中的所有指定字符串都已被另一个(指定)字符串替换。

语法：replace(original, search, replace)

RETURN replace("hello", "l", "w")

reverse()

返回一个字符串，其中原始字符串中所有字符的顺序都被颠倒了。

语法：reverse(original)

RETURN reverse('anagram')

right()

返回一个字符串，该字符串包含原始字符串中最右边的指定数量的字符。

语法：right(original, length)

RETURN right('hello', 3)

rTrim()

返回删除尾随空格的原始字符串

语法：rTrim(original)

RETURN rTrim('hello   ')

split()

返回一个字符串列表，其结果是将原始字符串围绕给定分隔符的匹配进行分割。

语法：split(original, splitDelimiter)

RETURN split('one,two', ',')

substring()

返回原始字符串的子字符串，以基于0的索引开始和长度开始。

语法：

RETURN substring('hello', 1, 3), substring('hello', 2)

toLower()

返回小写的原始字符串

语法：toLower(original)

RETURN toLower('HELLO')

toString()

转换成字符串

语法：toString(expression)

RETURN toString(11.5),
toString('already a string'),
toString(true),
toString(date({year:1984, month:10, day:11})) AS dateString,
toString(datetime({year:1984, month:10, day:11, hour:12, minute:31, second:14, millisecond: 341, timezone: 'Europe/Stockholm'})) AS datetimeString,
toString(duration({minutes: 12, seconds: -60})) AS durationString

toStringOrNull()

转换成字符串.

语法：toStringOrNull(expression)

RETURN toStringOrNull(11.5),
toStringOrNull('already a string'),
toStringOrNull(true),
toStringOrNull(date({year:1984, month:10, day:11})) AS dateString,
toStringOrNull(datetime({year:1984, month:10, day:11, hour:12, minute:31, second:14, millisecond: 341, timezone: 'Europe/Stockholm'})) AS datetimeString,
toStringOrNull(duration({minutes: 12, seconds: -60})) AS durationString,
toStringOrNull(['A', 'B', 'C']) AS list

toUpper()

返回大写的原始字符串

语法：toUpper(original)

RETURN toUpper('hello')

trim()

删除字两端的空格

RETURN trim('   hello   ')

7 Index(索引)

7.1 Index介绍

数据库索引是数据库中某些数据的冗余副本，用于提高搜索相关数据的效率。

一旦创建索引，DBMS将对齐进行管理并保持最新。一旦创建并上线，neo4j将自动获取并开始使用索引。

Cypher可以为具有给定标签或关系类型的所有节点或关系创建一个或多个属性的索引：

• 单个属性索引：在单个属性上创建的索引。
• 符合索引：在多个属性上创建的索引。

7.2 创建Index

创建索引

// Create an index
// Replace:
//   'IndexName' with name of index (optional)
//   'LabelName' with label to index
//   'propertyName' with property to be indexed
CREATE INDEX [IndexName] 
FOR (n:LabelName)
ON (n.propertyName)

创建唯一的属性约束值

// Create unique property constraint
// Replace:
//   'LabelName' with node label
//   'propertyKey' with property that should be unique
CREATE CONSTRAINT ON (n:<LabelName>) ASSERT n.<propertyKey> IS UNIQUE

为节点创建单属性索引

CREATE INDEX node_index_name FOR (n:Person) ON (n.surname)

为关系创建一个单属性索引

CREATE INDEX rel_index_name FOR ()-[r:KNOWS]-() ON (r.since)

只有在单属性索引不存在的情况下才创建它

CREATE INDEX node_index_name IF NOT EXISTS FOR (n:Person) ON (n.surname)

使用指定的索引提供程序创建单属性索引

CREATE BTREE INDEX index_with_provider FOR ()-[r:TYPE]-() ON (r.prop1) OPTIONS {indexProvider:
  'native-btree-1.0'}

使用指定的索引配置创建一个单属性索引

CREATE BTREE INDEX index_with_config FOR (n:Label) ON (n.prop2)
OPTIONS {indexConfig: {`spatial.cartesian.min`: [-100.0, -100.0], `spatial.cartesian.max`: [100.0,
  100.0]}}

为节点创建一个复合索引

CREATE INDEX node_index_name FOR (n:Person) ON (n.age, n.country)

为关系创建一个综合索引

CREATE INDEX rel_index_name FOR ()-[r:PURCHASED]-() ON (r.date, r.amount)

使用指定的索引提供程序和配置创建复合索引

CREATE INDEX index_with_options FOR (n:Label) ON (n.prop1, n.prop2)
OPTIONS {
 indexProvider: 'lucene+native-3.0',
 indexConfig: {`spatial.wgs-84.min`: [-100.0, -80.0], `spatial.wgs-84.max`: [100.0, 80.0]}
}

创建一个节点标签查找索引

CREATE LOOKUP INDEX node_label_lookup_index FOR (n) ON EACH labels(n)

创建关系类型查找索引

CREATE LOOKUP INDEX rel_type_lookup_index FOR ()-[r]-() ON EACH type(r)

7.3 列出所有index

列出所有索引

SHOW INDEXES

使用过滤列出索引

SHOW BTREE INDEXES WHERE uniqueness = 'NONUNIQUE'

7.4 删除index

删除索引

DROP INDEX index_name

删除不存在的索引

DROP INDEX missing_index_name IF EXISTS

8 neo4j和R

使用R来操作neo4j的话，有三个R包可以来用。但是呢，所使用的neo4j的版本应该是3+的，而不是4+。

这三个R包分别是：

RNeo4j

neo4jshell

neo4r

在这里主要展示我比较喜欢用的RNeo4j的使用。

启用身份验证

在neo4j的配置文件neo4j.conf，如果需要启用身份验证，将dbms.security.auth_enabled=false改成dbms.security.auth_enabled=true,并删除前面的#

8.1 RNeo4j

安装RNeo4j

#install.packages("devtools")
devtools::install_github("nicolewhite/RNeo4j")

连接数据库

#加载R包
library(RNeo4j)
# 连接数据库
graph = startGraph("http://localhost:7474/db/data/", username="neo4j", password="neo4j")

创建节点

nicole = createNode(graph, "Person", name="Nicole", age=24)
greta = createNode(graph, "Person", name="Greta", age=24)
kenny = createNode(graph, "Person", name="Kenny", age=27)
shannon = createNode(graph, "Person", name="Shannon", age=23)

创建关系

r1 = createRel(greta, "LIKES", nicole, weight=7)
r2 = createRel(nicole, "LIKES", kenny, weight=1)
r3 = createRel(kenny, "LIKES", shannon, weight=3)
r4 = createRel(nicole, "LIKES", shannon, weight=5)

使用cypher进行查询

query = "
MATCH (nicole:Person)-[r:LIKES]->(p:Person)
WHERE nicole.name = 'Nicole'
RETURN nicole.name, r.weight, p.name
"

cypher(graph, query)
# 返回的是一个数据框

使用cypherToList()查询

query = "
MATCH (nicole:Person)-[:LIKES]->(p:Person)
WHERE nicole.name = 'Nicole'
RETURN nicole, COLLECT(p.name) AS friends
"

cypherToList(graph, query)
# 返回的是一个列表

cypher()和cypherToList()查询时，都可以接入参数

query = "
MATCH (p1:Person)-[r:LIKES]->(p2:Person)
WHERE p1.name = {name1} AND p2.name = {name2}
RETURN p1.name, r.weight, p2.name
"
cypher(graph, query, name1="Nicole", name2="Shannon")
cypher(graph, query, list(name1="Nicole", name2="Shannon"))

最短路径查询

p = shortestPath(greta, "LIKES", shannon, max_depth=4)
n = nodes(p)
sapply(n, "[[", "name")

带有权重的最短路径查询

p = shortestPath(greta, "LIKES", shannon, max_depth=4, cost_property="weight")
n = nodes(p)
sapply(n, "[[", "name")

图形算法

library(igraph)

query = "
MATCH (n)-->(m)
RETURN n.name, m.name
"

edgelist = cypher(graph, query)
ig = graph.data.frame(edgelist, directed=F)

betweenness(ig)

可视化-使用igraph

plot(ig)

可视化-使用ggnet

library(network)
library(GGally)

net = network(edgelist)
ggnet(net, label.nodes=TRUE)

导入数据到数据库中

library(hflights)
hflights = hflights[sample(nrow(hflights), 1000), ]
row.names(hflights) = NULL

head(hflights)

addConstraint(graph, "Carrier", "name")
addConstraint(graph, "Airport", "name")

query = "
CREATE (flight:Flight {number: {FlightNum} })
SET flight.year = TOINT({Year}),
    flight.month = TOINT({DayofMonth}),
    flight.day = TOINT({DayOfWeek})

MERGE (carrier:Carrier {name: {UniqueCarrier} })
CREATE (flight)-[:OPERATED_BY]->(carrier)

MERGE (origin:Airport {name: {Origin} })
MERGE (dest:Airport {name: {Dest} })

CREATE (flight)-[o:ORIGIN]->(origin)
CREATE (flight)-[d:DESTINATION]->(dest)

SET o.delay = TOINT({DepDelay}),
    o.taxi_time = TOINT({TaxiOut})

SET d.delay = TOINT({ArrDelay}),
    d.taxi_time = TOINT({TaxiIn})
"

tx = newTransaction(graph)

for(i in 1:nrow(hflights)) {
  row = hflights[i, ]
  
  appendCypher(tx, query,
               FlightNum=row$FlightNum,
               Year=row$Year,
               DayofMonth=row$DayofMonth,
               DayOfWeek=row$DayOfWeek,
               UniqueCarrier=row$UniqueCarrier,
               Origin=row$Origin,
               Dest=row$Dest,
               DepDelay=row$DepDelay,
               TaxiOut=row$TaxiOut,
               ArrDelay=row$ArrDelay,
               TaxiIn=row$TaxiIn)
}

commit(tx)

summary(graph)

9 插件安装

(1)下载插件
根据不同的neo4版本，下载对应的插件版本。如果版本下载错了，启动neo4j的时候，是会报错的。
graph-data-science插件下载地址为：
https://github.com/neo4j/graph-data-science/releases

apoc插件下载地址为：
https://github.com/neo4j-contrib/neo4j-apoc-procedures/releases
下载apoc-***-all.jar和neo4j-graph-data-science-***.jar到plugins文件夹下

（2）编辑conf文件
在conf/neo4j.conf文件中添加下面的指令即可。
针对apoc插件：

dbms.security.procedures.unrestricted=apoc.*

针对graoh-data-science插件：

dbms.security.procedures.unrestricted=neo4j-graph-data-science.*