Cypher語句的分類

讀語句：
- MATCH
- OPTIONAL MATCH
- WHERE
- ~~START（從Cypher3.2開始被廢棄）~~
- Aggregation
- LOAD CSV
寫語句：
- CREATE
- MERGE
- SET
- DELETE
- REMOVE
- FOREACH
- ~~CREATE UNIQUE~~
通用語句：
- RETURN
- ORDER BY
- LIMIT
- SKIP
- WITH
- UNWIND
- UNION
- CALL

MATCH

MATCH語句用指定的模式檢索資料庫。

查詢節點

查詢所有節點

通過指定一個不帶標籤的節點的模式，圖資料庫中所有的節點將返回。
語法：

MATCH (n)
RETURN n;

查詢帶有某個標籤的所有節點

通過指定帶有一個標籤的節點的模式，可以獲取滿足該標籤的所有節點。
語法：

MATCH (<node-name>:<label-name>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>}) 
RETURN 
   <node-name>.<property1-name>,
   ........
   <node-name>.<propertyn-name>

示例：返回圖資料庫中的所有電影名稱

MATCH (movie:Movie)
RETURN movie.title

查詢關聯節點

"--"符號表示相關的，這個關係是不帶型別和方向的。
語法：

//查詢和當前節點有關係的節點，沒有方向性
MATCH (<node-name1>:<label-name1>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})--(<node-name2>:<label-name2>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})

示例：查詢"Lilly Wachowski"相關的所有電影名稱

MATCH({name:"Lilly Wachowski"})--(movie)
RETURN movie.title

示例：查詢"Lilly Wachowski"相關的帶有"Movie"標籤的所有電影名稱

MATCH({name:"Lilly Wachowski"})--(movie:Movie)
RETURN movie.title

查詢關係

有向關係

關係的方向通過“-->”或“<--”來表示。
語法：

MATCH (<node-name1>:<label-name1>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})-->(<node-name2>:<label-name2>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})

MATCH (<node-name1>:<label-name1>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})<--(<node-name2>:<label-name2>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})

示例：查詢"Lilly Wachowski"指向相鄰節點的電影名稱

MATCH({name:"Lilly Wachowski"})-->(movie:Movie)
RETURN movie.title

有向關係和變數

如果需要過濾關係中的屬性，或者返回關係的時候，就需要使用變數。
語法：

MATCH (<node-name1>:<label-name1>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})-[r]->(<node-name2>:<label-name2>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})

示例：返回"Lilly Wachowski"和其相鄰節點的關係型別。

MATCH({name:"Lilly Wachowski"})-[r]->(movie:Movie)
RETURN type(r)

匹配關係型別

當已知匹配關係的型別的時候，可以通過":關係型別"來指定。
語法：

MATCH (<node-name1>:<label-name1>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})-[r:TYPE]->(<node-name2>:<label-name2>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})

示例：返回"The Matrix"中的所有演員的姓名

MATCH (:Movie{title:"The Matrix"})<-[:ACTED_IN]-(actor)
RETURN actor.name

匹配多種關係型別

當需要匹配多種關係中的一種的時候，可以通過"|"將多個關係連線在一起。
語法：

MATCH (<node-name1>:<label-name1>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})-[r:TYPE1|TYPE2]->(<node-name2>:<label-name2>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})

示例：返回和"The Matrix"節點的關係為"ACTED_IN"或"DIRECTED"的人的名稱

MATCH (:Movie{title:"The Matrix"})<-[:ACTED_IN|:DIRECTED]-(person)
RETURN person.name

匹配關係型別和使用關係屬性

語法：

MATCH (<node-name1>:<label-name1>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})-[r:TYPE1|TYPE2]->(<node-name2>:<label-name2>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})
RETURN r.property_name

示例：查詢"The Matrix"電影中所有演員的角色

MATCH (:Movie{title:"The Matrix"})<-[r:ACTED_IN]-(actor)
RETURN r.role

多個關係

多個關係可以使用()--()的形式來表達，或者它們相互連線在一起。
語法：

