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