Neo4j的安装与使用 | 胖不了小陆

link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

地址相关：

下载地址： https://neo4j.com/download-center/#community
操作手册地址： https://neo4j.com/docs/operations-manual/4.4/introduction/
入门开发指南： https://neo4j.com/docs/getting-started/4.4/
桌面版文档： https://neo4j.com/docs/desktop-manual/current/

# 安装服务
neo4j install-service

# 卸载服务
neo4j uninstall-service

# 启动
neo4j start

# 停止
neo4j stop
	
# 重启
neo4j restart

# 查询服务状态
neo4j status

三、 Cypher 简介

Neo4j安装好之后，就可以给它添加数据了.

Cypher是一种声明性图形查询语言，允许对图形进行富有表现力和有效的查询，更新和管理。
文档地址： https://neo4j.com/docs/cypher-manual/current/
语法格式： https://neo4j.com/docs/cypher-cheat-sheet/4.4/

1、 Cypher 语法

常用的语法有

创建语法格式大致如下：

// 方式一： 格式
CREATE (
   <node-name>:<label-name>
   { 	
      <Property1-name>:<Property1-Value>
      ........
      <Propertyn-name>:<Propertyn-Value>
   }
)

// 方式二: 创建几点的时候，直接建立关系
CREATE (节点名称)-[:关系]->(节点名称)-[:关系]->(节点)


// 方式三 一个节点创建多个标签，Movie, Person是m节点的多个标签名称
CREATE (m:Movie:Person)

来一个实战语法：

// 创建大话西游两部电影节点 Movie
CREATE (moon:Movie {title:'大话西游之月光宝盒', released:1994, tagline:'是由周星驰彩星电影公司和西安电影制片厂联合摄制的爱情悲喜剧系列电影，由刘镇伟执导，周星驰、朱茵、吴孟达、蓝洁瑛、莫文蔚等主演'})
CREATE (marry:Movie {title:'大话西游之大圣娶亲', released:1995, tagline:'是由周星驰彩星电影公司和西安电影制片厂联合摄制的爱情悲喜剧系列电影，由刘镇伟执导，周星驰、朱茵、吴孟达、蓝洁瑛、莫文蔚等主演'})

// 创建人物节点 Person
CREATE (zhouxx:Person {name:'周星驰', born:1962})
CREATE (zy:Person {name:'朱茵', born:1962})
CREATE (wmd:Person {name:'吴孟达', born:1963})
CREATE (mww:Person {name:'莫文蔚', born:1964})
CREATE (ljy:Person {name:'蓝洁瑛', born:1965})
CREATE (luo:Person {name:'罗家英', born:1965})
CREATE (zsf:Person {name:'蔡少芬', born:1965})

// 创建人物与电影的关系
CREATE
  (zhouxx)-[:ACTED_IN {roles:['至尊宝','孙悟空']}]->(moon),
  (zhouxx)-[:ACTED_IN {roles:['至尊宝、孙悟空、夕阳武士']}]->(marry),
  (zy)-[:ACTED_IN {roles:['紫霞仙子']}]->(moon),
  (wmd)-[:ACTED_IN {roles:['二当家、猪八戒']}]->(moon),
  (mww)-[:ACTED_IN {roles:['白晶晶']}]->(moon),
  (ljy)-[:ACTED_IN {roles:[' 春三十娘']}]->(moon),
  (luo)-[:ACTED_IN {roles:['唐三藏']}]->(moon), 
  (zsf)-[:ACTED_IN {roles:['铁扇公主']}]->(moon),
  (zy)-[:ACTED_IN {roles:['紫霞仙子、青霞仙子、盘丝大仙']}]->(marry),
 (wmd)-[:ACTED_IN {roles:['二当家、猪八戒']}]->(marry),
 (mww)-[:ACTED_IN {roles:['白晶晶']}]->(marry),
 (luo)-[:ACTED_IN {roles:['唐僧']}]->(marry),
  (zsf)-[:ACTED_IN {roles:['铁扇公主']}]->(marry),
  (ljy)-[:ACTED_IN {roles:[' 春三十娘']}]->(marry),
  (zhouxx)-[:DIRECTED]->(moon),
  (zhouxx)-[:DIRECTED]->(marry)