MATCH (<node-name1>:<label-name1>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})-[r:TYPE1|TYPE2]->(<node-name2>:<label-name2>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})<-[r2:TYPE1|TYPE2]-(<node-name3>:<label-name3>{<property1-name>:<property1-value>,...,<propertyn-name>:<propertyn-value>})
RETURN r.property_name

示例：查詢"Tom Hanks"演過的電影和該電影的導演

MATCH (tom {name:"Tom Hanks"})-[:ACTED_IN]->(movie)<-[:DIRECTED]-(director)
RETURN movie.title,director.name

可變長關係

語法：

-[:TYPE*minHops..maxHops]->

minHops和maxHops都是可選的，預設值分別是1和無窮大。當沒有邊界值的時候，點也可以省略。當只設置了一個邊界的時候，如果點省略了就意味著是一個固定長度的模式。

示例：返回和"Tom Hanks"關係為1跳(hop)和3跳的所有電影

MATCH ({name:"Tom Hanks"})-[:ACTED_IN*1..3]-(movie:Movie)
RETURN movie.title

匹配一簇關係

當模式包含一簇關係的時候，關係模式如果沒有指定方向，Cypher將嘗試匹配兩個方向上的關係。
示例：返回兩個相鄰的節點，一個為開始節點，一個為結束節點

MATCH (a)-[r]-(b)
WHERE id(r)= 0
RETURN a,b

查詢路徑

如果想返回或者需要對路徑進行過濾，可以將路徑賦值給一個變數。
示例：返回和"Tom Hanks"一跳的路徑

MATCH p = (tom {name:"Tom Hanks"})-->()
RETURN p

最短路徑

通過shortestPath函式可以很容易的找到兩個節點之間的最短路徑。
示例：查詢"Tom Hanks"和"Steve Zahn"之間的最短路徑，並且路徑最大長度為15。

MATCH p = shortestPath((tom {name:"Tom Hanks"})-[*1..15]-(steve {name:"Steve Zahn"}))
RETURN p

通過id查詢節點

可以使用id()函式來根據id查詢節點。
示例：將節點id為0的節點返回

MATCH (n)
WHERE id(n) = 0
RETURN n

示例：將關係id為0的關係返回

MATCH ()-[r]-()
WHERE id(r) = 0
RETURN r

示例：查詢多個節點

MATCH (n)
WHERE id(n) in [1,2,3]
RETURN n

OPTIONAL MATCH

OPTIONAL MATCH語句用於搜尋模式中描述的匹配項時，對於找不到的項用null代替。
如果某個關係是可選的，可以使用OPTIONAL MATCH。這個類似於SQL中的outer join的工作方式。如果關係存在就返回，否則在相應的地方返回null。
如果可選元素為null，那麼該元素的屬性也返回null。
可以指定可選的關係型別。
示例：查詢電影"The Matrix"指向的相鄰的節點

OPTIONAL MATCH (a:Movie { title: 'The Matrix' })-->(x)
RETURN x

示例：查詢電影"The Matrix"指向的相鄰的節點的名稱

OPTIONAL MATCH (a:Movie { title: 'The Matrix' })-->(x)
RETURN x,x.name

示例：查詢"The Matrix"電影的演員，沒有就返回null

MATCH (a:Movie { title: 'The Matrix' })
OPTIONAL MATCH (a)<-[r: ACTED_IN]-(b)
RETURN b

WHERE

WHERE在MATCH或者OPTIONAL MATCH語句中新增約束，或者和WITH一起使用來過濾結果。

基本使用

布林運算

可以在WHERE中使用布林運算子符，如AND和OR，以及布林函式NOT。
示例：查詢1990年到2000年發行的電影的名稱

MATCH (movie:Movie)
WHERE movie.released >= 1900 AND movie.released <= 2000
RETURN movie.title

節點標籤的過濾

可以在WHERE中使用類似WHERE n:foo寫入標籤來過濾節點。
示例：查詢帶有":Movie"標籤的節點

MATCH (n:Movie)
RETURN n

MATCH (n)
WHERE n:Movie
RETURN n

節點屬性的過濾

可以在WHERE語句中對節點的屬性進行過濾。
示例：返回釋出時間>1990的":Movie"節點

MATCH (n:Movie)
WHERE n.released > 1990
RETURN n

