Neo4j 查询例句

MATCH (john {name: ‘John‘})-[:friend]->()-[:friend]->(fof) RETURN john.name, fof.name

MATCH (user)-[:friend]->(follower)
WHERE user.name IN [‘Joe‘, ‘John‘, ‘Sara‘, ‘Maria‘, ‘Steve‘] AND follower.name =~ ‘S.*‘
RETURN user.name, follower.name

• CREATE (DELETE): 创建或删除节点/关系

• SET ( REMOVE): 给属性 赋/ 删 值；给节点 添/删 标签

• MERGE: 匹配一个节点，如果该节点不存在。则创建该节点

• MATCH: 从图中查询信息。如：节点、节点属性、节点关系 等等

• WHERE: 它不是一个单独的句子。但是它是MATCH OPTIONAL MATCH ,WITH 的一部分，进行限定或者是过滤。或者对WITH 的返回结果进行过滤。

• RETURN: 后接 你想要返回的值、及其格式

MATCH (n {name: ‘John‘})-[:FRIEND]-(friend)
WITH n, count(friend) AS friendsCount
WHERE friendsCount > 3   // 对 with 的值进行过滤
RETURN n, friendsCount

MATCH (n {name: ‘John‘})-[:FRIEND]-(friend)
WITH n, count(friend) AS friendsCount
SET n.friendsCount = friendsCount
RETURN n.friendsCount

The RETURN 句子有三个字句，对结果进行处理 : SKIP、LIMIT 和 ORDER BY.

任何对图进行更新的语句，都会在一个 事务中进行.

CREATE (adam:User { name: ‘Adam‘ }),(pernilla:User { name: ‘Pernilla‘ }),(david:User { name: ‘David‘}),(adam)-[:FRIEND]->(pernilla),(pernilla)-[:FRIEND]->(david)

MATCH (user:User { name: ‘Adam‘ })-[r1:FRIEND]-()-[r2:FRIEND]-(friend_of_a_friend)
RETURN friend_of_a_friend.name AS fofName
//  1   这个句子和下面这个句子 2  的结果是一样的，但不同于 3

MATCH (user:User { name: ‘Adam‘ })-[r1:FRIEND]-(friend),(friend)-[r2:FRIEND]-(friend_of_a_friend)RETURN friend_of_a_friend.name AS fofName
  // 2   这个句子和 句子 1 效果相同，但是不同于句子 3.虽然中间用“，”号分开了，但他们仍然是一个match句。

MATCH (user:User { name: ‘Adam‘ })-[r1:FRIEND]-(friend)
MATCH (friend)-[r2:FRIEND]-(friend_of_a_friend)
RETURN friend_of_a_friend.name AS fofName
// 3  词句子不同于上面的 句子 1  和句子  2 ，因为这是两个match 句子。

MATCH (n)
RETURN
CASE n.eyes  // 这里已经限定了 n.eyes 值 的 类型。
WHEN ‘blue‘  
THEN 1
WHEN ‘brown‘
THEN 2
ELSE 3 END AS result
// 用 n.eyes 的值，依次和 when 条件进行对，直到得到正确的。返回相应的 then 的值。如果到最后也没有找到正确的，那么就返回 else 
// 条件的值。如果未设置 else 条件的值，那么返回  null

MATCH (n)
RETURN
CASE
WHEN n.eyes = ‘blue‘
THEN 1
WHEN n.age < 40
THEN 2
ELSE 3 END AS result
// 依次计算各个 when 条件，直到找到正确的表达式，返回相应的 then 的 值。如果最后也没有找到正确的表达式
// 那么就返回 else 的值。如果 未设置 else 的值，那么 返回 null

以下是变量的一些用法：

{
  "name" : "Johan"
}
?
MATCH (n:Person)
WHERE n.name = $name
RETURN n
?
MATCH (n:Person { name: $name })
RETURN n

{
  "regex" : ".*h.*"
}
MATCH (n:Person)
WHERE n.name =~ $regex
RETURN n.name
// =~ 后跟正则表达式

{
  "s" : 1,
  "l" : 1
}   
?
MATCH (n:Person)
RETURN n.name
SKIP $s
LIMIT $l

{
  "ids" : [ 0, 1, 2 ]
}
?
MATCH (n)
WHERE id(n) IN $ids    // in
RETURN n.name

WITH [‘John‘, ‘Mark‘, ‘Jonathan‘, ‘Bill‘] AS somenames
UNWIND somenames AS names  // unwind 解包
WITH names AS candidate
WHERE candidate STARTS WITH ‘Jo‘
RETURN candidate

WITH [2, 4, 7, 9, 12] AS numberlist
UNWIND numberlist AS number
WITH number
WHERE number = 4 OR (number > 6 AND number < 10)  // and  or 的用法，cypher 也支持 异或
RETURN number

RETURN [1,2,3,4,5]+[6,7] AS myList   // 此处 + 用来组合列表。 + 也可以用于拼接字符串

WITH [‘Anne‘, ‘John‘, ‘Bill‘, ‘Diane‘, ‘Eve‘] AS names
RETURN names[1..3] AS result   // 切片 “..” 作用等同于  “：”