ACTED_IN 代表关系类型，表演的意思，DIRECTED 也是关系类型，导演

执行上面命令之后，可得节点如下：

②、MATCH

MATCH 检索有关节点，关系和属性数据

// 查询所有节点
MATCH (n) RETURN n

// LIMIT 分页获取节点
MATCH (n) RETURN n LIMIT 10

// SKIP 跳过几个节点，LIMIT 分页
MATCH (n) RETURN n  SKIP 10 LIMIT 2

// 查询导演的节点关系，加 LIMIT 25分页
MATCH




    
 p=()-[r:DIRECTED]->() RETURN p 

// 查询 表演关系节点，分页
MATCH p=()-[r:ACTED_IN]->() RETURN p LIMIT 25

③、RETURN

RETURN常与其他语法组合使用

可以返回节点的某些属性，或所有属性，关联关系的属性等


// 查询name=周星驰的节点
MATCH (n:Person{name:"周星驰"}) return n;

// 返回节点的部分属性
MATCH (n:Person{name:"周星驰"}) return n.name,n.born;

// 查询 Person类型的所有节点
MATCH (n:Person) return n;

// 查询 Persion和Movie两种类型的节点
MATCH (n:Person) MATCH(a:Movie) return n,a;

④、WHERE

WHERE子句一般是用来过滤MATCH查询的结果


// 查询 Person节点，born=1962的所有节点
MATCH (n:Person) WHERE n.born=1962 return n;

// in 查询
MATCH (p:Person) WHERE p.name in["周星驰","朱茵"] return p;

// 查询 born 不为空的
MATCH (p:Person) WHERE p.born is NOT NULL return p;

// 查询 born 为空的
MATCH (p:Person) WHERE p.born is NULL return p;

// OR 关系运算符，还有AND 
MATCH (n:Person) WHERE n.name="周星驰" OR n.born=1962 return n;

//这种类似 MATCH (n:Person) WHERE n.name="周星驰" AND n.born=1962 return n;
MATCH (n:Person{name:"周星驰"}) WHERE n.born=1962 return n;

⑤、DELETE

DELETE可以删除节点及其关联节点和关系。


// 删除与某个节点的关系
match (n:Person{name:"蔡少芬"})-[r]-(m:Movie{title:"大话西游之大圣娶亲"})  delete r;

// 删除与某个节点的关系
match (n:Person{name:"蔡少芬"})-[r]-(m:Movie) 
where m.title='大话西游之月光宝盒'  delete r;

// 删除 name=莫文蔚 点与所有节点的所有关系链
match (n:Person{name:"莫文蔚"})-[r]-(m:Movie) delete r;

// 删除 name=莫文蔚 的所有关系链,和其本身节点
match (n:Person{name:"莫文蔚"})-[r]-(m:Movie) delete r,n;

//  删除 name=莫文蔚 的所有关系链与本身节点和相关联的节点
// （保证两节点都没有和其他节点有关系才可删除）
match (n:Person{name:"莫文蔚"})-[r]-(m:Movie) delete r,n,m;

// 删除，清库
MATCH (n) DETACH DELETE n;

⑥、REMOVE

和DELETE的主要区别

// 删除 节点name=莫文蔚的born属性
MATCH (n:Person{name:"莫文蔚"}) REMOVE n.born return n

// 和上面一样意思，第二种写法
MATCH (n:Person) where n.name="莫文蔚" REMOVE n.born return n

// 删除 关系类型的 roles 属性
match (n:Person{name:"吴孟达"})-[r]-(m:Movie{title:"大话西游之大圣娶亲"}) 
REMOVE r.roles
return r,n;

⑦、ORDER BY

和数据库SQL一样，也是排序的意思

例子如下：

// 查询 Person所有节点，按born升序返回
MATCH (p:Person) return p.born,p.name order by p.born asc

// 查询 Person所有节点，按born降序返回
MATCH (p:Person) return p.born,p.name order by p.born desc

⑧、SET

可以向现有节点或关系添加新属性。

添加或更新属性值

例子如下：

// 上面删除了吴孟达的关系属性roles,现在重新给他加上
match (n:Person{name:"吴孟达"})-[r]-(m:Movie{title:"大话西游之大圣娶亲"}) 
SET r.roles=["猪八戒","二师兄"




    
]
// return 这个可加可不加，加的话会查询返回节点，不加就只显示是否更新成功的提示
return n,m;