關係屬性的過濾

可以在WHERE語句中對關係的屬性進行過濾。
示例：查詢以['Bob Hinson']角色名的演員名和電影名

MATCH (actor)-[r:ACTED_IN]->(movie)
WHERE r.roles = ['Bob Hinson']
RETURN actor.name,movie.title,r.roles

屬性存在性檢查

在WHERE語句中使用exists()可以檢查節點或關係的某個屬性是否存在。
示例：返回電影節點（因為只有電影有title屬性）

MATCH (n)
WHERE exists(n.title)
RETURN n

字串匹配

匹配字串開始

在WHERE語句中使用STARTS WITH用於大小寫敏感的方式匹配字串的開始。
示例：返回以名字以"Tom"開始的人的資訊

MATCH (n)
WHERE n.name STARTS WITH 'Tom'
RETURN n

匹配字串結尾

在WHERE語句中使用ENDS WITH用於大小寫敏感的方式匹配字串的結尾。
示例：返回以名字以"Hanks"結尾的人的資訊

MATCH (n)
WHERE n.name ENDS WITH 'Hanks'
RETURN n

字串包含

在WHERE語句中使用CONTAINS用於以大小寫敏感的方式檢查字串中是否包含某個字串。
示例：返回名字中包含"bin"的人的資訊

MATCH (n)
WHERE n.name CONTAINS 'bin'
RETURN n

字串反向匹配

在WHERE中可以使用NOT關鍵字返回不滿足給定字串匹配的結果。
示例：返回姓名中不以"s"結尾的人的資訊

MATCH (n)
WHERE NOT n.name ENDS WITH 's'
RETURN n

正則表示式

在WHERE語句中可以=~ ’正則表示式‘來進行正則表示式的匹配。

匹配字串開始

在WHERE語句中使用=~ ’字串.*‘的方式來匹配字串的開始。
示例：查詢以"Tom"開頭的人的資訊

MATCH (n)
WHERE n.name =~ 'Tom.*'
RETURN n

正則表示式的非大小寫敏感

在正則表示式前面加入(?i)之後，整個正則表示式將變成非大小寫敏感。
示例：返回姓名以"Tom"開頭的人的資訊，要求字串不敏感

MATCH (n)
WHERE n.name =~ '(?i)Tom.*'
RETURN n

在WHERE中使用路徑模式

模式過濾

示例：返回"Kevin Bacon"參演過的電影

MATCH (n {name:"Kevin Bacon"}),(m)
WHERE (n)-[:ACTED_IN]->(m)
RETURN n.name,m.title

模式中NOT過濾

示例：返回"Kevin Bacon"沒有參演過的電影

MATCH (n {name:"Kevin Bacon"}),(m)
WHERE NOT (n)-[:ACTED_IN]->(m)
RETURN n.name,m.title

模式中的屬性過濾

示例：返回參演"Apollo 13"電影的所有演員

MATCH (n)
WHERE (n)-[:ACTED_IN]->({title:"Apollo 13"})
RETURN n

關係型別過濾

可以在MATCH模式中新增關係型別，但是有時候希望在型別過濾上具有豐富的功能。這個時候，可以將型別和其他的（比如正則表示式）進行比較。
示例：返回所有的導演資訊

MATCH (n)-[r]->()
WHERE type(r) =~ 'DIRE.*'
RETURN n

列表

檢查列表中是否存在某個元素的時候，可以使用IN運算子。
示例：返回'Keanu Reeves'、'Lana Wachowski'和'Hugo Weaving'的資訊

MATCH (n)
WHERE n.name IN ['Keanu Reeves','Lana Wachowski','Hugo Weaving']  
RETURN n

使用範圍

示例：查詢釋出時間>=1900的電影資訊

MATCH (n)
WHERE n.released >= 1990
RETURN n

示例：查詢釋出時間再1900年到2000年的電影資訊

MATCH (n)
WHERE n.released >= 1990 AND n.released <= 2000
RETURN n

RETURN

RETURN語句定義了查詢結果集中返回的內容。

返回節點

示例：返回包含name屬性值為“Steve Zahn”的節點

