Neo4j数据和Cypher查询语法笔记

Cypher数据结构

Cypher的数据结构: 属性类型, 复合类型和结构类型

属性类型

属性类型

• Integer
• Float
• String: 'Hello', "World"
• Boolean: true, false, TRUE, FALSE

结构类型

结构类型

• node: 表示一个节点, 由 id, label 和 map 构成
  • id: 长整数, 全局唯一, node 与 relation 的 id 是共用的一个序列, 都是图当中的元素id
  • label: 节点标签, 每个节点可以有多个标签
  • map: 节点的属性集合
• relation: 表示一条边, 由 id, type, map和两端的两个 node的 id 构成
  • id: 长整数, 图中元素的唯一id
  • type: 边类型, 只有一个值, 和节点的label作用等价
  • map: 边的属性集合
• path: 表示路径, 是节点和边的序列. Path模式: (a)-->()<--(b), 可以有向也可以无向

复合类型

List

注意在 cypher SQL 中, list 和标准 SQL 的区别, 不是用括号(), 而是用方括号[]. 有序的值的集合, ['a', 'b'], [1, 2, 3], ['a', 2, n.property, $param], [ ]

• 由标量类型构成的List, 例如 ['a', 'b'], [1, 2, 3]
• 由函数range函数生成的List对象, 例如 range(0, 10)表示从start到end的有序数字, Range函数包含两端
• 列表(List comprehension): [x IN range(0,10) WHERE x % 2 = 0 | x^3]

Map类型

无序Key/Value对的集合, n是节点, prop是节点的属性键, 引用属性的值的格式: n.prop

• 列表的常量表示: { key: 'Value', listKey: [{ inner: 'Map1' }, { inner: 'Map2' }]}
• Map投影, 用于从节点, 关系和其他Map对象中投影特定元素或变量的值, Map投影的格式是map_variable {map_element, [, …​n]}
  map_variable: 用于引用Map对象, map_element 有四种格式是
  • 属性选择器: 格式是 .key, 用于引用Map对象中的属性
  • 嵌入属性（Literal entry）, 是一个Key/Value对, 例如, key: <expression>表示嵌入到Map变量中的元素
  • 变量选择器: 把一个变量的名称作为Key, 变量的值作为Key的值, 构建一个Key/Value对, 作为Map变量中的元素
  • 属性全选符号: .*

Map投影的示例, actor是Map变量, nrOfMovies是变量, 从Map变量中获取name属性, 并添加额外的属性nrOfMovies:

MATCH (actor:Person)-[:ACTED_IN]->(movie:Movie)
WITH actor, count(movie) AS nrOfMovies
RETURN actor { .name, nrOfMovies }

创建

创建一个Node

create(
    dis:Disease{
        oid: "xxx1",
        code: "111",
        name: "2hh"
    }
)

create也可以和return搭配, 直接返回结果, create也可以同时创建多个关系

create (m),(s)

创建一个Relation

比如已经有了两个节点, 我们想关联上关系

match(
    a: Disease
), (
    b: Disease
)
where a.code="111" and b.code="d1"
create (a)-[r:type]->(b)
return *

给这个线设置一些属性

match(
    a: Disease{
        code: '111' 
    }
), (
    b: Disease{
        code: 'd1'
    }
)
create(a)-[r:relation{name : a.name + '--' + b.name}]->(b)
return type(r), r.name

同时创建节点和关系

假设不存在节点, 直接创建节点+关系了

create p=(reba:Person{name: 'reba'})-[:WORK_AT]->(nazha:Person{name:'nazha'})<-[:WORK_AT]-(jt:Person{name: 'jt'})
return p

删除

清空数据库

对于节点比较少的可以使用

match (n) detach delete n

对于节点比较多的:

1. 停掉服务
2. 删除 graph.db 目录
3. 重启服务

delete 删除节点

只能删除不带连接的节点

match(p:Person{name:'jt'}) delete p
-- or
match(p:Person{id:124}) delete p

删除节点连带着全部关系

用 detach 删除

match(p:Person{name: 'jt'}) detach delete p

只删除关系

