Cypher语句从入门到上天

cypher语句大全

下载和安装

neo4j 教程_w3cschool

Neo4j windows 桌面版 下载地址：Neo4j Desktop Download | Free Graph Database Download

Cypher语言的关键字不区分大小写，但是属性值，标签，关系类型和变量是区分大小写的。

Neo4j中不存在表的概念，只有**标签(labels),节点(Node),关联(Relation),路径(path)**，标签里存的节点,节点和关联可以简单理解为图里面的点和边,路径是用节点和关联表示的如：(a)-[r]->(b)，表示一条从节点a经关联r到节点b的路径。

在数据查询中，节点一般用**小括号()，关联用中括号[]**。

关于Neo4j和Cypher批量更新和批量插入优化的5个建议

https://blog.csdn.net/hwz2311245/article/details/60963383

Neo4j之Cypher学习总结

https://www.jianshu.com/p/2bb98c81d8ee

常用cypher语句

快速清空数据库

match (n) detach delete n

创造一个节点

create (n:Person {name:"我", age:21})

创建关系

create (p:Person {name:"我", age:"23"})-[:包工程{金额:10000}]->(n:Person {name:"好大哥", age:"35"})

删除节点 注意 删除有连接的节点时 必须先删掉关系

create (n:Person {name:"XL", age:23})
match (n:Person {name:"XL"}) delete n

删除关系

match (p:Person {name:"我", age:"23"})-[f:包工程{金额:10000}]->(n:Person {name:"好大哥", age:"35"}) delete f

加上标签

同个某个节点的id 找到它 然后给其设置一个好人的标签

match (t:Person) where id(t)=2 set t:好人 return t

额外增加属性

在好人标签中找一个节点的id为2 然后给其加一个战斗力属性 并设置其值为200

match (a:好人) where id(a)=2 set a.战斗力=200 return a

查找

create (:Person {name:"唐僧", age:"79"})-[:师傅 {s_time:"2020-11-23"}]->(:Person {name:"孙悟空", age:"1w"})
match (a:Person)-[:师傅]->(b:Person) return a,b

显示所有节点关系

match (n) return n

删除节点关系

MATCH (a:Person) OPTIONAL MATCH (a)-[r1]-() DELETE a, r1

查找人员

MATCH (tom {name: "Tom Hanks"}) RETURN tom

1.创建节点

创建Person 标签,刘德华等若干节点,各自有name,birthday ,born,englishname等属性

create (n:Person { name: '朱丽倩', birthday:'1966年4月6日',born: 1966 ,englishname:'Carol'});
create (n:Person { name: '刘向蕙', birthday:'2012年5月9日',born: 2012 ,englishname:'Hanna'});
create (n:Person { name: '任贤齐', birthday:'1966年6月23日',born: 1966 ,englishname:'Richie Jen'});
create (n:Person { name: '金城武', birthday:'1973年10月11日',born: 1973,englishname:'Takeshi Kaneshiro'});
create (n:Person { name: '林志玲', birthday:'1974年11月29日',born: 1974,englishname:'zhilin'});
create (n:Person { name: '刘德华', birthday:'1961年9月27日',born: 1961,englishname:'Andy Lau'});

创建Movie 标签,彩云曲等若干节点,各自有title,released 等属性

create (n:Movie { title: '彩云曲',released: 1981});
create (n:Movie { title: '神雕侠侣',released: 1983});
create (n:Movie { title: '暗战',released: 2000});
create (n:Movie { title: '拆弹专家',released: 2017});

2.查询节点

2.1 查询整个图形数据库:

点击节点，查看节点的属性，如图，Neo4j自动为节点设置ID值

match(n) return n;

2.2 查询具有指定标签的节点

查询Movie标签下的节点

match(n:Movie) return n;  

2.3 where 谓词查询

查询名称为林志玲的节点

match (n:Person) where n.name='林志玲' return n

**(查询具有指定属性的节点)**结果相同

match(n{name:'林志玲'}) return n;

查询born属性小于1967的节点

match(n) where n.born<1967 return n; 

3.创建关系

关系的构成：

StartNode - [Variable:RelationshipType{Key1:Value1,Key2:Value2}] -> EndNode