MATCH (n {name:"Steve Zahn"})
RETURN n

返回關係

示例：返回name屬性值為"Steve Zahn"節點，並且關係的型別是":ACTED_IN"的關係

MATCH (n {name:"Steve Zahn"})-[r:ACTED_IN]->(m)
RETURN r

返回屬性

示例：返回name屬性值為"Steve Zahn"的屬性值

MATCH (n {name:"Steve Zahn"})
RETURN n.name

返回所有元素

示例：返回name屬性值為"Steve Zahn"的所有節點、關係和路徑，可以使用*表示

MATCH p = (n {name:"Steve Zahn"})-[r]->(m)
RETURN *

變數名中的特殊字元

可以使用空格等特殊字元作為變數名，但是需要使用反引號``括起來。
示例：

MATCH (`This is a common variable`)
WHERE  `This is a common variable`.name = 'Steve Zahn'                         
RETURN `This is a common variable`

列別名

如果希望列名不同於表示式中使用的名字，可以使用AS 別名的方式。
示例：

MATCH (a { name: 'Steve Zahn' })
RETURN a.born AS bornYear

可選屬性

如果某個屬性可能存在，也可能不存在。對於不存在的值，Cypher返回null。
示例：

MATCH (n)
RETURN n.title

其他表示式

任何表示式都可以作為返回項。如字面值、斷言、屬性和函式以及其他任何表示式。
示例：

MATCH (a { name: 'Steve Zahn' })
RETURN a.born > 1960, "I'm a literal",(a)-->()

去重

可以使用DISTINCT來去重。
示例：

MATCH (n)
WHERE NOT n.name IS  NULL       
RETURN DISTINCT n.name

CREATE

CREATE語句用於建立圖元素：節點、關係和索引。

建立節點

示例：建立單個節點

CREATE (n)

示例：建立多個節點

CREATE (n),(m)

示例：建立帶有標籤的節點

CREATE (n:Person)

示例：建立帶有多個標籤的節點

CREATE (n:Person:Teacher)

示例：建立同時帶有標籤和屬性的節點

CREATE (n:Person { name: "Andres", title: "Developer" })

示例：返回建立的節點

CREATE (n { name: "Andres" })
RETURN n

建立關係

建立兩個節點之間的關係

CREATE (n:Person {name: "Node A"}),(m:Person {name: "Node B"})

MATCH (a:Person),(b:Person)
WHERE a.name = 'Node A' AND b.name = 'Node B'
CREATE (a)-[r:RELTYPE]->(b)
RETURN r

建立關係並設定屬性

CREATE (n:Person {name: "Node A"}),(m:Person {name: "Node B"})

MATCH (a:Person),(b:Person)
WHERE a.name = 'Node A' AND b.name = 'Node B'
CREATE (a)-[r:RELTYPE { name: 'abc' }]->(b)
RETURN r

建立一個完整路徑

當使用CREATE和模式的時候，模式中所有不存在的部分都會被建立。
示例：

CREATE p =(andress { name:'Andres' })-[:WORKS_AT]->(neo)<-[:WORKS_AT]-(michael { name: 'Michael' })
RETURN p

建立索引

示例：

CREATE INDEX ON :Person(name)

MERGE

MERGE先去圖資料庫中查詢模式，如果模式不存在，就建立。

MERGE節點

示例：判斷資料庫中是否存在含有Ctritic標籤的節點，如果不存在就建立這個節點

MERGE (robert:Critic)
RETURN robert, labels(robert)

示例：判斷資料庫中是否存在name屬性值為"Charlie Sheen"並且age屬性值為10的節點，如果不存在就建立這個節點

MERGE (n {name:"Charlie Sheen",age:10})
RETURN n

示例：判斷資料庫中是否存在":Person"標籤的name屬性值為"Michael Douglas"以及bornIn屬性值為"newyork"的節點，如果不存在就建立這個節點

MERGE (n:Person {name:"Michael Douglas",bornIn:"newyork"})
RETURN n

示例：
①判斷資料庫中是否存在":Person"標籤的name屬性值為"riky"以及bornIn屬性值為"newyork"的節點，如果不存在就建立這個節點

