知识图谱之Cypher语言的使用

一、什么是Cypher
Cypher 是一种声明式图查询语言，它允许对图进行表达性和高效的查询、更新和管理。它旨在适用于开发人员和运营专业人员。
Cypher 设计简单但功能强大；可以轻松表达高度复杂的数据库查询，使您能够专注于您的领域，而不是迷失在数据库访问中。
Cypher 借鉴了 SQL 的结构——查询是使用各种子句构建的。和SQL一样不区分大小写。
二、Cypher 的使用

1、CREATE子句

用于创建节点和关系。
1.1、创建节点

-- 创建单个节点
CREATE (n)
-- 创建多个节点
CREATE (n), (m)
-- 创建一个带标签和属性的节点
CREATE (n:Person {name:'Jack'}) RETURN n 
1
2
3
4
5
6

1.2、创建关系
创建两个节点之间的关系，需获取两个节点，再进行创建

MATCH (a:Person {name:'Jack'}),  (b:Person {name:'Mike'}) 
MERGE (a)-[:FRIENDS]->(b)
-- 或者
CREATE (a:Person {name:'Jack'})-[r:FRIENDS]->(b:Person {name:'Mike'})
-- 创建带属性的关系
CREATE (a:Person {name:'Jack'})-[r:FRIENDS{name:a.name-b.name}]->(b:Person {name:'Mike'})
1
2
3
4
5
6

2、MERGE子句

MERGE子句匹配现有节点并绑定它们。 如果未找到匹配的数据，则MERGE的行为类似于CREATE，并且将在新创建的节点和关系中设置属性。简而言之，就是对存在的节点进行返回，对不存在的节点进行创建。

MERGE (a:Person { name:'Sheen', age:10 }) RETURN a
-- merge on create  若创建节点, 就合并节点并设置属性
MERGE (a:Person {name: 'Sheen'}) ON CREATE SET a.created = timestamp() RETURN a.name,a.created
-- merge on match   合并节点并在找到的节点上设置属性
MERGE (a:Person) ON MATCH SET a.found = true RETURN a.name, a.found
-- 创建节点并设置时间戳，若节点已存在，则设置不同的属性
MERGE (a:Person {name: 'Keanu'})
ON CREATE
  SET a.created = timestamp()
ON MATCH
  SET a.lastSeen = timestamp()
RETURN a.name, a.created, a.lastSeen
-- 设置多个属性，只需用逗号分隔它们
MERGE (a:Person)
ON MATCH
  SET
    a.found = true,
    a.lastAccessed = timestamp()
RETURN a.name, a.found, a.lastAccessed
-- MERGE可用于匹配或创建关系
MATCH
  (a:Person {name: 'Make'}),
  (b:Movie {title: 'Jack'})
MERGE (a)-[r:ACTED_IN]->(b)
RETURN a.name, type(r), b.title
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

– 创建唯一约束
CREATE CONSTRAINT ON (n:Person) ASSERT n.name IS UNIQUE;

3、SET子句

用于更新节点上的标签以及节点和关系上的属性

-- 新增/更新属性
MATCH (n {name: 'Any'}) SET n.surname = 'Taylor' RETURN n.name, n.surname
-- 删除属性
MATCH (n { name: 'Any' })  SET n.surname = NULL RETURN n
-- 复制属性
MATCH
  (at {name: 'Andy'}),
  (pn {name: 'Peter'})
SET at = pn
RETURN at.name, at.age, at.hungry, pn.name, pn.age
-- 属性替换运算符'=' 可用于SET将节点或关系上的所有现有属性替换为提供的属性
MATCH (p {name: 'Peter'})
SET p = {name: 'Peter Smith', position: 'Entrepreneur'}
RETURN p.name, p.age, p.position
-- 属性变异算子'+=' 可用于以SET细粒度方式从映射中变异属性
MATCH (p {name: 'Peter'})
SET p += {age: 38, hungry: true, position: 'Entrepreneur'}
RETURN p.name, p.age, p.hungry, p.position
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4、DELETE子句

用于删除节点、关系或路径

-- 删除单一节点
MATCH (n:Person {name: 'Jack'}) DELETE n
MATCH (r) WHERE id(r) in [32,33] DETACH DELETE r RETURN r
-- 删除所有节点和关系
MATCH (n) DETACH DELETE n
-- 删除一个节点及其所有关系
MATCH (n {name: 'Any'}) DETACH DELETE n
-- 删除关系
MATCH (n {name: 'Any'})-[r:KNOWS]->() DELETE r
1
2
3
4
5
6
7
8
9

