Neo4j-8-Projection-Filtering
Neo4j 第八篇：投射和过滤
转载：https://www.cnblogs.com/ljhdo/p/10917618.html
参考：https://neo4j.com/docs/developer-manual/3.2/cypher/clauses/
投射子句用于定义如何返回数据集，并可以对返回的表达式设置别名，而过滤子句用于对查询的结果集按照条件进行过滤
一 Return 子句
使用 return 子句返回节点，关系和关系。
1 返回节点
1
2
| MATCH (n { name: 'B' })
RETURN n
|
2 返回关系
1
2
| MATCH (n { name: 'A' })-[r:KNOWS]->(c)
RETURN r
|
3 返回属性
1
2
| MATCH (n { name: 'A' })
RETURN n.name
|
4 返回所有元素
1
2
| MATCH p =(a { name: 'A' })-[r]->(b)
RETURN *
|
5 为属性设置别名
1
2
| MATCH (a { name: 'A' })
RETURN a.age AS SomethingTotallyDifferent
|
6 返回谓词（predicate），文本（literal）或模式（pattern）
1
2
| MATCH (a { name: 'A' })
RETURN a.age > 30, "I'm a literal",(a)-->()
|
7 使用 distinct 关键字返回不重复值
1
2
| MATCH (a { name: 'A' })-->(b)
RETURN DISTINCT b
|
二 with 子句
一个查询（Query）语句有很多查询子句，每一个查询子句按照特定的顺序执行，每一个子句是查询的一部分（Part）。with 子句的作用是把上一个查询的结果进行处理，作为下一个查询的数据源，也就是说，在上一个查询的结果输出到客户端之前，把结果传递到后续的子句中去。
1 对聚合的结果进行过滤
聚合的结果必须通过 with 子句才能被过滤，例如，with 子句保留 otherPerson ，并新增聚合查询 count(*)，通过 where 子句过滤，返回查询结果： Anders。
1
2
3
4
| MATCH (david { name: 'David' })--(otherPerson)-->()
WITH otherPerson, count(*) AS foaf
WHERE foaf > 1
RETURN otherPerson.name
|
2 限制返回的结果
1
2
3
4
5
| MATCH (n { name: 'Anders' })--(m)
WITH m
ORDER BY m.name DESC LIMIT 1
MATCH (m)--(o)
RETURN o.name
|
三 unwind 子句
unwind 子句用于把 list 格式的字符串拆开为行的序列
1 拆开列表
1
2
| UNWIND [1, 2, 3, NULL ] AS x
RETURN x, 'val' AS y
|
2 拆开嵌套列表
1
2
3
4
| WITH [[1, 2],[3, 4], 5] AS nested
UNWIND nested AS x
UNWIND x AS y
RETURN y
|
3 Collect 函数
collect 函数用于把值组装成列表
1
2
3
4
| WITH [1, 1, 2, 2] AS coll
UNWIND coll AS x
WITH DISTINCT x
RETURN collect(x) AS setOfVals
|
四 Where 子句
使用 Where 子句对查询的结果进行过滤
1 按照逻辑表达式来过滤
1
2
3
| MATCH (n)
WHERE n.name = 'Peter' XOR (n.age < 30 AND n.name = 'Tobias') OR NOT (n.name = 'Tobias' OR n.name = 'Peter')
RETURN n.name, n.age
|
2 按照节点的标签来过滤
1
2
3
| MATCH (n)
WHERE n:Swedish
RETURN n.name, n.age
|
3 按照节点的属性来过滤
1
2
3
| MATCH (n)
WHERE n.age < 30
RETURN n.name, n.age
|
4 按照关系的属性来过滤
1
2
3
| MATCH (n)-[k:KNOWS]->(f)
WHERE k.since < 2000
RETURN f.name, f.age, f.email
|
5 按照动态计算的属性来计算
1
2
3
4
| WITH 'AGE' AS propname
MATCH (n)
WHERE n[toLower(propname)]< 30
RETURN n.name, n.age
|
6 是否存在属性
1
2
3
| MATCH (n)
WHERE exists(n.belt)
RETURN n.name, n.belt
|
7 字符串匹配
对字符串进行匹配：starts with、ends with，contains
1
2
3
| MATCH (n)
WHERE n.name STARTS WITH 'Pet'
RETURN n.name, n.age
|
1
2
3
| MATCH (n)
WHERE n.name ENDS WITH 'ter'
RETURN n.name, n.age
|
1
2
3
| MATCH (n)
WHERE n.name CONTAINS 'ete'
RETURN n.name, n.age
|
8 正则匹配
使用 =~ ‘regexp’ 匹配正则 ，如果正则表达式以 (?i)开头，表示整个正则是大小写敏感的。
1
2
3
| MATCH (n)
WHERE n.name =~ 'Tob.*'
RETURN n.name, n.age
|
1
2
3
| MATCH (n)
WHERE n.name =~ '(?i)ANDR.*'
RETURN n.name, n.age
|
9 匹配路径模式
1
2
3
| MATCH (tobias { name: 'Tobias' }),(others)
WHERE others.name IN ['Andres', 'Peter'] AND (tobias)<--(others)
RETURN others.name, others.age
|
使用 not 来排除路径模式：
1
2
3
| MATCH (persons),(peter { name: 'Peter' })
WHERE NOT (persons)-->(peter)
RETURN persons.name, persons.age
|
使用属性来匹配路径：
1
2
3
| MATCH (n)
WHERE (n)-[:KNOWS]-({ name: 'Tobias' })
RETURN n.name, n.age
|
使用关系类型来匹配路径：
1
2
3
| MATCH (n)-[r]->()
WHERE n.name='Andres' AND type(r)=~ 'K.*'
RETURN type(r), r.since
|
10 列表
使用 IN 操作符表示匹配列表中的元素
1
2
3
| MATCH (a)
WHERE a.name IN ['Peter', 'Tobias']
RETURN a.name, a.age
|
11 缺失值
如果属性值缺失，那么属性值默认值是 null，null 和任何值比较都是 false；可以使用 is not null 或 is null 来判断是否为 null
1
2
3
| MATCH (person)
WHERE person.name = 'Peter' AND person.belt IS NULL
RETURN person.name, person.age, person.belt
|
五 排序
使用 order by 对查询的结果进行排序，默认是升序，使用关键字 desc 使 Cypher 按照降序进行排序。
1 按照节点的属性进行升序排序
1
2
3
| MATCH (n)
RETURN n.name, n.age
ORDER BY n.name
|
2 按照节点的属性值进行降序排序
1
2
3
| MATCH (n)
RETURN n.name, n.age
ORDER BY n.name DESC
|
六 SKIP 和 LIMIT
SKIP 是跳过前 N 行，LIMIT 是限制返回的数量
1 跳过前 3 行
1
2
3
4
| MATCH (n)
RETURN n.name
ORDER BY n.name
SKIP 3
|
2 跳过前 3 行，返回第 4 和 5 行
1
2
3
4
5
| MATCH (n)
RETURN n.name
ORDER BY n.name
SKIP 3
LIMIT 2
|