MERGE (n:Person {name:"riky",bornIn:"newyork"})
RETURN n

②判斷資料庫是否存在"City"標籤的name屬性值是剛才建立的節點的bornIn的屬性值的節點，如果不存在就建立這個節點

MATCH (person:Person{ bornIn:'newyork'})
MERGE (city:City { name: person.bornIn })
RETURN person.name, person.bornIn, city

MERGE在CREATE和MATCH中使用

示例：判斷節點name屬性值為"Keanu Reeves"的節點是否存在，如果不存在，在建立的時候設定created的屬性值為當前的時間戳

MERGE (keanu:Person { name: 'Keanu Reeves' })
ON CREATE SET keanu.created= timestamp()
RETURN keanu.name,keanu.created

示例：判斷節點name屬性值為"Keanu Reeves"的節點是否存在，如果存在，在查詢的時候在節點上設定屬性found的屬性值為true

MERGE (person:Person { name: 'Keanu Reeves2' })
ON MATCH SET person.found = TRUE 
RETURN person.name, person.found

示例：檢查節點是否存在，如果不存在則建立它並設定屬性

MERGE (keanu:Person { name: 'Keanu Reeves' })
ON CREATE SET keanu.created = timestamp()
ON MATCH SET keanu.lastSeen = timestamp()
RETURN keanu.name, keanu.created, keanu.lastSeen

示例：檢查節點是否存在，如果存在設定多個屬性和屬性值

MERGE (person:Person)
ON MATCH SET person.found = TRUE , person.lastAccessed = timestamp()
RETURN person.name, person.found, person.lastAccessed

MERGE關係

示例：查詢"Keanu Reeves"演員和"The Matrix"電影，同時設定關係（Keanu Reeves已經參演了The Matrix，所以直接返回關係）。

MATCH (charlie:Person { name: 'Carrie-Anne Moss' }),(wallStreet:Movie { title: 'The Matrix' }) 
MERGE (charlie)-[r:ACTED_IN]->(wallStreet)
RETURN charlie.name, type(r), wallStreet.title

示例：合併多個關係

MATCH (oliver:Person {name: 'Lilly Wachowski'}), (reiner:Person {name: 'Rob Reiner'})
MERGE (oliver)-[:DIRECTED]->(movie:Movie)<-[:ACTED_IN]-(reiner)
RETURN movie

示例：

//建立name屬性值是"riky"的節點
CREATE (person:Person { name: 'riky',bornIn:"New York" })

MATCH (person:Person { name: 'riky',bornIn:"New York" })
MERGE (city:City { name: person.bornIn })
MERGE (person)-[r:BORN_IN]->(city)
RETURN person.name, person.bornIn, city;

示例：MERGE能同時建立一個新節點和關係

MATCH (person:Person { name: 'riky',bornIn:"New York" })
MERGE (person)-[r:master]-(cat:Cat{name:"tom"})
RETURN person.name,type(r),cat.name

用MERGE的唯一性約束

示例：
建立唯一性約束：

CREATE CONSTRAINT ON (n:Person) ASSERT n.name IS UNIQUE;

如果節點沒有找到，使用唯一性約束來建立該節點

MERGE (laurence:Person { name: 'Laurence Fishburne' })
RETURN laurence.name

SET

SET語句用於更新節點的標籤以及節點和關係的屬性。

設定屬性

示例：設定節點或關係的屬性

MERGE (n { name: ' Taylor Hackford' })
SET n.username = 'Taylor'
RETURN n

刪除屬性

示例：通常使用REMOVE來刪除一個屬性，但是也可以使用SET將屬性設定為null的方式來刪除屬性

MERGE (n { name: ' Taylor Hackford' })
SET n.name = null
RETURN n

在節點直接複製屬性

示例：將一個節點的屬性複製給另一個節點的屬性

MERGE (a{name:"aaa",age:10,gender:"女"})
MERGE (b{name:"bbb",gender:"男"})          
SET a.gender=b.gender
RETURN a,b

新增屬性

示例：可以在SET中使用"+="的形式來新增屬性，而不刪除元素中已經存在的屬性