match(p:Person{name: "reba"})-[r:WORK_AT]->() delete r

删除属性

remove 删除节点和关系中的属性字段

-- 节点(或关系)的属性
{
  "name": "诊断",
  "code": "d1",
  "oid": "xxx1"
}
-- 删除属性
match(d:Disease{name:"诊断"}) remove d.code
-- return 的 d.code 会变成 null
return d.name, d.oid, d.code

修改

修改/添加一个属性

match(n {name: 'Andy'})
set n.surname = 'Taylor'
return n.name, n.surname

注意: 如果本身没有surname 这个属性, 会自动增加

还有一个高级写法, 用到了case when

match(n{name: 'Andy'})
set(
    case
    when n.age = 36
    then n End
).wordIn = 'Malmo'
return n.name, n.wordIn

CASE语法

CASE
WHEN predicate THEN result
  [WHEN ...]
  [ELSE default]
END

修改/添加多个属性

使用等号赋值

match(n{name: 'Peter'})
set n.a1= '1' , n.a2 = '3'
return n

使用map赋值, 注意: 这样会清除所有原属性

MATCH (p { name: 'Peter' })
SET p = { name: 'Peter Smith', position: 'Entrepreneur' }
RETURN p.name, p.age, p.position

如果要保留原属性, 把=变成+=

match (p{name: 'Peter'})
SET p += { age: 38, hungry: TRUE , position: 'Entrepreneur' }
RETURN p.name, p.age, p.hungry, p.position

删除一个属性

将这个属性置为null, 就是删除一个属性, 如下

MATCH (n { name: 'Andy' })
SET n.name = NULL RETURN n.name, n.age

删除所有的属性

使用一个空的map和等号, 这样即可删除节点所有属性

MATCH (p { name: 'Peter' })
SET p = { }
RETURN p.name, p.age

完全复制一个节点或者关系

SET可用于将所有属性从一个节点或关系复制到另一个节点. 目标节点或关系的原属性会被清空.

MATCH (at { name: 'Andy' }),(pn { name: 'Peter' })
set at = pn
return at.name, at.age, at.hungry, pn.name, pn.age

修改标签（label）

修改一个

MATCH (n { name: 'Stefan' })
SET n:German
RETURN n.name, labels(n) AS labels

修改多个

match(n{name: 'Peter'})
set n:Swedish:Bossman
return n.name, labels(n) as labels

查询

根据标签查询节点

-- 标签为LABEL1的节点列表
match(d:LABEL1) return d
-- 标签同时为LABEL1和LABEL2的节点列表
match(d:LABEL1:LABEL2) return d

根据类型查询边

-- 类型为 RELATION1 的边列表
match(n)-[r:RELATION1]-(o) return r

带属性条件的查询

-- 标签为LABEL1, 且 oid = '123' 的节点列表
match(d:LABEL1{oid: "123"}) return d

Return 关键词

return 的作用是在match匹配上了以后, 选择哪些返回, 如果能确定返回的属性, 尽量不要全部返回

Return的语法

需要什么就返回什么, *表示返回所有的. 比如

MATCH p =(a { name: 'A' })-[r]->(b)
RETURN *

返回的结果就是满足上面p, a r, b关系的所有的可能结果

在return中通过as改名

MATCH (a { name: 'A' })
RETURN a.age AS SomethingTotallyDifferent

对于没有属性的会返回一个null, 比如

MATCH (n)
RETURN n.age

如果返回的两个结果, 一个由age这个属性, 一个没有, 那么有的正常返回, 没有的返回null.

还可以在返回中包含运算, 并且返回的是多个元素也支持

MATCH (a { name: 'A' })
RETURN a.age > 30, "I'm a literal",(a)-->()

DISTINCT

MATCH (a { name: 'A' })-->(b)
RETURN DISTINCT b

OPTIONAL MATCH

这个和match差不多, 区别在于当没有查到东西的时候, 会返回一个null

比如下面的结果有值

match(p:Person{
    name: 'reba'
})
optional match (p) -->(x)
return x

但是如果把方向换一下, 结果会变成两个null