在创建关系时，必须指定关系类型。

3.1 创建没有任何属性的关系

MATCH (a:Person),(b:Movie)
WHERE a.name = '刘德华' AND b.title = '暗战'
CREATE (a)-[r:DIRECTED]->(b)
RETURN r;

得到结果：

{
  "identity": 2,
  "start": 9,
  "end": 7,
  "type": "DIRECTED",
  "properties": {

  }
}

3.2 创建关系，并设置关系的属性

MATCH (a:Person),(b:Movie)
WHERE a.name = '刘德华' AND b.title = '神雕侠侣'
CREATE (a)-[r:出演 { roles:['杨过'] }]->(b)
RETURN r;

得到结果：

{
  "identity": 1,
  "start": 9,
  "end": 6,
  "type": "出演",
  "properties": {
"roles": [
      "杨过"
    ]
  }
}

3.3 创建双向关系

刘德华的女是刘向蕙,刘向蕙的父亲是刘德华

MATCH (a:Person),(c:Person)
WHERE a.name = '刘德华' AND c.name = '刘向蕙'
CREATE (a)-[r:父亲 { nickname:'甜心' }]->(c),
(c)-[d:女儿 { nickname:'爹地' }]->(a)
RETURN r;

关系建错了 删除关系 (见5.2 )

重新创建

MATCH (a:Person),(c:Person)
WHERE a.name = '刘德华' AND c.name = '刘向蕙'
CREATE (a)-[d:女儿 { nickname:'甜心' }]->(c),
(c)-[r:父亲 { nickname:'爹地' }]->(a)
RETURN r;

MATCH (a:Person),(c:Movie)
WHERE a.name = '刘德华' AND c.title = '彩云曲'
CREATE (a)-[r:出演 { partner:'张国荣' }]->(c),
(c)-[d:演员 { rolename:'阿华哥' }]->(a)
RETURN r;

MATCH (a:Person),(c:Movie)
WHERE a.name = '刘德华' AND c.title = '拆弹专家'
CREATE (a)-[r:出演 { partner:'赵薇,高圆圆' }]->(c),
(c)-[d:演员 { rolename:'华仔' }]->(a)
RETURN r;

MATCH (a:Person),(c:Movie)
WHERE a.name = '刘德华' AND c.title = '神雕侠侣'
CREATE (a)-[r:出演 { partner:'刘亦菲' }]->(c),
(c)-[d:演员 { rolename:'杨过' }]->(a)
RETURN r;

继续新增关系 刘德华和林志玲,金城武,任贤齐

MATCH (a:Person),(c:Person)
WHERE a.name = '刘德华' AND c.name = '任贤齐'
CREATE (a)-[d:朋友 { sex:'男' }]->(c)
RETURN d;

MATCH (a:Person),(c:Person)
WHERE a.name = '刘德华' AND c.name = '金城武'
CREATE (a)-[d:朋友 { sex:'男' }]->(c)
RETURN d;

下面这个没有给关系设置属性sex

MATCH (a:Person),(c:Person)
WHERE a.name = '刘德华' AND c.name = '林志玲'
CREATE (a)-[d:朋友]->(c)
RETURN d;          

match (a:Person), (b:Person) 
where a.name="刘德华" and b.name="朱丽倩"
create (a)-[c:wife]->(b)
return c;

查询Person表关系

MATCH (n:Person) RETURN n

4 查询关系

在Cypher中，关系分为三种：符号“–”，表示有关系，忽略关系的类型和方向；符号“–>”和“<–”，表示有方向的关系；

4.1 查询整个数据图形

match (n) return n;

4.2 查询跟指定节点有关系的节点

查询跟Movie标签有关系的所有节点

match (n) -- (m:Movie) return n;

4.3 查询有向关系的节点

查询和刘德华有关系的电影

MATCH (:Person { name: '刘德华' })-->(movie:Movie) RETURN movie;

4.4 为关系命名

通过[r]为关系定义一个变量名，通过函数type获取关系的类型

MATCH (:Person { name: '刘德华' })-[r]->(:Movie) RETURN r,type(r);