// 给朱茵这个节点加上一个age属性
match (n:Person{name:"朱茵"})
SET n.age=18
return n;

// 给朱茵这个节点加上多个属性
match (n:Person{name:"朱茵"})
SET n.nickName="紫霞仙子",n.race='仙'
return n;

⑨、UNION


                    UNION

的意思是合并，可以将不同的结果合并成一组结果


                    UNION ALL

也是合并，和


                    UNION

不同的是:


                    UNION

会去重，


                    UNION ALL

不会

// 合并 Person类型和Movie类型，不同字段名，所以需要用as 使用别名
MATCH (p:Person) 
return p.name as name,p.born as year
UNION ALL
Match (m:Movie) 
return m.title as name,m.released as year

⑩、MERGE

MERGE 命令检查该节点在数据库中是否可用。避免重复

如果它不存在，它创建新节点。否则，它不创建新的。

// 这个是创建节点不成功的，因为Person已经有name=周星驰的节点了
MERGE (zxx:Person {name:'周星驰'})

// 这个命令会创建一个新的节点，因为name=周星驰有了，
// 但是 born=2022这个值不相等，所以会创建新的节点
MERGE (zxx:Person {name:'周星驰',born:2022})

2、其他复合查询

上面已经基本介绍了简单语法，现在来试试把他们组合成复杂语法

// 创建意中人关系的A、B节点
MATCH (a:Person { name: '朱茵' })
MATCH (b:Person { name: '周星驰' })
create (a)-[r:Feel {role:"意中人",remark:"紫霞仙子等了至尊宝500年"}]->(b)
return a,b;

// 除了上面的CREATE语法，也可以使用MERGE，加一个牛魔王 如下
MATCH (a:Person { name: '朱茵' })
MATCH (b:Person { name: '周星驰' })
MERGE (c:Person{name:"牛魔王"})-[:Feel{role:"意中人",remark:"第三者，横刀夺爱"}]->(a)-[:Feel{role:"意中人",remark:"紫霞仙子等了至尊宝500年"}]->(b)
RETURN a,b,c;

// 查询Person节点存在nickName 属性的节点
MATCH (p:Person)
WHERE exists(p.nickName)
RETURN p;


// 查询Person节点不存在nickName 属性的节点
MATCH (p:Person)
WHERE not exists(p.nickName)
RETURN p;

// 查询标题以 大 开头的电影节点
MATCH (p:Movie)
WHERE p.title STARTS WITH '大'
RETURN p.title;

// 查询名称以 英 结尾的人物节点
MATCH (p:Person)
WHERE p.name ENDS WITH  '英'
RETURN p;

// 查询 标题包含 大 的电影节点
MATCH (p:Movie)
WHERE p.title CONTAINS '大'
RETURN p.title;

// ~ 开头的后面可以使用正则表达式
MATCH (p:Person)
WHERE p.name =~ '周.*'
RETURN p.name;

// OPTIONAL 有点像左连接
MATCH (p:Person)
WHERE p.born>1950
OPTIONAL MATCH (p)-[r]-(other:Movie{title:"大话西游之大圣娶亲"})
RETURN p.name, other.title;

// 查询多组关系，谁 出演电影 又导演电影
MATCH (j:Person)-[r:ACTED_IN]->(m:Movie ),
      (j)-[:DIRECTED]-(m),
      (p)-[r1:Feel]-(j)
RETURN j.name,m.title,p.name;

// DISTINCT 过滤掉重复的数据
MATCH (j:Person)-[r:ACTED_IN]->(m:Movie ),
      (j)-[:DIRECTED]-(m),
      (p)-[r1:Feel]-(j)
RETURN DISTINCT j.name,p.name;

// unwind 可以展开然后 通过 as 起一个别名
WITH [1965




    
, 1962] AS list
UNWIND list AS number
MATCH (p:Person{born:number})
RETURN p.name, p.born ORDER BY p.born DESC;