5、REMOVE子句

用于从节点和关系中删除属性，以及从节点中删除标签

-- 删除属性,删除后属性为null
MATCH (a {name: 'Any'}) REMOVE a.age RETURN a.name, a.age
-- 删除节点的标签
MATCH (n { name: 'Peter' }) REMOVE n:German RETURN n
-- 删除多重标签
MATCH (n { name: 'Peter' }) REMOVE n:German:Swedish RETURN n
1
2
3
4
5
6

6、FOREACH子句

用于更新集合中的数据，无论是路径的组件还是聚合的结果

-- 将start到end路径上的所有节点的marked属性设置为true
MATCH p=(start)-[*]->(end)
WHERE start.name = 'A' AND end.name = 'D'
FOREACH (n IN nodes(p) | SET n.marked = true)
1
2
3
4

7、MATCH子句

用于搜索其中描述的模式

-- 查询所有节点
MATCH (n) RETURN n
-- 获取所有指定标签的节点
MATCH (n:Person ) RETURN n
-- 关联节点，‘--’不考虑关系的方向,‘-->’传出关系，‘<--’传入关系，
MATCH (a:Person {name:'Jack'})--(b:work) RETURN a,b
-- 关系查询
MATCH (a:Person {name: 'Make'})-[r]->(b:Person{name: 'Jack'}) RETURN type(r)

MATCH (p:Person) WHERE p.name IN ['Make', 'Jack'] RETURN p
-- 多重关系
MATCH (charlie {name: 'Charlie Sheen'})-[:ACTED_IN]->(movie)<-[:DIRECTED]-(director) 
RETURN movie.title, director.name
-- 对变长路径的查询
MATCH (charlie {name: 'Charlie Sheen'})-[:ACTED_IN*1..3]-(movie:Movie) RETURN movie.title
-- 具有多种关系类型的可变长度关系
MATCH (a:charlie {name: 'Charlie Sheen'})-[r:ACTED_IN|DIRECTED*2]-(b:person:Person)
RETURN a,r,b
-- 单一最短路径
MATCH
  (martin:Person {name: 'Martin Sheen'}),
  (oliver:Person {name: 'Oliver Stone'}),
  p = shortestPath((martin)-[*..15]-(oliver))
RETURN p

MATCH
  (charlie:Person {name: 'Charlie Sheen'}),
  (martin:Person {name: 'Martin Sheen'}),
  p = shortestPath((charlie)-[*]-(martin))
WHERE none(r IN relationships(p) WHERE type(r) = 'FATHER')
RETURN p
-- 所有最短路径
MATCH
  (martin:Person {name: 'Martin Sheen'} ),
  (michael:Person {name: 'Michael Douglas'}),
  p = allShortestPaths((martin)-[*]-(michael))
RETURN p
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

8、ORDER BY子句

输出进行排序以及如何排序

-- DESC降序、asc升序
MATCH (n) RETURN n.name, n.age ORDER BY n.name DESC
-- 按多个属性排序节点
MATCH (n) RETURN n.name, n.age ORDER BY n.age, n.name
-- 按内部id排序
MATCH (n) RETURN n.name, n.age ORDER BY id(n)
-- WITH子句中的排序
MATCH (n) WITH n ORDER BY n.age RETURN collect(n.name) AS names
1
2
3
4
5
6
7
8

9、LIMIT子句

限制返回的行数

MATCH (n) RETURN n.name ORDER BY n.name LIMIT 3
-- 限制 1 行加上随机 0、1 或 2
MATCH (n) RETURN n.name ORDER BY n.name LIMIT 1 + toInteger(3 * rand())
1
2
3

10、SKIP子句

定义从哪一行开始，包括输出中的行

-- 跳过前三行，从第四行开始返回数据
MATCH (n) RETURN n.name ORDER BY n.name SKIP 3
-- 返回中间两行
MATCH (n) RETURN n.name ORDER BY n.name SKIP 1 LIMIT 2
-- 跳过第一行加上随机 0、1 或 2
MATCH (n) RETURN n.name ORDER BY n.name SKIP 1 + toInteger(3*rand())	
1
2
3
4
5
6