MERGE (peter { name: 'Peter' })
SET peter += { hungry: TRUE , position: 'Entrepreneur' }
RETURN peter

設定多個屬性

示例：可以一次設定多個屬性，使用逗號,隔開即可

MERGE (peter { name: 'Peter' })
SET peter.age = 15,peter.gender='男'
RETURN peter

設定節點的標籤

示例：

MERGE (n { name: 'Stefan' })
SET n :German
RETURN n

給一個節點設定多個標籤

示例：

MATCH (n { name: 'Emil' })
SET n :Swedish:Bossman
RETURN n

DELETE

DELETE語句用於刪除圖元素--節點、關係和路徑。

刪除單個節點

示例：

CREATE (n:Useless)
RETURN n

MATCH (n:Useless)
DELETE n

刪除關係

示例：

CREATE (A {name:"A"})-[r:Type]->(B {name:"B"})
RETURN A,r,B

MATCH (A {name:"A"})-[r:Type]->(B {name:"B"})
DELETE r

刪除路徑

將查到路徑上的節點、屬性和關係全部刪除。
示例：

CREATE (d { name: 'Node D' }),(e { name: 'Node e' })
CREATE (d)-[r:x]->(e)
RETURN d,e

MATCH p=(d { name: 'Node D' })--(e { name: 'Node e' })
DELETE p

刪除一個節點及其所有的關係

一般而言，需要先刪除節點所關聯的所有關係，然後才能刪除該節點。
但是，可以使用DETACH DELETE刪除一個節點及其所有關係。
示例：

CREATE (A {name:"A"})-[r:Type]->(B {name:"B"})
RETURN A,r,B

MATCH (A {name:"A"})
DETACH DELETE A

刪除所有節點及其所有關係

示例：

MATCH (n)
DETACH DELETE n

REMOVE

REMOVE語句用於刪除圖元素的屬性和標籤。

刪除一個屬性

Neo4j不允許屬性儲存為null。如果屬性的值不存在，那麼節點或關係中的屬性將被刪除。也可以通過REMOVE來刪除。
示例：

CREATE (p { name: 'Michael Douglas',age:10 })
RETURN p

MATCH (p { name: 'Michael Douglas',age:10 })
REMOVE p.age
RETURN p

刪除節點的一個標籤

示例：

CREATE (p:Person { name: 'Michael Douglas',age:10 })
RETURN p

MATCH (p:Person { name: 'Michael Douglas',age:10 })
REMOVE p:Person
RETURN p

刪除節點的多個標籤

示例：

CREATE (p :Person:Actor:Father { name: 'Michael Douglas',age:10 })
RETURN p

MATCH (p :Person:Actor:Father { name: 'Michael Douglas',age:10 })
REMOVE p :Person:Actor                              
RETURN p

ORDER BY

ORDER BY是緊跟RETURN或者WITH的字句的，它指定了輸出的結果應該如何排序。
ORDER BY是根據屬性進行排序的。

根據屬性對節點進行排序

示例：根據節點的name屬性值進行排序，預設是升序

MATCH (n)
RETURN n.name
ORDER BY n.name

根據多個屬性對節點進行排序

ORDER BY語句支援根據多個屬性對節點進行排序。先根據第一個變數進行排序，對於相等的值，然後再檢查ORDER BY中的下一個屬性的值
示例：根據節點的born和name屬性值進行排序

MATCH (n)
RETURN n.name,n.born
ORDER BY n.name,n.born

節點降序排序

預設是升序排序，如果需要降序，直接新增DESC。
示例：對節點的name屬性值進行降序排序

MATCH (n)
RETURN n.name
ORDER BY n.name DESC

空值的排序

當結果集中包含null值得時候，對於升序排序，null總在結果集的末尾；而對於降序排序，null值總是排在最前面。
示例：對節點的title屬性進行排序

MATCH (n)
RETURN n.title
ORDER BY n.title

LIMIT

LIMIT語句限制輸出的行數。

返回開始部分

示例：對節點的name屬性進行排序，返回前3條資料

MATCH (n)
RETURN n
ORDER BY n.name
LIMIT 3

SKIP

SKIP語句定義了從哪行開始返回結果集，即意味著前面的記錄全部丟棄，不顯示。

