neo4j 函数使用

原文链接: neo4j 函数使用

上一篇: neo4j py2neo 的简单使用

下一篇: python3 爬取电影信息

range用于产生一个序列

unwind 将列表序列转为列的数据形式

对列表形式的序列无法使用类似求和和最小值等函数,需要转化之后才可以

简单变量的使用

with range(0,5) as a, 3 as minval
return filter(i in a where i>minval)

with 'n2' as
name
match (n)
where n.name=name
return n

case的使用,类似switch语句,注意使用end结尾

match (x)
return
case x.id%2
when 0
then '偶数'
else '奇数'
end
as ans

使用比较的方式

match (x)
return
case
when x.id<3
then '小'
when x.id>8
then '大'
else '中'
end
as ans

运算符

For example:

a < b = c <= d <> e

Is equivalent to:

a < b AND b = c AND c <= d AND d <> e

类似Python的列表生成

map的使用

map的查询

MATCH (actor:Person { name: 'Charlie Sheen' })-[:ACTED_IN]->(movie:Movie)
RETURN actor { .name, .realName, movies: collect(movie { .title, .year })}

match ,根据属性值查找节点

match (n:Node{id:1})
return n

与0 相连的点

找节点距离大于某个值的点和边

使用collect 将查询结果转为列表

转化为不重复的列表

使用字典形式获取属性

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

where 子句查询

MATCH (tobias { name: 'Tobias' }),(others)
WHERE others.name IN ['Andres', 'Peter'] AND (tobias)<--(others)
RETURN others.name, others.age

not

MATCH (persons),(peter { name: 'Peter' })
WHERE NOT (persons)-->(peter)
RETURN persons.name, persons.age

寻找无连接的点

寻找存在指定的边

MATCH (n)
WHERE (n)-[:KNOWS]-({ name: 'Tobias' })
RETURN n.name, n.age

过滤属性和标签

MATCH (n)-[r]->()
WHERE n.name='Andres' AND type(r)=~ 'K.*'
RETURN type(r), r.since

与list的 操作

MATCH (a)
WHERE a.name IN ['Peter', 'Tobias']
RETURN a.name, a.age

缺失属性和值

MATCH (n)
WHERE n.belt = 'white' OR n.belt IS NULL RETURN n.name, n.age, n.belt
ORDER BY n.name

查找最短路,边数最少的,而不是加权最小的

只查找一条

match (d{id:0}),(e{id:9})
MATCH p = shortestPath( (d)-[*..15]->(e) )
return [i in nodes(p)| i.id]

查找所有,无方向

match (d{id:0}),(e{id:9})
MATCH p = allShortestPaths( (d)-[*..15]-(e) )
return [i in nodes(p)| i.id]

排序

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

随机数

return rand()

寻找路径

使用foreach设置路径上的属性

MATCH p =(begin)-[*]->(END )
WHERE begin.name = 'A' AND END .name = 'D'
FOREACH (n IN nodes(p)| SET n.marked = TRUE )

all

All（标识符 in iterable where 判断）

参数：

Ø  iterable ：一个集合属性，或者可迭代的元素，或一个迭代函数。

Ø  标识符：可用于判断比较的标识符。

Ø  判断：一个测试所有迭代器中元素的判断。

查询：

START a=node(3), b=node(1)

MATCH p=a-[*1..3]->b

WHERE all(x in nodes(p) WHERE x.age > 30)

RETURN p

过滤包含age〈30的节点的路径，返回符合条件路径中所有节点。

Any

语法：ANY(identifierin iterable WHERE predicate)

参数：

Ø  Iterable（迭代器）：一个集合属性，或者可迭代的元素，或一个迭代函数。

Ø  Identifier（标识符）：可用于判断比较的标识符。

Ø  Predicate（判断）：一个测试所有迭代器中元素的判断。

查询：

START a=node(2)

WHERE any(x in a.array WHERE x = "one")

RETURN a

None

在迭代器中没有元素判断将返回true。

语法：NONE(identifierin iterable WHERE predicate)

Ø  Iterable（迭代器）：一个集合属性，或者可迭代的元素，或一个迭代函数。

Ø  Identifier（标识符）：可用于判断比较的标识符。

Ø  Predicate（判断）：一个测试所有迭代器中元素的判断。

查询：

START n=node(3)

MATCH p=n-[*1..3]->b

WHERE NONE(x in nodes(p) WHERE x.age = 25)

RETURN p

Single

如果迭代器中仅有一个元素则返回true。

语法：SINGLE(identifierin iterable WHERE predicate)

参数：

Ø  Iterable（迭代器）：一个集合属性，或者可迭代的元素，或一个迭代函数。

Ø Identifier（标识符）：可用于判断比较的标识符。

Ø Predicate（判断）：一个测试所有迭代器中元素的判断。

查询：

START n=node(3)

MATCH p=n-->b

WHERE SINGLE(var in nodes(p) WHERE var.eyes = "blue")

RETURN p

集合操作与python类似