4.5 查询特定的关系类型

通过[Variable:RelationshipType{Key:Value}]指定关系的类型和属性

MATCH (:Person { name: '刘德华' })-[r:出演{partner:'张国荣'}]->(:Movie) RETURN r,type(r);

查询 刘德华和张国荣合作过的电影

MATCH (:Person { name: '刘德华' })-[r:出演{partner:'张国荣'}]->(m:Movie) RETURN m;

查询被刘德华称呼为甜心的女儿

MATCH (:Person { name: '刘德华' })-[r:女儿{nickname:'甜心'}]->(m:Person) return m

查询刘德华的老婆是谁

Match (n:Person{name: '刘德华'})-[:wife]->(a:Person) return a

刘德华出演过的电影

match (:Person{name:'刘德华'})-[r:`出演`]->(a:Movie) return a

5 删除

5.1 删除节点

create (n:City { name: '北京'})

Match (n:City{name:'北京'}) delete n

5.2 删除关系

Match (a:Person{name:'刘德华'})-[r:父亲]->(b:Person{name:'刘向蕙'}) delete  r

Match (a:Person{name:'刘向蕙'})-[r:女儿]->(b:Person{name:'刘德华'}) delete  r

5.4 强制删除节点和关系

Match  (n:`美国军事基地`) where n.name ='挂载'  detach delete n

6 常用查询关键词

6.1 count

查询Person 一共有多少人

Match (n:Person ) return count(n)

查询标签(Person)中born=1966的一共有多少节点（人）：

两种写法：

Match (n:Person) where  n.born=1966   return  count(n) 

Match (n:Person{born:1966})  return  count(n)  //特别注意类型,如果存的类似是数字类型,使用字符串就查不出来

6.2 Limit 限制查询条数

Match (n:Person) return n limit 3

6.3 Distinct

Match (n:Person) return  distinct(n.born)![0]

6.4 Order by

默认升序：

Match(n:Person) return n order by n.born

升序：

Match(n:Person) return n order by n.born asc 

降序：

Match(n:Person) return n order by n.born desc

6.5 根据id查找

match (n) where id(n)=9 return n

6.6 In的用法

Match (n) where ID(n) IN[353,145,547] return n

6.7 Exists

节点存在 name这个属性的记录：

Match (n) where exists(n.title) return n

6.8 With

查询name以‘刘’开头的节点：

Match (n) where n.name starts with '刘' return n

查询name以‘明’结尾的节点：

Match (n) where n.name ends with '齐' return n

6.9 Contains

查询title中含有 ‘侠侣’的节点

Match (n:Movie) where n.title Contains '侠侣' return n

6.10 Union all (Union)

求并集，不去重（去重用Union, as 取别名）:

Match(n:Person) where n.born=1966 return n.name as name
Union all
Match(n:Movie) where n.released=1983 return n.title as name

7. 更新

7.1 创建一个完整的Path

CREATE p =(m:Person{ name:'刘亦菲',title:"演员" })-[:签约]->(neo)<-[:签约]-(n:Person { name: '赵薇',title:"投资人" })
RETURN p

7.2 为节点增加一个属性

通过节点的ID获取节点，Neo4j推荐通过where子句和ID函数来实现。

match (n)
where id(n)=11
set n.name = '华谊兄弟'
return n;

为节点移除属性

MATCH (n:农业) where id(n)=17816137 remove n.sortcode,n.targettable,n.unit,n.uuid

7.3 为节点增加标签

match (n)
where id(n)=11
set n:公司
return n;

7.4 为关系增加属性

match (n)-[r]->(m)
where id(n)=10 and id(m)=11
set r.经纪人='程晨'
return n;

此时图谱效果成

接着让刘德华也和华谊兄弟签约

MATCH (a:Person),(c:公司)
WHERE a.name = '刘德华' AND c.name = '华谊兄弟'
CREATE (a)-[d:签约 { 经纪人:'刘得得' }]->(c)
RETURN d;

7.5 MERGE

Merge子句的作用有两个：当模式（Pattern）存在时，匹配该模式；当模式不存在时，创建新的模式，功能是match子句和create的组合。在merge子句之后，可以显式指定on creae和on match子句，用于修改绑定的节点或关系的属性。