跳過前面三個

示例：從第四個開始返回

MATCH (n)
RETURN n
ORDER BY n
SKIP 3

分頁顯示

示例：

MATCH (n)
RETURN n
ORDER BY n
SKIP 0 LIMIT 10

WITH

WITH語句將分段的查詢部分連線在一起，查詢結果從一部分以管道形式傳遞給另外一部分作為開始點。
使用WITH可以在將結果傳遞到後續查詢之前對結果進行操作。操作可以是改變結果的形式或數量。WITH的一個常見用法就是限制給其他MATCH語句的結果樹。通過結合ORDER BY和LIMIT，可以獲取排在前面的X個結果。
另一個結果就是在聚合值上進行過濾。

過濾聚合函式結果

聚合的結果必須要通過WITH語句傳遞才能進行過濾。
示例：

MATCH (david { name: 'Tom Hanks' })--()--(otherPerson)
WITH otherPerson, count(*) AS foaf
WHERE foaf > 1
RETURN otherPerson

在collect前對結果進行排序

可以在將結果傳遞給collect函式之前對結果進行排序，這樣就可以返回排過序的列表。
示例：

MATCH (n)
WITH n
ORDER BY n.name DESC LIMIT 3
RETURN collect(n.name)

限制路徑搜尋的分支

可以限制匹配路徑的數量，然後以這些路徑為基礎再做任何類似的有限制條件的搜尋。
示例：

MATCH (n { name: 'Tom Hanks' })--(m)
WITH m
ORDER BY m.name DESC LIMIT 1
MATCH (m)--(o)
RETURN o.name

FOREACH

FOREACH語句用於迴圈遍歷結果集列表，然後做一些操作。
列表和路徑和Cypher中的關鍵概念。可以使用FOREACH來更新其中的資料。它可以在路徑或者聚合的列表的每個元素執行更新的命令。FOREACH括號中的變數是和外部分開的。這意味著FOREACH中建立的變數不能用於該語句之外。
在FOREACH括號內，可以執行任何的更新命令，包括CREATE、DELETE和FOREACH。如果希望對列表中的每個元素指定額外的MATCH命令，使用UNWIND命令更合適。

獲取路徑上的所有節點

示例：將查詢到的路徑上的所有節點的marked屬性這是為true值

MATCH p = (root {name:"root"})-[r]-(A)
FOREACH (n IN nodes(p) | SET n.marked = TRUE)

從列表中建立朋友

示例：

MATCH (a {name:"root"})
FOREACH (name IN ["Tom","Jerry","Aliao"] | CREATE (a)-[:FRIEND]->(:Person{name :name}))

Aggregation

Cypher支援使用聚合(Aggregation)來計算聚在一起的資料。聚合函式有多個輸入值，然後基於它們計算出一個聚合值。

Count

示例：返回標籤為":Person"的節點的數量

MATCH (n:Person)
RETURN COUNT(n)

示例：返回"Tom Hanks "和與之相鄰節點的數量

MATCH (n{name:"Tom Hanks"})-[r]->()
RETURN type(r),count(r)

示例：可以通過count()來計算非空值的數量

MATCH (n)
RETURN count(n.title)

統計

準備工作

CREATE (A :Person{name: 'A', property:13 }),(B :Person { name: 'B', property:33,eyes: 'blue' }),(C:Person { name: 'C', property:44,eyes: 'blue' }),(D:Person { name: 'D', eyes: 'blue' })
return A,B,C,D

示例：返回含有":Person"標籤節點的property屬性值的和

MATCH (n:Person)
RETURN SUM(n.property)

示例：返回含有":Person"標籤節點的property屬性值的平均值

MATCH (n:Person)
RETURN AVG(n.property)

示例：返回含有":Person"標籤節點的property屬性值中的最大值

MATCH (n:Person)
RETURN MAX(n.property)

示例：返回含有":Person"標籤節點的property屬性值中的最小值

MATCH (n:Person)
RETURN MIN(n.property)

collect

collect將所有的值收集起來放入一個列表。null將被忽略。
示例：以列表的形式將含有":Person"標籤節點的property屬性值返回