match(p:Person{
    name: 'reba'
})
optional match (p) <--(x)
return x

如果把optional去掉, 结果是 no records

WHERE

使用WHERE指定复杂的查询条件

MATCH (n)
WHERE n.name = 'Peter' XOR (n.age < 30 AND n.name = 'Timothy') OR NOT (n.name = 'Timothy' OR n.name = 'Peter')
RETURN n.name, n.age

在WHERE中对id进行过滤, 返回标签为 LABEL1, 元素ID为 1, 2, 3 的元素

MATCH (n:LABEL1) WHERE id(n) IN [1,2,3] RETURN n

在WHERE中对label进行过滤

MATCH (n) WHERE n:Swedish RETURN n.name, n.age

不固定属性的过滤

with 'AGE' as propname
match (n)
where n[toLower(propname)] < 30
return n.name, n.age

属性存在性校验

MATCH (n)
WHERE exists(n.belt)
RETURN n.name, n.belt

以xx字符串开头

MATCH (n)
WHERE n.name STARTS WITH 'Pet'
RETURN n.name, n.age

以xx字符串结尾

MATCH (n)
WHERE n.name ENDS WITH 'ter'
RETURN n.name, n.age

字符串包含

MATCH (n)
WHERE n.name CONTAINS 'ete'
RETURN n.name, n.age

NOT 的使用

MATCH (n)
WHERE NOT n.name ENDS WITH 'y'
RETURN n.name, n.age

正则表达式的使用

MATCH (n)
WHERE n.name =~ 'Tim.*'
RETURN n.name, n.age

不区分大小写

MATCH (n)
WHERE n.name =~ '(?i)AND.*'
RETURN n.name, n.age

根据null过滤

MATCH (person)
WHERE person.name = 'Peter' AND person.belt IS NULL RETURN person.name, person.age, person.belt

ORDER BY

首先记住, 不能根据关系或者节点进行排序, 只能根据属性

MATCH (n)
RETURN n.name, n.age
ORDER BY n.age, n.name

一般order by都是放在return后面

SKIP

从头开始跳过几个数据, 一般在Order by 的后面, 如果没有order by 就放在return后面

MATCH (n)
RETURN n.name
ORDER BY n.name
SKIP toInteger(3*rand()) + 1

LIMIT

limit 一般是在最后了, 控制展示的个数

MATCH (n)
RETURN n.name
ORDER BY n.name
LIMIT toInteger(3 * rand())+ 1

MERGE

这个关键字基本上是把create和match合并到一起

基础用法

merge (robert:Critic{name: '111'})
return robert, labels(robert)

如果不存在这个节点, 会直接创建, 执行后再执行一遍, 作用只是相当于match了.

当然也可以从已经存在的节点中获取值, 比如

MATCH (person:Person)
MERGE (city:City { name: person.bornIn })
RETURN person.name, person.bornIn, city

从已经存在的节点中, 获取一些属性值, 然后进行复制. 当然, 这个操作可以是批量的

on create

这个实际上是一个限定条件, 表达的是当创建的时候, 才执行, 不创建就不执行, 比如:

merge (c:Critic{name:'1112'})
on create set c.create = timestamp()
return c.name, c.create

这个语句中, 如果数据库中已经存在了一个1112那么就不会set值, 同样, 如果不存在, 那么就会执行set后面的部分.

on match

这个命令和上述表达差不多, 不同的是它是匹配上了就进行set

MERGE (person:Person)
ON MATCH SET person.found = TRUE RETURN person.name, person.found

当然也可以同时设置多个属性值:

MERGE (person:Person)
ON MATCH SET person.found = TRUE , person.lastAccessed = timestamp()
RETURN person.name, person.found, person.lastAccessed

on create 和on match 合并

MERGE (keanu:Person { name: 'Keanu Reeves' })
ON CREATE SET keanu.created = timestamp()
ON MATCH SET keanu.lastSeen = timestamp()
RETURN keanu.name, keanu.created, keanu.lastSeen

现在数据库中是没有这个节点的, 也就是说会进行创建

Merge relationships

MERGE 同样也能被用来match或者create关系.