(a:User:Admin)-->(b)  // 当一个 node 有多个label

变长模式匹配

(a)-[*2]->(b)  // 2 表示路径长度是  2 ,也叫深度为  2 
?
(a)-->(c)-->(b) // (a)-->(c) 这就是一个路径长度，包含一个关系两个节点。

(a)-[*3..5]->(b)  // 表示 （a）（b）之间的路径长度是3 到5 之间（3，5 都包括）
(a)-->()-->()-->(b)
(a)-->()-->()-->()-->(b)
(a)-->()-->()-->()-->()-->(b)

(a)-[*3..]->(b) // (a),(b)之间的路径距离为  3 及其以上

(a)-[*..5]->(b) //(a),(b)之间的路径为 5 及其以下

(a)-[*]->(b)   // (a),(b) 之间的路径距离为  任意值

MATCH (me)-[:KNOWS*1..2]-(remote_friend)
WHERE me.name = ‘Filipa‘  
RETURN remote_friend.name    // me 的名字是 Filipa, 返回 和我是 KNOWS 关系的 路径距离是 1  到 2之间                             //  的节点(人) 的属性(名字)

可变长度关系不可用于MATCH and MERGE.

一组相互连接的关系和节点被称为 path , Cypher 允许用一个标识符，你也可以用同样的方法，命名 MATCH CREATE 、MERGE 。 注意，这种用标识符命名的方式，不能用于匹配表达式。

You can do this in MATCH, CREATE and MERGE, but not when using patterns as expressions.

p = (a)-[*3..5]->(b)  // 不知道为啥，我做不成功

return range(1,10) as list
[1,2,3,4,5,6,7,8,9,10]  // 注意：在cyper 中，range() 是包含右边界的。
return range(1,10)[3]
3
RETURN range(0, 10)[-3]
8

RETURN range(0, 10)[0..3]  // 切片 相当于python 的 :,注意 这种切片是 含左不含右的
[0,1,2]

RETURN range(0, 10)[0..-5]
[0,1,2,3,4,5]       // 右边  “-” 的存在使  右边 的边界元素也 包括 进了切片中

RETURN range(0, 10)[-5..]
[6,7,8,9,10]     // 不同   左边的“-” 使 切片 不 包括左边的边界元素

RETURN range(0, 10)[..4]
[0,1,2,3]   //  相当于 [:4]

RETURN range(0, 10)[5..15]
[5,6,7,8,9,10]   // 超出边界会被截断，只显示 当前具有的一组片段
?
RETURN range(0, 10)[15] 
null    // 但如果是单个元素，那么就会返回 null，而不是报错

RETURN [x IN range(0,10) WHERE x % 2 = 0 | x^3] AS result // "|" 管道符的使用，结果的传递处理

match (n{name:"an"}) return [(n)--(b) where b:Person|b.name] as name
[sun,ma]  // 一次返回 ，在一个结果里面(可以通过查看 返回的json 格式来发现他们的区别)
MATCH (a:Person { name: ‘anxibin‘ })-[r]-(b:Person) return b.name  
sun ,ma   //分两次返回，分别在不同的结果里面
?
with predicates just like a normal WHERE clause, but will yield a custom projection as specified. // predicates 谓语   projection 投影

MATCH (a:Person) return a.name,a.age,a.from
// 查看返回结果的 json 格式，可以看出，它的键一起在一个地方，值一起在另一个地方，键值分离了。
// "a.name" "a.age" "a.from"
//   "sun"   18       null
//   "ma"    19        null

// map projection 映射
MATCH (a:Person)return a {.name,.age,.from}
// 查看结果的json 格式，可以看出，他们的键值对是在一起的。
{"name":"sun","age":18,"from":null}
{"name":"ma","age":19,"from":null}

MATCH (a:Person)return a {.*}
// {"name":"Emil","from":"beijing","klout":99}
// {"name":"an","age":20}
// {"name":"zhen","age":9}
// 如果map 中是 .* ，那么就会只显示变量自己所拥有的全部属性。而不像上面似的，指定了返回的属性值，如果，该变量没有那个属性值，就只能以 null 填充
// 注意，如果 变量 a 指向的是一个 null 值，那么所有的返回值都是 null

MATCH (a:Person{name:"an"})-[:KNOWS]->(n:Person)return a{.name,.age,friens:n{.name,.age}}
// {"name":"an","age":20,"friens":{"name":"sun","age":21}}
// 变量名也可以作为键 

MATCH (a:Person{name:"an"})-[:KNOWS]->(n:Person)return a{.name,.age,friens:collect(n{.name,.age})}
?
// {"name":"an","age":20,"friens":[{"name":"sun","age":21}]}
// 也可以在聚合函数之类的函数中使用

In Cypher, null is used to represent missing or undefined values. null is not equal to null. Not knowing two values does not imply that they are the same value. So the expression null = null yields null and not true.

Expressions that return null

• Getting a missing element from a list: [][0], head([])

• Trying to access a property that does not exist on a node or relationship: n.missingProperty

• Comparisons when either side is null: 1 < null

• Arithmetic expressions containing null: 1 + null

• Function calls where any arguments are null: sin(null)

neo4j 学习-2