MATCH (n:Person)
RETURN collect(n.property)

DISINTCT

所有的聚合函式都可以帶有DISTINCT修飾符，它將去掉其中的重複值。
示例：返回眼睛顏色的個數

MATCH (n)
RETURN count(DISTINCT n.eyes)

UNWIND

UNWIND將一個列表展開為一個行的序列（行轉列）。

UNWIND列表

示例：將一個常量列表轉為名為x的行並返回

UNWIND [1,2,3] AS x
RETURN x

建立唯一列表

示例：使用DISTINCT將一個重複值列表轉為一個集合

WITH [1,1,2,2] AS coll
UNWIND coll AS x
WITH DISTINCT x
RETURN collect(x)

UNION

UNION語句用於將多個查詢結果組合起來。

組合兩個查詢

示例：用UNION ALL將兩個查詢結果組合在一起

//返回了組合的結果，包含重複行
MATCH (n:Actor)
RETURN n.name AS name
UNION ALL 
MATCH (n:Movie)
RETURN n.title AS name

組合兩個查詢並移除重複值

示例：在UNION中不使用ALL時，組合的結果集中去掉重複值

MATCH (n:Actor)
RETURN n.name AS name
UNION
MATCH (n:Movie)
RETURN n.title AS name

CALL

CALL語句用於呼叫資料庫中的過程。

呼叫過程

示例：本例呼叫資料庫內嵌的過程db.labels，它可以列出資料庫中的所有標籤

CALL db.labels

使用名稱空間和名字呼叫過程

會理：本例呼叫資料庫內嵌的過程db.labels，它可以列出資料庫中的所有標籤

CALL `db`.`labels`

使用字面值引數呼叫過程

示例：下面使用字面值引數呼叫了例子中的過程org.neo4j.procedure.example.addNodeToIndex，如引數直接寫在語句中

CALL org.neo4j.procedure.example.addNodeToIndex('users', 0, 'name')

在複雜查詢中呼叫過程

示例：呼叫資料庫內嵌的過程db.labels計算資料庫中的總標籤數

CALL db.labels() YIELD label
RETURN count(label) AS numLabels

在複雜查詢中呼叫過程並重命名結果

示例：呼叫內嵌過程db.propertyKeys作為一部分，計算資料庫中包含每個屬性鍵的節點數

CALL db.propertyKeys() YIELD propertyKey AS prop
MATCH (n)
WHERE n[prop] IS NOT NULL 
RETURN prop, count(n) AS numNodes

LOAD CSV

且聽下回分解。

Go的100天之旅-06陣列和Slice

Cypher語句的分類

MATCH

查詢節點

查詢所有節點

查詢帶有某個標籤的所有節點

查詢關聯節點

查詢關係

有向關係

有向關係和變數

匹配關係型別

匹配多種關係型別

匹配關係型別和使用關係屬性

多個關係

可變長關係

匹配一簇關係

查詢路徑

最短路徑

通過id查詢節點

OPTIONAL MATCH

WHERE

基本使用

布林運算

節點標籤的過濾

節點屬性的過濾

關係屬性的過濾

屬性存在性檢查

字串匹配

匹配字串開始

匹配字串結尾

字串包含

字串反向匹配

正則表示式

匹配字串開始

正則表示式的非大小寫敏感

在WHERE中使用路徑模式

模式過濾

模式中NOT過濾

模式中的屬性過濾

關係型別過濾

列表

使用範圍

RETURN

返回節點

返回關係

返回屬性

返回所有元素

變數名中的特殊字元

列別名

可選屬性

其他表示式

去重

CREATE

建立節點

建立關係

建立一個完整路徑

建立索引

MERGE

MERGE節點

MERGE在CREATE和MATCH中使用

MERGE關係

用MERGE的唯一性約束

SET

設定屬性

刪除屬性

在節點直接複製屬性

新增屬性

設定多個屬性

設定節點的標籤

給一個節點設定多個標籤

DELETE

刪除單個節點

刪除關係

刪除路徑

刪除一個節點及其所有的關係

刪除所有節點及其所有關係

REMOVE

刪除一個屬性

刪除節點的一個標籤

刪除節點的多個標籤