库neo4j连接neo4j

安装库

pip install neo4j

通用例子

from neo4j import GraphDatabase
driver = GraphDatabase.driver("bolt://localhost:7687", auth=("neo4j", "neo4j"))


session = driver.session()
tx = session.begin_transaction()

#不同功能更改cql语句即可
cql = 'match (n) return n'
result = tx.run(cql)

# 查询不需要提交
tx.commit()
tx.closed()
driver.close()

创建节点语句

'''
#merge可以看成是match和create的合体，找的到时match，找不到时create
cql = "MERGE (a:%s {name:$name,age:$age})"%('person1')
'''
cql = "CREATE (a:%s {name:$name,age:$age})"%('person1')
result = tx.run(cql,name='张三',age=18)

查询节点语句

cql = "MATCH (a:%s {name:$name,age:$age}) return a"%('person1')
persons = tx.run(cql,name='张三',age=18)

#获取具体属性信息
for person in persons:
    print(person.get('a')._id)
    print(person.get('a')._labels)
    print(person.get('a')._properties)

更新节点语句

cql = "MATCH (a) WHERE a.name = $name SET a.name = $new_name"
result = tx.run(cql,name='张三',new_name='李四')

删除节点语句

'''
#批量删除
cql = "MATCH (a) WHERE a.name in {} DELETE a".format(['张三','李四'])
result = tx.run(cql)
'''
cql = "MATCH (a) WHERE a.name = $name DELETE a"
result = tx.run(cql,name='张三')

创建三元组语句

'''
#不重复插入实体
cql =  'merge (m:GraphEntity {entityId:"%s"}) merge (n:GraphEntity {entityId:"%s"}) merge (m)-[:GraphRelation%s]->(n)'

cql = 'match (m:GraphEntity),(n:GraphEntity) where m.entityId= "%s" and n.entityId= "%s" create (m)-[r:test] -> (n)'
'''