通过merge子句，你可以指定图形中必须存在一个节点，该节点必须具有特定的标签，属性等，如果不存在，那么merge子句将创建相应的节点。

通过merge子句匹配搜索模式

匹配模式是：一个节点有Person标签，并且具有name属性；如果数据库不存在该模式，那么创建新的节点；如果存在该模式，那么绑定该节点；

MERGE (m:Person { name: '迈克尔·杰克逊' })
RETURN m;

在merge子句中指定on create子句

如果需要创建节点，那么执行on create子句，修改节点的属性；timestamp()时间戳

MERGE (m:Person { name: '杰森·斯坦森' })
ON CREATE SET m.registertime = timestamp()
RETURN m.name, m.registertime

在merge子句中指定on match子句

如果节点已经存在于数据库中，那么执行on match子句，修改节点的属性；节点属性不存在则新增

MERGE (m:Person)
ON MATCH SET m.registertime = timestamp()
RETURN m.name, m.registertime

在merge子句中同时指定on create 和 on match子句(没有对应属性则不修改，不会新增属性)

MERGE (m:Person{ name: '李连杰' })
ON CREATE SET m.registertime = timestamp()
ON MATCH SET m.offtime = timestamp()
RETURN m.name, m.registertime, m.offtime

merge子句用于match或create一个关系

MATCH (m:Person { name: '刘德华' }),(n:Movie { title: '神雕侠侣' })
MERGE (m)-[r:导演]->(n)
RETURN m.name, type(r), n.title

merge子句用于match或create多个关系

赵薇既是神雕侠侣的导演,也是神雕侠侣的演员

MATCH (m:Person { name: '赵薇' }),(n:Movie { title: '神雕侠侣' })
MERGE (m)-[r:导演]->(n)<-[r2:出演]-(m)
RETURN m.name, type(r),type(r2), n.title

merge子句用于子查询

先添加基础数据

创建城市节点

create (n:City { name: '北京',othername:'帝都'});
create (n:City { name: '香港',othername:'HongKong'});
create (n:City { name: '台湾',othername:'湾湾'});

为Person标签的每个节点都增加一个属性 bornin

match (n:Person)
set n.bornin = ''
return n;

match (n)
where id(n)=9
set n.bornin = '香港'
return n;

match (n)
where n.name='金城武'
set n.bornin = '台湾'
return n;

需求:查找刘德华和金城武的信息和所在地的othername(相当于mysql 连表查询)

MATCH (p:Person)
where p.name='刘德华' or p.name='金城武'
MERGE (c:City { name: p.bornin })
RETURN p.name,p.born,p.bornin, c.othername;

创建刘德华出生地是香港这条关系

MATCH (a:Person),(c:City)
WHERE a.name = '刘德华' AND c.name = '香港'
CREATE (a)-[r:出生地]->(c)
RETURN r;

需求:给Person中每个节点都创建一个出生地的关系,没有则返回null

MATCH (p:Person)
MERGE (c:City { name: p.bornin })
MERGE (p)-[r:出生地]->(c)
RETURN p.name, p.bornin, c.othername;

删除这些关系

Match (a:Person)-[r:出生地]->(c:City{name:''}) delete r

Match (a:City)-[r:出生地]->(c:Person) delete r

查询Person标签中不存在name属性的节点

Match (n:Person) where not exists(n.name) return n

Match  (n:Person)  where not  exists(n.name)  delete  n

create (n:Prize { name: '金马奖'});
create (n:Prize { name: '奥斯卡金奖'});
create (n:Prize { name: '金鸡奖'});
create (n:Prize { name: '香港电影金像奖'});

7.6 跟实体相关的函数

通过id函数，返回节点或关系的ID

查询Movie标签中和刘德华有关系的电影 id(节点和关系)

MATCH (:Person { name: '刘德华' })-[r]->(:Movie)
RETURN id(r);

通过type函数，查询关系的类型

查询Person标签中和刘德华相关的关系(以下三种结果相同)

MATCH (:Person { name: '刘德华' })-[r]->()
RETURN type(r);