// MERGE ON CREATE 当不存在时执行，否则执行MERGE ON MATCH 分支
MERGE (p:Person {name: '周星驰测试'})-[r:ACTED_IN]-(m:Movie)
  ON CREATE SET r.since = date('2018-03-01')
  ON MATCH SET r.updated = date()
RETURN p, r, m;

// exists 可以使用{}包起来
match (p:Person)-[r:ACTED_IN]->(m:Movie)
WHERE exists{
    match (n:Person)-[r1:Feel]->(p) 
}
return p,m;

// 查询朱茵到Movie都经过哪些节点，发现结果和想要的不太对
match p=(n1:Person)-[* 0..5]-(n2:Movie) 
where n1.name='朱茵' 
return p;

// 查看节点到节点的经过过程是怎样的，因为查的5层，会经过重复节点，所有可以过滤掉重复节点
match p=(n:Person)-[r* 0..5]-(m:Movie) 
where n.name='朱茵' and ALL( n1 in nodes(p) where size([n2 in nodes(p) where id(n1) = id(n2)])=1 )
return [n in nodes(p) | coalesce(n.name,n.title)];


// 查询两点之间的最短路径
match p=shortestPath((n1:Person)-[* 0..3]-(n2:Movie)) 
where n1.name='朱茵' 
return p;

// 查询所有最短路径（可能会漏）
match p=allshortestpaths((n1:Person)-[* 0..3]-(n2:Movie)) 
where n1.name='朱茵' 
return p;

// with 可以把之前的查询结果带到下面的查询语句中进行使用
match (n1:Person)-[r * 0..3]-(n2:Movie) 
where n1.name='朱茵'
with n1,n2
match p2=(n3)-[r:DIRECTED]->(n2)
return n1,n2,p2


// Call语法简单示例
call{
    match (p:Person)-[r:ACTED_IN]->(m:Movie)
    WHERE exists{
        match (n:Person)-[r1:Feel]->(p) 
    }
    return p
}
with p,[(a)-[:Feel]->(p) | a.name] as tName
return p.name,p.born,tName

3、Cypher函数

常用函数有：

字符串函数

toUpper

toLower

coalesce

substring

replace

// 朱茵的 eName 大写返回
MATCH (e:Person{name:"朱茵"}) RETURN e.name,e.eName,toUpper(e.eName) 

// 朱茵的 eName 小写返回
MATCH (e:Person{name:"朱茵"}) RETURN e.name,e.eName,toLower(e.eName)

// 朱茵的 eName 不存在就给一个 默认值
MATCH (e:Person{name:"朱茵"}) RETURN e.name,coalesce(e.eName,"默认值") as eName

// 字符串截取
MATCH (e:Person{name:"朱茵"}) RETURN e.name,substring(e.nickName,0,1) as eName

// 字符串替换
MATCH (e:Person{name:"朱茵"}) RETURN e.name,replace(e.nickName,"紫霞","紫霞和紫青") as eName

// 查询Person节点包含born属性的节点个数
MATCH (p:Person) RETURN count(p.born);

// 查询Person所有节点个数
MATCH (p:Person) RETURN count(*);
                              
// 求最大值                              
MATCH (p:Person) RETURN max(p.born);

// 求最小值
MATCH (p:Person) RETURN min(p.born);

// 求和
MATCH (p:Person) RETURN sum(p.born);

// 求平均数
MATCH (p:Person) RETURN avg(p.born);
// 数据聚类
MATCH (p:Person) RETURN count(p.born),max(p.born),min(p.born),sum(p.born),avg(p.born);

// 返回 r 关系的开始节点
MATCH (a)-[r:ACTED_IN]->(b) RETURN STARTNODE(r);

// 返回 r 关系的结束节点
MATCH (a)-[r:ACTED_IN




    
]->(b) RETURN ENDNODE(r);

// 返回 关系的ID 和关系的 类型
MATCH (a)-[r]->(b) RETURN ID(r),TYPE(r),size(r.roles)

// 返回 导演与 收集导演导过的电影剧名titleList
match (a:Person)-[r:DIRECTED]->(m:Movie) RETURN a.name,collect(m.title) as titleList,size(collect(m.title))

4、Cypher索引

索引是为了加快查询速度

索引配置地址： https://neo4j.com/docs/operations-manual/4.4/performance/index-configuration/

