Neo4j3-Neo4j基础操作（中）

一、关系操作

  1. 创建关系

    (1) 关系模式的构成：起始节点 - [变量名:关系类型 {属性名1:属性值1,属性名2:属性值2,...,属性名n:属性值n}] -> 结束节点

    (2) 在创建关系时，必须指定关系类型

    (3) 关系带有方向，箭头的方向代表关系的方向

    (3) 创建关系同样使用 create 子句

match (s1 {name: "张三"}), (s2 {name: "李四"})
create (s1) - [r:关系 {relationship: "朋友"}] -> (s2)
return r;

        先获取要创建关系的2个节点，再创建关系

    (4) 也可以边创建节点边创建关系

match (s1 {name: "张三"})
create (s1) - [r:关系 {relationship: "朋友"}] -> (s2:`人`:`学生` {name: "王五"})
return r;

  2. 查询关系

      关系是带方向的，查询关系使用的符号有3种：-- 代表任意方向，--> 和 <-- 分别代表箭头方向的关系

    (1) 查询连接节点张三的所有关系的节点

match ({name: "张三"}) -- (n)
return n;

    (2) 查询连接张三的从张三出发的所有有向关系的节点

match ({name: "张三"}) --> (n)
return n;

    (3) 使用变量为关系命名，查询连接张三的所有关系的 relationship 属性，和节点的 name 属性

match ({name: "张三"}) - [r] - (n)
return n.name as name, r.relationship as relationship;

         使用 as 子句可以给查询结果的列名起别名

3. 修改关系

    (1) 同样是使用 set 子句，新增或修改关系的属性

match ({name: "李四"}) - [r] - ({name: "赵六"})
set r.relationship = "同学"
return r;

        先获取要修改的关系，再对其进行修改操作

    (2) 同样是使用 remove 子句，删除关系的属性

match ({name: "李四"}) - [r] - ({name: "赵六"})
remove r.relationship
return r;

  4. 删除关系

      删除关系同样是使用 delete 子句，先获取到要删除的关系，再删除即可

    (1) 删除关系

match ({name: "李四"}) - [r] - ({name: "赵六"})
delete r;

    (2) 删除连接节点张三的所有关系

match ({name: "张三"}) - [r] - ()
delete r;

二、路径操作

  1. 路径模式

      路径模式的构成：变量名 = 开始节点 边 节点 边 ... 节点 边 ... 结束节点

  2. 路径匹配

    (1) [*n]：两个节点间有 n 个关系

# 例如[*4]表示a和b之间有4个关系
match p = (a:人) - [*4] - (b)
return p;

    (2) [*m..n]：两个节点间包含 m 到 n 个关系

# 路径包含3~5个关系
match p = (a) - [*3..5] - b
return p;

# 路径包含3个及以上关系
match p = (a) - [*3..] - b
return p;

# 路径包含5个及以内关系
match p = (a) - [*..5] - b
return p;

    (3) [*]：两节点之间的所有关系

match p = (a) - [*] - (b)
return p;

        这个查询不推荐使用，相当于全库扫描，效率特别低下，数据量稍微多一点就会很慢

三、数据类型

  1. 属性类型

    (1) 数值类：Integer（整数）和 Float（浮点数）

    (2) 字符串：String

    (3) 布尔类：Boolean

    (4) 空间类：Point

    (5) 时间类：Date，Time，LocalTime，DateTime，LocalDateTime 和 Duration

  2. 结构类型

    (1) 节点类：Node（包含 Id， Labels、Map 类型）

    (2) 关系类：Relationship（包含 Id、Type、Map 类型）

    (3) 路径类：Path（节点和关系的序列）

  3. 组合类型

    (1) 列表类：List（列表是元素的有序序列，元素可以是任意类型）

    (2) 字典类：Map（由 (key, value) 对组成，key 是 字符串类型，value 可以是任意类型）

  4. 类型转换

    (1) toBoolean() 和 toBooleanOrNull()：将字符串、整数或布尔值转换为布尔值

    (2) toFloat() 和 toFloatOrNull()：将整数、浮点数或字符串值转换为浮点数

    (3) toInteger() 和 toIntegerOrNull()：将布尔值、整数、浮点数或字符串值转换为整数值

四、常用函数

  1. 标量函数

        标量函数返回标量值

    (1) 节点相关

# id()：返回节点或关系的 id
# labels()：返回节点的标签（List）
# keys()：返回节点或关系的属性名（List）
# properties()：返回节点或关系的属性（Map）

create (p:人 {name: "小明", city: "济南"})
return id(p), labels(p), keys(p), properties(p);

    (2) 关系相关

# type()：返回关系的类型
# startNode()：返回关系的开始节点
# endNode()：返回关系的结束节点

match (a) - [r] -> (b)
return type(r), startNode(r), endNode(r);

    (3) 列表相关

# coalesce：返回参数列表中第一个非 null 的元素，都为空则返回 null
match (n)
return coalesce(n.age, n.name, n.sex);

# head：返回列表中第一个元素
# last：返回列表中最后一个元素
# size：返回列表中元素的数量