cql = "MERGE (a:%s {name: '张三',age: 18})-[:%s{year:5}]->(b:%s {name: '李四',age: 20})"%('person1','know','person2')
result = tx.run(cql)
'''

查询三元组语句

cql = "MATCH (a:%s {name:'张三',age:18})-[r:%s{year:5}]->(b) return a,r,b"%('person1','know','person2')
triples = tx.run(cql)

#获取具体属性信息
for triple in triples:
	print(triple.get('a')._id)
	print(triple.get('a')._labels)
	print(triple.get('a')._properties)
	
	print(triple.get('r')._id)
	print(triple.get('r')._properties)
	print(triple.get('r').type)
	
	print(triple.get('b')._id)
	print(triple.get('b')._labels)
	print(triple.get('b')._properties)

更新关系语句

cql = "MATCH (a)-[r]->(b) SET r.year=15"
result = tx.run(cql)

删除关系语句

cql = "MATCH (a)-[r]->(b) WHERE a.name in {} DELETE r".format(['张三','李四'])
result = tx.run(cql)

删除所有语句

MATCH (n) DETACH DELETE n

分组查询

# 以name分组，返回分组后的结果
MATCH (n) 
WITH n.name as name,n as n
WITH name, collect(n) AS n
RETURN name, n

批量插入

#批量插入
WITH [['张三',1],['李四',2]] AS coll UNWIND coll AS x CREATE (n:test{name:x[0],age:x[1]})

# key值不能带引号
WITH [{name:'张三',age:1}] AS coll UNWIND coll AS x CREATE (a:test {name:x.name,age:x.age})

# python去除引号
def dictToString(info):
    # 变为可以直接输入的属性字符串
    string = '{'
    for k, v in info.items():

        v = str(v) if v == 0 else v
        v = v if v else ''
        v = str(v)
        if 'datetime' != v[:8]:
            string += k
            string += ':"'
            string += v
            string += '",'
        else:
            string += k
            string += ':'
            string += v
            string += ','
    # 去掉最后一个逗号
    string = string[:-1] + '}'
    return string

def listToString(info):
    string = '['
    for i in info:
        string += dictToString(i)
        string += ','
    # 去掉最后一个逗号
    string = string[:-1] + ']'
    return string

高级语句

把可迭代对象拆分,UNWIND

#去重
WITH [1,1,2,2] AS coll UNWIND coll AS x
WITH DISTINCT x
RETURN collect(x) AS SET

组合多个查询结果,UNION

'''
UNION ALL会输出所有的查询结果，不做任何处理；UNION输出的时候会做去重处理
每个查询return的列数和列名都必须相同
'''
#输出1到9
unwind [1,2,3] as x
return x
union all
unwind [4,5,6] as x
return x
union all
unwind [7,8,9] as x
return x

时间处理

1、date

date函数默认返回当前时区的当前日期，如： RETURN date()   //结果："2019-05-24" 。具体使用方法如下：
date()                                                            //当前时区当前日期
date({ timezone: 'America/Los Angeles' })   //指定时区日期
date({ year:1984, month:10, day:11 })          //指定日期
date({ year:1984, week:10, dayOfWeek:3 })
date({ year:1984, quarter:3, dayOfQuarter: 45 })
date({ year:1984, ordinalDay:202 })
date('2015-07-21')
date('2015-07')
date('201507')
date('2015-W30-2')
date('2015202')
date('2015')

2、datetime

datetime()   //当前时间
datetime({ timezone: 'America/Los Angeles' })
datetime({ year:1984, month:10, day:11, hour:12, minute:31, second:14, millisecond: 123, microsecond: 456, nanosecond: 789 })

特殊查询

1、省略关系
match(n)-->(m)      两个 - 表示省略任意关系

2、匹配多种关系类型
match(n)->[:A|:B]->(m)    匹配A或者B类型的关系

3、带有空格的关系
match(n)-[`A B`]->(m)      使用反引号

4、变长关系
match(n)-[r*1..3]-(m)     查找n的1~3跳关系，包括1和3，默认值是1和无穷大，可以省略其中一个值。如果省略 .. ，且只有一个值则表示固定跳数（长度）关系。

5、最短路径(m、n不能为同一节点)
match(n),(m),p=shortestPath((n)-[r*..10]-(m))  where id(n)<>id(m) return p     查找n，m之间的最短路径，路径最大长度为10

#返回对象id以及对应对象
match(n),(m),p=shortestPath((n)-[r*1..3]-(m))  where id(n)<>id(m) return [x in relationships(p) | [[id(startNode(x)),startNode(x)],[id(x),x],[id(endNode(x)),endNode(x)]]] as triples

6、所有最短路径
match(n),(m),p=allShortestPaths((n)-[*]-(m))  where id(n)<>id(m)    查找n，m之间所有最短路径

7、id查询
match(n) where id(n)=1 return n

8、OPTIONAL MATCH
match(n:Person{name:"p1"})
optional match(m:Person{name:"p2"})   
return n,m
如果p1存在，p2不存在，则也会返回p1。

9、逻辑判断
cypyer支持 AND、OR、NOT、XOR等逻辑运算。

10、where标签过滤
标签过滤常常放在match中，where也支持标签过滤。下面三句效果是一样的：
match(n:Person) return n
match(n) where labels(n)=["Person"] return n
match(n) where n:Person return n
注意该语法只支持节点标签判断，不支持关系标签判断，where关系判断参考16。

11、属性存在检查
exists函数支持属性检查判断属性是否存在。
match(n) where exists (n.name) return n

12、字符串匹配
STARTS WITH匹配字符串开始：match(n) where n.name STARTS WITH 'Jac' return n
ENDS WITH匹配字符串结尾：match(n) where n.name ENDS WITH 'li' return n
CONTAINS匹配字符串，不关心位置：match(n) where n.name CONTAINS 'ac' return n
使用NOT可以判断上述三个语句的反向条件

13、where路径模式
一般只会在match中使用路径模式，比如下面：
match(n)-->(m:Person{name:"p1"}) return n   返回所有指向p1的节点
如果反过来，查找所有不指向p1的节点:
match(n),(m:Person{name:"p1"}) where not (n)-->(m) return n   需要注意的时，该语句也会返回p1自身

14、比较运算
cypher比较运算符包括：=、<>、<、>、<=、>=、IS NULL、IS NOT NULL（NOT IS NULL也可以，但是这两种的解释不一样），注意不支持 !=

15、skip和limit
这两个应该比较熟悉，跳过和限制返回：
match(n) return n limit 1
match(n) return n skip 1

16、type匹配关系类型
常用的关系类型匹配是在路径模式中，比如下面这种：
match(n)-[r:F1]->(m) return n   查找F1类型的关系，也可以在where中通过type函数判断类型，如下面这种：
match(n)-[r]->(m) where type(r)="F1"  return n
注意type函数支持关系类型判断，不支持节点标签判断，关于节点where标签判断，参考10。

17、cypher正则表达式
cypher正则表达式来源于java，含义和java正则也是大同小异。cypher正则标识是 =~ 。例如：

MATCH (n)
WHERE n.name =~ 'Tim.*'    //查找以Tim开头的名字
RETURN n.name, n.age
对于 . * 等特殊符号需要转义，例如：

MATCH (n)
WHERE n.email =~ '.*\\.com'       //查找以.com结尾的字符串
RETURN n.name, n.age, n.email
(?i)表示不区分大小写，例如：

MATCH (n)
WHERE n.name =~ '(?i)AND.*'
RETURN n.name, n.age
(?s)表示全文检索，例如：

return 'w1w2\nt3w3w4' =~ '.*w3.*'        //返回false
return 'w1w2\nt3w3w4' =~ '(?s).*w3.*'    //返回true

18、索引
添加索引：CREATE INDEX ON :label_name(property)
删除索引：DROP INDEX ON :label_name(property)
查看索引和约束：   :schema  （注意前面有一个冒号）

19、模糊属性查询
查询属性包含 "test" 子串的属性
unwind keys(node) as key
where key contains 'test'
但是一般情况下不推荐这么做，因为这种查询无法利用属性索引

ORDER BY

'''
默认升序，加DESC为降序
'''
MATCH (n)
RETURN n.name,n.age 
ORDER BY n.age DESC

CASE

'''
相当于if ... else ...
'''
MATCH (n)
RETURN n.name,
CASE n.age
WHEN n.age IS NULL THEN -1
ELSE n.age - 10 END AS age_10_years_ago

聚合函数

聚合函数	含义
count	计数
sum	求和
avg	平均值
percentileDisc	计算给定百分位在组中的值，数值从0.0~1.0，采用四舍五入返回最接近百分位的值
percentileCont	计算给定百分位在组中的值，数值从0.0~1.0，采用线性插值，在两个值之间计算一个加权平均数
stdev	无偏估计的标准偏差，分母是n-1
stdevp	标准偏差
max/min	最大/最小
collect	将所有值收集作为一个列表返回，忽略空值
distinct	去重，可用于聚合函数中
reverse	可迭代对象反转
tail	跳过第一个元素,等同与索引范围[1…]

#返回列表形式的结果
MATCH (n) RETURN collect(n.name)

列表操作

'''
和python类似
'''
#列表索引
RETURN [1,2,3,4][0..3]     #[1,2,3]
RETURN [1,2,3,4][-2..]     #[3,4]

#列表推导式,返回过滤符|后面的内容
RETURN [x in range(1,5) where x%2=0 | x^2]     #[4.0, 16.0]

NULL

#逻辑运算
x		y		x AND y		x OR y		x XOR y
false	null	false		null		null
true	null	null		true		null
null	null	null		null		null

#in运算
return 3 in []                   //返回false
return 3 in [1,2,null]       //返回null
return null in [1,2,3]       //返回null
return null in [1,2,null]   //返回null

#is运算
判断为null：x is null
判断非null：x is not null

函数

一、断言函数
1、all
语法：all(variable IN list WHERE predicate)
返回：Boolean
含义：list中的所有元素都满足where条件，则返回true，否则返回false。
Demo：return all(x in [1,2,3,4] where x%2=0)  //结果是false

2、any
语法：any(variable IN list WHERE predicate)
返回：Boolean
含义：list中的所有元素有一个满足where条件，则返回true，否则返回false。
Demo：return any(x in [1,2,3,4] where x%2=0)  //结果是true
注意：return any(x in [] where x%2=0)        //返回false
           return any(x in [null] where x%2=0)  //返回null
           return any(x in [2.0] where x%2=0)   //返回true

3、exist
语法：exists(pattern-or-property)
返回：Boolean
含义：判断是否存在某个属性或者模式。
Demo：

MATCH (n)
WHERE exists(n.name)
RETURN n.name AS name, exists((n)-[:MARRIED]->()) AS is_married
4、none

语法：none(variable IN list WHERE predicate)
返回：Boolean
含义：如果list中每个元素都不满足where条件，则返回true，否则false。
Demo：return none(x in [1,3] where x%2=0)   //返回true

5、single

语法：single(variable IN list WHERE predicate)
返回：Boolean
含义：如果list中只有一个元素满足where条件，则返回true，否则false。
注意：return single(x in [6,null] where x%2=0)  //返回null

二、标量函数
1、coalesce

语法：coalesce(expression [, expression]*)
含义：返回参数中第一个不为null的值，如果都为null，则返回null。
Demo：MATCH (a) RETURN coalesce(a.hairColor, a.eyes)   //返回第一个存在的属性，只要有一个节点存在就返回，不存在的返回null

2、startNode和endNode

语法：startNode(relationship)，endNode(relationship)
含义：返回关系的起始、结束节点，参数是关系，startNode(null)返回null。
Demo：MATCH (x:Developer)-[r]-() RETURN endNode(r)

3、head和last

语法：head(list)，last(list)
含义：返回列表的第一个/最后一个元素。
Demo：return head([3,null,1,2,3])   //返回3，return head([])   //返回null

4、randomUUID

语法：randomUUID()
含义：返回一个128位的唯一uuid。
返回：string
Demo：return randomUUID()

5、id

语法：id(expression)
返回：Integer
含义：返回节点或者关系的id

6、size

语法：size(list)
含义：返回一个列表或者字符串的长度，size(null)返回null。
返回：Integer
Demo：return size("www")

7、length

语法：length(path)
含义：返回路径的长度，输入是路径，length(null)返回null。
返回：Integer
Demo：match p=(n:Person{name:"p1"})-[*1..5]-(m) return length(p)
注意：length和size功能非常相似，length也可以用于计算string、list、pattern的长度，但是强烈建议只对path使用length，对其它类型长度的计算功能，后续可能被丢弃。

8、properties

语法：properties(expression)
含义：返回节点或者关系的全部属性map集合，properties(null)返回null。
返回：map
Demo：match (n:Person{name:"p2"}) return properties(n)

9、timestamp

语法：timestamp()
含义：返回当前时间和1970年1月1日之间的毫秒值。
返回：Integer
Demo：RETURN timestamp()
注意：在整个查询执行期间，timestamp的值都是相同的，即不能使用timestamp计算一个查询的执行时间

10、类型转换函数

注意：以下函数转换失败时，都返回null，不报异常，但是如果参数类型错误会报异常。
toBoolean(expression)    //转换一个字符串为布尔值，注意toBoolean("1")返回null。
                                        // RETURN toBoolean("TRUE"), toBoolean('False')    //返回true和false
toFloat(expression)         //转换一个integer or string 为浮点型
toInteger(expression)      //转换一个浮点型或者string为integer
toString(expression)        //转换数值型或者时间为字符串，支持十六进制和八进制。但是结果都是十进制

11、type

语法：type(relationship)
含义：返回关系的Label，type(null)返回null。
返回：String
Demo：match(n:Person{name:"p1"})-[r]-(m) return type(r)

12、labels

语法：labels(node)
含义：返回节点的Label，labels(null)返回null。
返回：list，因为节点可以有多个label
Demo：match(n:Person{name:"p1"})-[r]-(m) return labels(m)

三、字符串函数
1、left和right

语法：left(original, length)、right(original, length)
含义：获取original的左边、右边length长子串。
返回：String

2、ltrim、rtrim、trim

语法：lTrim(original)、rTrim(original)、trim(original)
含义：去除original左边、右边、两边空格
返回：String

3、replace

语法：replace(original, search, replace)
含义：使用replace替换original中的所有search字符串
返回：String

4、reverse

语法：reverse(original)
含义：翻转original
返回：String

5、split

语法：split(original, splitDelimiter)
含义：使用splitDelimiter切分original，需要注意的是当字符串首尾是分隔符时，首尾也会返回一个 ""
返回：列表
Demo：return split('w3w1w2w3w4w3', 'w3')       //返回  ["", "w1w2", "w4", ""]

6、substring

语法：substring(original, start [, length])
含义：获取original从start开始的length长子串，从0开始，包含start
返回：String

7、toLower

语法：toLower(original)、toUpper(original)
含义：转换original为小写、大写
返回：String

8、contains

语法：original contains substring
含义：contains并不是一个函数，是一个关键词，在字符串中使用也很方便，判断original中是否包含substring
返回：Boolean

四、遍历/列表函数
1、keys

语法：keys(expression)
含义：返回节点、关系或者map的属性列表
返回：List
Demo：MATCH (a) WHERE a.name = 'Alice'  RETURN keys(a)

2、labels

语法：labels(node)
含义：返回节点的所有标签列表，之所以返回是列表，是因为节点可以有多个label
返回：List
Demo：MATCH (a) WHERE a.name = 'Alice'  RETURN labels(a)

3、nodes

语法：nodes(path)
含义：返回路径上的所有节点
返回：List
Demo：MATCH p =(a)-->(b)-->(c) WHERE a.name = 'Alice' AND c.name = 'Eskil' RETURN nodes(p)

4、relationships

语法：relationships(path)
含义：返回路径上的所有关系
返回：List
Demo：MATCH p =(a)-->(b)-->(c) WHERE a.name = 'Alice' AND c.name = 'Eskil' RETURN relationships(p)

5、reduce

语法：reduce(accumulator = initial, variable IN list | expression)
含义：返回每个元素作用在表达式上的结果，类似于scala中的reduce函数
返回：由输入决定
Demo：return(init = 0, x in [1,2,3,4] | init+x) as sum   //求所有列表元素的和