// 创建一个以 Person类型的name属性为索引
CREATE INDEX pName_index FOR (a:Person) ON (a.name)

// 创建全文索引
CREATE FULLTEXT INDEX titleIndex FOR (n:Movie) ON EACH [n.title]

// 这种查询就会用到上面建立的索引
MATCH (p:Person {name: '周星驰'})
RETURN p.name

// 多个字段属性，建立的索引，也可以叫 复合索引
CREATE INDEX pb_index FOR (a:Person) ON (a.name,a.born)

//显示数据库中都创建了哪些索引
SHOW INDEXES

// 只显示指定字段（id,name, labelsOrTypes, properties, type）的索引列表
SHOW INDEXES YIELD id,name, labelsOrTypes, properties, type

//唯一性约束，创建唯一约束也会隐式创建索引。一个字段已经创建索引后，就不能继续创建索引
CREATE CONSTRAINT uniTile FOR (m:Movie) REQUIRE m.title IS UNIQUE

// 查询唯一性约束
SHOW CONSTRAINTS

// 删除索引
DROP INDEX titleIndex

四、启用APOC

APOC是Java编写的一个Neo4j的插件库。

它提供了数据集成，数据导出，数据结构，高级图查询等诸多功能

文档地址： https://neo4j.com/labs/apoc/4.4/
Github地址： https://github.com/neo4j-contrib/neo4j-apoc-procedures

1、社区版安装APOC

如果是下载的是社区版的话，在Neo4j的安装目录下有一个labs目录

直接把labs下的


                                    apoc-4.4.0.8-core.jar

（不同版本，这里的名称也不同）复制到plugins目录下即可

默认情况下，只启用不使用低级API的一些函数。要启用所有APOC程序，还需要配置

在


                                    conf/neo4j.conf

配置文件中添加：


                                    dbms.security.procedures.unrestricted=apoc.*

重新启动Neo4j，然后执行命令：


                                    RETURN apoc.version()

就会返回apoc的版本（说明成功)

或者执行：


                                    call apoc.help("apoc");

返回apoc的函数相关信息

2、桌面版安装APOC

打开桌面版，然后点击项目=> 选择一个数据库=>右边选择Plugins=>找到Apoc安装即可

3、函数使用示例

// apoc 的命令帮助文档
call apoc.help('apoc')

// 比如查看格式化的文档
call apoc.help('format')

// 时间格式化
RETURN apoc.date.format(timestamp()) as time,
       apoc.date.format(timestamp(),'ms','yyyy-MM-dd') as date,
       apoc.date.parse('13.01.1975','s','dd.MM.yyyy') as unixtime,
       apoc.date.parse('2017-01-05 13:03:07') as millis
       
// 加载MYSQL数据库连接并查询
WITH "jdbc:mysql://localhost:3306/northwind?user=root" as url
CALL apoc.load.jdbc(url,"products") YIELD row
RETURN row
ORDER BY row.UnitPrice DESC
LIMIT 20

// 数组属性过滤查询
UNWIND ['紫霞仙子'] AS names
match (n:Person)-[r]-(m:Movie) 
where apoc.coll.contains(r.roles,names)
return n,m

4、APOC文件的导入导出

文件的导出导入需要添加配置文件：


                                      apoc.conf

新建一个


                                      apoc.conf

配置文件放在Neo4j安装目录的conf目录下

编辑如下内容，一个是开启导入功能，一个开启导出功能

1 2	apoc.import.file.enabled=true apoc.export.file.enabled=true

重启Neo4j服务就可以使用相应的导入导出函数

Neo4j默认的导入导出目录是在


                                      import

目录。

可以在


                                      neo4j.conf

内容中看到：


                                      dbms.directories.import=import

（可修改）

命令示例：

①、导入：

导入的语法格式： apoc.import.csv(<nodes>, <relationships>, <config>)

是一个对象数组，代表节点，里面有两个属性： fileName、labels

// persons.csv 是存节点的，knows.csv 是建立关系
CALL apoc.import.csv(
  [{fileName: 'file:/persons.csv', labels: ['Person']}],
  [{fileName: 'file:/knows.csv', type: 'KNOWS'}],
  { arrayDelimiter: ',', stringIds: false}
)

persons.csv

1
2
3