通过lables函数，查询节点的标签

查询和刘德华有关系的节点

MATCH (:Person { name: '刘德华' })-[r]->(p)
RETURN p;

查询和刘德华有关系的标签(去重)

MATCH (:Person { name: '刘德华' })-[r]->(p)
RETURN distinct(labels(p))

通过keys函数，查看节点或关系的属性键

MATCH (a)
WHERE a.name = '刘德华'
RETURN keys(a)

MATCH (:Person { name: '刘德华' })-[r]->(p) RETURN distinct(keys(r))

通过properties()函数，查看节点或关系的属性

MATCH (a)
WHERE a.name = '刘德华'
RETURN properties(a)

MATCH (:Person { name: '刘德华' })-[r]->(p) RETURN properties(r)

8.跟索引相关的函数

8.1 创建索引

创建单一属性索引

CREATE INDEX ON :Lable(property)

Query:

CREATE INDEX ON :Person(name)

给数据库的:Person标签的name属性创建索引

Result:

Added 1 index, completed after 32 ms.

创建复合属性索引

CREATE INDEX ON :Label(prop1,…,propN)

Query:

CREATE INDEX ON :Person(age,country)

Result:

Added 1 index, completed after 4 ms.

8.2 查询索引

CALL db.Indexes

8.3 删除索引