比如已经存在两个节点, 想给他们MERGE一下关系

MATCH (charlie:Person { name: 'Charlie Sheen' }),(wallStreet:Movie { title: 'Wall Street' })
MERGE (charlie)-[r:ACTED_IN]->(wallStreet)
RETURN charlie.name, type(r), wallStreet.title

一下子处理多个关系, 比如:

MATCH (oliver:Person { name: 'Oliver Stone' }),(reiner:Person { name: 'Rob Reiner' })
MERGE (oliver)-[:DIRECTED]->(movie:Movie)<-[:ACTED_IN]-(reiner)
RETURN movie

创建一个无向的连接:

MATCH (charlie:Person { name: 'Charlie Sheen' }),(oliver:Person { name: 'Oliver Stone' })
MERGE (charlie)-[r:KNOWS]-(oliver)
RETURN r

批量操作

有一些批量操作的写法, 能够帮助我们快速创建大量节点和关系, 比如:

MATCH (person:Person)
MERGE (city:City { name: person.bornIn })
MERGE (person)-[r:BORN_IN]->(city)
RETURN person.name, person.bornIn, city

将所有Person中出生地和实际的城市直接挂钩

上面这句话, 我们还可以改写下:

MATCH (person:Person)
MERGE (person)-[r:BORN_IN]->(city:City { name: person.bornIn })
RETURN person.name, person.bornIn, city

WITH

With关键字是连接多个查询的结果, 即将上一个查询的结果用作下一个查询的开始

对聚合函数结果进行筛选

我们用这样一段话, 来查询David连接过去的节点, 它向外连接关系大于1的那个节点

match(David{name: 'David'}) --(otherPerson)-->()
with otherPerson, count(*) as cnt
where cnt > 1
return otherPerson.name

match(Anders{name: 'Anders'}) --(otherPerson)-->()
with otherPerson, count(*) as cnt
where cnt > 1
return otherPerson.name

在使用collect之前对结果进行排序

match(n)
with n
where n.name = 'David' or n.name = 'Bossman'
return collect(n.name)

限制搜索路径分支

MATCH (n { name: 'Anders' })--(m)
WITH m
ORDER BY m.name DESC LIMIT 1
MATCH (m)--(o)
RETURN o.name

UNWIND

unwinding a list

我们先看这样一句话, 初步了解下unwind 的用法:

unwind [1, 2, 3, NULL] as x
return x, 'val' as y

creating a distinct list

with [1, 1, 2, 2] as coll
unwind coll as x
with distinct x
return collect(x) as setOfVals

Using UNWIND with any expression returning a list

其实是在合并列表

with [1, 2] as a, [3, 4] as b
unwind (a + b) as x
return x

Using UNWIND with a list of lists

with [[1, 2], [3, 4], 5] as nested
unwind nested as x
unwind x as y
return x, y

Using UNWIND with an empty list

这是一个用法, 只要unwind的是一个[], 那么不管一起返回的是什么, 都会返回一个0rows.

unwind [] as empty
return empty, 'literal_that_is_not_returned'

Using UNWIND with an expression that is not a list

unwind可以被用来检测是不是一个list

unwind null as x
return x, 'some_itearl'

如果直接unwind一个数字, 会报错:

unwind 5 as x
return x, '11'

FOREACH

批量的进行修改属性

match p=(begin)-[*]->(END)
where begin.name = 'A' And END.name = 'D'
foreach(n in nodes(p)| set n.marked = TRUE)

CALL

使用CALL可以调用一些函数, 比如来个最简单的调用一个库函数

CALL `db`.`labels`

这样子可以把所有类名全部列出来

UNION

union 就是把两个结果合并起来.

MATCH (n:Actor)
RETURN n.name AS name
UNION ALL 
MATCH (n:Movie)
RETURN n.title AS name

如果不用union all 直接用union, 会对结果排除重复

MATCH (n:Actor)
RETURN n.name AS name
UNION
MATCH (n:Movie)
RETURN n.title AS name

参考

• https://jawhiow.github.io/2019/04/25/neo4j cypher/
• https://www.cnblogs.com/ljhdo/p/10911426.html