:ID|name:STRING|speaks:STRING[]
1|John|en,fr
2|Jane|en,de

knows.csv

1 2	:START_ID\|:END_ID\|since:INT 1\|2\|2016

②、导出：

1 2	//导出数据为movie1.csv文件，点击右边的下载按钮，文件会下载到安装目录的import目录下 CALL apoc.export.csv.all("movies1.csv", {})

五、大数据量导入Neo4j

小数据量，我们可以用Cypher语法导入

千万上亿级别的，推荐使用 neo4j-admin import

neo4j-admin 只能用于导入到未使用的数据库中，也就是需要清库

需要把数据转成 csv文件

来看栗子：演员 -出演->电影

我们现在需要准备3个csv文件：演员节点文件、电影节点文件、演员与电影的关系文件

演员节点文件： actors.csv ,内容大致如下：

personId:ID,username,:LABEL
tt01111,"周星驰",Actor
tt02222,"朱茵",Actor
tt03333,"吴孟达",Actor;Person
1
2
3
4
5
6
7
8
9
10
11
12
13

  - `personId:ID` 中的`:ID`代表是节点的id,之后的关系连接也是用这个字段

  - `username`是这个节点的属性字段：名字，如果需要多个属性，可以往后添加列

  - `:LABEL` 代表生成的节点Label叫什么，如果有多个Lable用`;`隔开

- 电影节点文件：`movies.csv`,内容如下：

  - ```
    movieId:ID,title,year:int,:LABEL
    tt01,"大话西游之月光宝盒",1994,Movie
    tt02,"大话西游之大圣娶亲",1994,Movie

movieId代表节点ID，
title和year:int代码节点的属性，year:int 代表year这个属性是int类型的。
:LABEL 和演员节点一样意思，代表生成的节点Label叫什么，后期不再介绍
演员与电影关系文件：rel.csv
:START_ID,role,:END_ID,:TYPE
tt01111,"至尊宝",tt01,ACTED_IN
tt02222,"紫霞仙子",tt01,ACTED_IN
tt03333,"二当家",tt01,ACTED_IN
tt01111,"孙悟空",tt02,ACTED_IN
1
2
3
4
5
6
7
8
9
10
11
12

    - `:START_ID` 代表建立关系的开始节点ID

    - `role`就是关系的属性，多个就在后面多加几列即可

    - `:END_ID` 代表建立关系的结束节点ID

    - `:TYPE` 代表关系的Label名称
- 当文件准备好，我们就可以使用命令导入了,把上面的3个文件放到neo4j安装目录下的`import`目录下
- 在neo4j安装目录下的bin目录下有：`neo4j-admin` 可执行程序执行它，命令如下：
- ```bash
  neo4j-admin import --database=neo4j --nodes=import/actors.csv --nodes=import/movies.csv --relationships=import/rel.csv --force=true --skip-duplicate-nodes=true

--skip-bad-relationships 代表允许跳过引用关系缺失节点ID(找不到节点)
--multiline-fields 表示输入源中的字段是否可以跨越多行，即包含换行符
--delimiter 表示csv数据中值之间的分隔符
还有很多选项就不一一列举了，可看官方文档：https://neo4j.com/docs/operations-manual/4.4/tools/neo4j-admin/neo4j-admin-import/
导入成功如下：
          1. 一、Neo4j的概述1.1. 1、Neo4J的特点
1.2. 2、Neo4j图数据库主要有以下构建块
2. 二、Neo4j的安装与使用
3. 三、Cypher 简介3.1. 1、Cypher 语法3.1.1. ①、CREATE
3.1.2. ②、MATCH
3.1.3. ③、RETURN
3.1.4. ④、WHERE
3.1.5. ⑤、DELETE
3.1.6. ⑥、REMOVE
3.1.7. ⑦、ORDER BY
3.1.8. ⑧、SET
3.1.9. ⑨、UNION
3.1.10. ⑩、MERGE
3.2. 2、其他复合查询
3.3. 3、Cypher函数
3.4. 4、Cypher索引
4. 四、启用APOC4.1. 1、社区版安装APOC
4.2. 2、桌面版安装APOC
4.3. 3、函数使用示例
4.4. 4、APOC文件的导入导出
5. 五、大数据量导入Neo4j