match (n)
where exists(n.nums)
return n.nums, coalesce(n.nums), head(n.nums), last(n.nums), size(n.nums);

    (4) 长度相关

# size(string)：表示字符串中字符的数量，可以把字符串当作是字符的列表
# size(list)：返回列表中元素的数量
# size(pattern_expression)：也是统计列表中元素的数量，但是不是直接传入列表，而是提供模式表达式（pattern_expression），用于在匹配查询（Match query）中提供一组新的结果，这些结果是路径列表，size()函数用于统计路径列表中元素（即路径）的数量。
# length(path)：返回路径的长度，即路径中关系的数量

# 统计列表中元素数量
match (a) where a,name = "Mike"
return size(a --> () --> ());

    (5) 字符串相关

# upper()，用于将所有字母更改为大写字母
# lower()，用于将所有字母改为小写字母
# substring()，用于截取字符串
# replace()，用于替换字符串

 

  2. 断言函数

        断言函数返回 true 或者 false，主要用于检查是否存在或满足特定的条件

    (1) exists()

        如果指定的模式存在于图中，或者特定的属性存在于节点、关系或Map中，那么函数返回True

# 查询具有 name 属性的所有节点
match (n)
where exists(n.name)
return n;

    (2) 检查集合元素

      1 -> all() 表示所有的元素都满足条件

# all 谓词表示，在路径中，所有节点都必须具有 age 属性，并且 age 属性值都必须大于20
match p = (a) - [*1..3] -> (b)
where all(x in nodes(p) where x.age > 30)
return p;

      2 -> any() 表示至少一个元素满足条件

# any 谓词表示，节点的 array 属性中至少有一个元素值为"one"
match (a)
where any (x in a.array where x = "one")
return a;

      3 -> none() 表示没有一个元素满足条件

# none 谓词表示，在路径中，没有节点的 age 属性是25
match p = (a) - [*1..3] -> (b)
where none(x in nodes(p) where x.age = 25)
return p;

      4 -> single() 表示只有一个元素满足条件

# single 谓词表示，在路径中，只有一个节点的 eyes 属性是"blue"
match p = (n) --> (b)
where single(x in nodes(p) where x.eyes = "blue")
return p;

  3. 聚合函数

      聚合函数用于对查询结果进行统计

    (1) avg()，计算均值

    (2) count()，用于计算非 null 值的数量

# 使用 count(distinct n) 进行无重复非 null 值的计数
match (n) return count(distinct n.name);

# 使用 count(*) 计算值或记录的总数量，包括 null 值

    (3) max() 和 min()，求最大值和最小值

# 在计算极值时，null 被排除在外
# min(null) 和 max(null) 返回 null

    (4) sum()，求和

# 在求和时，null 值被排除在外，sum(null) 的结果是0

    (5) collect()，把返回的多个值或记录组装成一个列表

# collect(null) 返回一个空的列表

      在聚合运算中，可以引用分组键来对查询的结果进行分组聚合

# 例如，在 return 子句中，如果表达式不是聚合函数，那么该表达式是分组 key，下面的表达式是按照 type(r) 分组，计算每个分组中记录的数量

# 每个地点分别有多少人来过
match (l:地点) <- [:目的地] (p:人员) return l.name as 地点,count(*) as 人数;

  4. 列表函数

      列表（List）是 cypher 中的一个重要的组合类型，对列表进行操作的函数主要是生成列表、获取列表对象、抽取特定的列表元素、过滤列表元素和对列表元素进行迭代计算

    (1) extract()，抽取元素构成列表，作用是从列表中抽取值

# extract(item in list | expression)
# 根据抽取的值组装成一个列表，返回这个列表

match p = (a) --> (b) --> (c)
where a.name = "小明" and b.name = "小华" and c.name = "小红"
return extract(n in nodes(p) | n.age;

    (2) filter()，过滤列表元素

# filter(item in list where predicate)
# 把过滤后的元素组成一个列表，返回这个列表

match a where a.name = "马云"
return a.array, filter(x in a.array where x.size() = 3);

    (3) 获得列表

# keys(node)，从节点的属性中抽取属性键
# labels(node)，节点标签的列表
# nodes(path)，从路径中获取所有节点的列表
# relationships(path)，从路径中获得所有的关系

match (a) where a.name = "Kate"
return labels(a), keys(a);

match p = (a) --> (b) --> (c)
where a.name = "小明" and c.name = "小红"
return nodes(p), relationships(p);

    (4) 序列的生成和倒置

        range()，用于生成一个有序的序列

        reverse()，把原始列表的元素进行倒置

# range(start, end[ ,step]
# reverse(list)

    (5) 迭代计算列表

        reduce() 函数应用在列表上，对列表中的每个元素 item 进行迭代计算，在元素 item 上运行表达式（expression），把当前的结果存储在累加器中，进行迭代计算，并返回最终计算的标量结果

# reduce(accumulator = initial, item in list } expression)

#例如，初始的 age 是0，对路径 p 中的所有节点，计算各个节点的 age 之和
match p = (a) --> (b) --> (c)
where a.name = "小明" and b.name = "小华" and c.name = "小红"
return reduce(totalAge = 0, n in nodes(p) | totalAge + n.age) as tatalAge;