DROP INDEX ON :LABEL(property）

Query:

DROP INDEX ON :Person(firstname)

DROP INDEX ON :LABEL(prop1,…,propN)

Query:

DROP INDEX ON :Person(age,country)

8.4 备份与导入

备份/导出

要以管理员身份运行

neo4j-admin dump --database=graph.db --to=E:\neo4jdata

导入

neo4j-admin load --from=E:\neo4jdata\graph.db.dump --database=graph.db --force

导入csv

USING PERIODIC COMMIT 500 LOAD CSV FROM "file:///D:\\test.csv" AS line  MERGE (:`顶顶顶` {name:line[0]})
LOAD CSV WITH HEADERS FROM "file:///C:\\Program Files\\Java\\neo4j-community-3.4.7\\import\\stock_concept.csv"
AS line
return line.n

USING PERIODIC COMMIT 10  
LOAD CSV FROM "file:///node.csv" AS line  
create (a:Node{name:line[0]})  

USING PERIODIC COMMIT
LOAD CSV FROM 'file:///concept.csv' AS row
CREATE (n:概念{name:row[1],uuid:row[0]})

csv 不带header方式

USING PERIODIC COMMIT
LOAD CSV  FROM "file:///executive_stock.csv" AS row
MATCH (n:高管 {uuid: row[0]})
MATCH (m:企业 {uuid: row[1]})
MERGE (n)-[:RE{name:row[2]}]->(m) 

带header方式

USING PERIODIC COMMIT
LOAD CSV WITH HEADERS FROM 'file:///industry.csv' AS row
CREATE (:行业{name:row.name,uuid:row.uuid})

apoc 导入

call apoc.import.csv([{fileName: 'D:\\text\\ctwh\\ctwh.csv', labels: ['ctwh']}], [], {})

apoc导出

MATCH (n:`zhctwh`)-[r:RE]->(m:`zhctwh`)
WITH collect(DISTINCT n) AS cn, collect(DISTINCT m) AS cm, collect(r) AS rships
CALL apoc.export.csv.data(cn+cm, rships, "ctwh-re.csv", {})
YIELD file, source, format, nodes, relationships, properties, time, rows, batchSize, batches, done, data
RETURN file, source, format, nodes, relationships, properties, time, rows, batchSize, batches, done, data

注意：导出文件如果如上面语句没写路径，默认在安装目录的根目录下，bin所在的同级目录

关于neo4j查询多深度关系节点

1.使用with关键字

查询三层级关系节点如下：with可以将前面查询结果作为后面查询条件

match (na:company)-[re]->(nb:company) where na.id = '11' WITH na,re,nb match (nb:company)-[re2]->(nc:company) return na,re,nb,re2,nc

2.直接拼接关系节点查询

match (na:company{id:'12399145'})-[re]->(nb:company)-[re2]->(nc:company) return na,re,nb,re2,nc

3.为了方便，可以将查询结果赋给变量，然后返回

match data=(na:company{id:'12'})-[re]->(nb:company)-[re2]->(nc:company) return data

4.使用深度运算符

当实现多深度关系节点查询时，显然使用以上方式比较繁琐。

可变数量的关系->节点可以使用**-[:TYPE*minHops..maxHops]->**。

查询：

如果在1到3的关系中存在路径，将返回开始点和结束点。

match data=(na:company{id:'12399145'})-[*1..3]->(nb:company) return data

其他

使用APOC库

https://neo4j-contrib.github.io/neo4j-apoc-procedures/

合并重复节点

先装apoc 过程如下

https://blog.csdn.net/graphway/article/details/78957415

安装完成 执行 return apoc.version() 查看下版本

MATCH (n:国家电网)
WITH n.name AS name, COLLECT(n) AS nodelist, COUNT(*) AS count
WHERE count > 1
CALL apoc.refactor.mergeNodes(nodelist) YIELD node
RETURN node

查询某个节点有关系的3级及以内的路径

MATCH (n:`贵州`) WHERE n.name='交通事件'
CALL apoc.path.spanningTree(n, {maxLevel:3}) YIELD path
RETURN path;

复制领域

match(n:菊花) MERGE (:大萨达{name:n.name})
match(n:菊花)-[r]->(q:菊花)
with n, r, q
match (o:大萨达{name:n.name}), (m:大萨达{name:q.name})
MERGE (o)-[:RE{name:r.name}]->(m)

keys函数

查询某个属性大于0 的节点

match(n) where any(x in keys(n) where n[x] > 0) return n

查询所有属性大于0的节点

match(n) where all(x.uuid in keys(n) where n[x.uuid] > 0) return n   

x在any中是一个变量，并不是属性

uuid大于0

match(n) where any(uuid in keys(n) where n[uuid] > 0) return n 

所有uuid都大于0

match(n) where all(uuid in keys(n) where n[uuid] > 0) return n

match(n) where any(querytype in keys(n) where n[querytype] = 0) return n

修改密码

进入neo4j提供的可视化界面broswer

输入： :server change-password

键入原密码及新密码，即可修改

设置权重

match (n:`测试权重`{name:'项目名称'}),(m:`测试权重`{name:'设计速度'})
MATCH p=(n)-[*]-(m)
with p,reduce(s=0,r in rels(p)|s+toInt(r.name)) as dist
return p,dist order by dist asc

match (n:`交通规划设计`{name:'项目名称'}),(m:`交通规划设计`{name:'设计速度'})
CALL apoc.algo.dijkstra(n,m,'RE','weight')yield path as path,weight as weight
return path,weight

最短路径

match (n:`测试权重`{name:'项目名称'}),(m:`测试权重`{name:'设计速度'}),
p=shortestpath((n)-[*..10]-(m))
RETURN p

所有路径

match (n:`测试权重`{name:'项目名称'}),(m:`测试权重`{name:'设计速度'}),

p=allshortestpaths((n)-[*..10]-(m))

RETURN p

多个节点两两间互相求最短路径

with ['项目名称','工可批复单位','设计速度'] as indicator_list
match (n:`交通规划设计`) where n.name in indicator_list
with collect(n) as nodes
unwind nodes as source
unwind nodes as target
with source,target where id(source)
match paths = shortestPath((source)-[*0..2]-(target)) 
with paths limit 20000
return paths

带条件的

with [3105, 200025928, 200025929, 151286502, 135660351] as id_list
match (v:vertices) where v.id in id_list
  with collect(v) as nodes
  unwind nodes as source
  unwind nodes as target
  with source,target where id(source)
match paths = shortestPath((source)-[:HOLDER|MANAGER*0..2]-(target)) where all(x in nodes(paths) where x.id<>3105)
  with paths limit 20000
  return paths

多标签查询

match (n) where any(label in labels(n) WHERE label in ['A 标签', 'B 标签']) return n

查询字段类型

apoc.meta.type
String cypher = "match(n:`zhctwh`) where  apoc.meta.type(n.similar)='STRING' return n";