Neo4j Cypher查詢語言詳解

轉自：http://www.ttlsa.com/nosql/how-to-neo4j-cypher-query-language/

Cypher介紹

「Cypher」是一個描述性的圖形查詢語言，容許沒必要編寫圖形結構的遍歷代碼對圖形存儲有表現力和效率的查詢。Cypher還在繼續發展和成熟，這也就意味着有可能會出現語法的變化。同時也意味着做爲組件沒有經歷嚴格的性能測試。

Cypher設計的目的是一我的類查詢語言，適合於開發者和在數據庫上作點對點模式（ad-hoc）查詢的專業操做人員（我認爲這個很重要）。它的構念是基於英語單詞和靈巧的圖解。

Cyper經過一系列不一樣的方法和創建於肯定的實踐爲表達查詢而激發的。許多關鍵字如like和order by是受SQL的啓發。模式匹配的表達式來自於SPARQL。正則表達式匹配實現實用Scala programming language語言。

Cypher是一個申明式的語言。對比命令式語言如Java和腳本語言如Gremlin和JRuby，它的焦點在於從圖中如何找回（what to retrieve），而不是怎麼去作。這使得在不對用戶公佈的實現細節裏關心的是怎麼優化查詢。

這個查詢語言包含如下幾個明顯的部分：

• START：在圖中的開始點，經過元素的ID或因此查找得到。

• MATCH：圖形的匹配模式，束縛於開始點。

• WHERE：過濾條件。

• RETURN：返回所須要的。

在下例中看三個關鍵字

示例圖片以下：

如：這個有個查詢，經過遍歷圖找到索引裏一個叫John的朋友的朋友（不是他的直接朋友），返回John和找到的朋友的朋友。

START john=node:node_auto_index(name = 'John')

MATCH john-[:friend]->()-[:friend]->fof

RETURN john, fof

返回結果：

下一步添加過濾：

在下一個例子中，列出一組用戶的id並遍歷圖查找這些用戶接出friend關係線，返回有屬性name而且其值是以S開始的用戶。

START user=node(5,4,1,2,3)

MATCH user-[:friend]->follower

WHERE follower.name =~ /S.*/

RETURN user, follower.name

返回結果：

操做符

Cypher中的操做符有三個不一樣種類：數學，相等和關係。

數學操做符有+，-，*，/和%。固然只有+對字符有做用。

等於操做符有=，<>，<，>，<=，>=。

由於Neo4j是一個模式少的圖形數據庫，Cypher有兩個特殊的操做符?和!。

有些是用在屬性上，有些事用於處理缺乏值。對於一個不存在的屬性作比較會致使錯誤。爲替代與其餘什麼作比較時老是檢查屬性是否存在，在缺失屬性時問號將使得比較老是返回true，感嘆號使得比較老是返回false。

WHEREn.prop? = "foo"

這個斷言在屬性缺失狀況下將評估爲true。

WHEREn.prop! = "foo"

這個斷言在屬性缺失狀況下將評估爲false。

警告：在同一個比較中混合使用兩個符號將致使不可預料的結果。

參數

Cypher支持帶參數的查詢。這容許開發者不須要必須構建一個string的查詢，而且使得Cypher的查詢計劃的緩存更容易。

參數能夠在where子句，start子句的索引key或索引值，索引查詢中做爲節點/關係id的引用。

如下是幾個在java中使用參數的示例：

節點id參數

Map<String, Object> params = new HashMap<String, Object>();

params.put( "id", 0 );

ExecutionResult result = engine.execute( "start n=node({id}) return n.name", params );

節點對象參數

Map<String, Object> params = new HashMap<String, Object>();

params.put( "node", andreasNode );

ExecutionResult result = engine.execute( "start n=node({node}) return n.name", params );

多節點id參數

Map<String, Object> params = new HashMap<String, Object>();

params.put( "id", Arrays.asList( 0, 1, 2 ) );

ExecutionResult result = engine.execute( "start n=node({id}) return n.name", params );

字符串參數

Map<String, Object> params = new HashMap<String, Object>();

params.put( "name", "Johan" );

ExecutionResult result = engine.execute( "start n=node(0,1,2) where n.name = {name} return n", params );

索引鍵值參數

Map<String, Object> params = new HashMap<String, Object>();

params.put( "key", "name" );

params.put( "value", "Michaela" );

ExecutionResult result = engine.execute( "start n=node:people({key} = {value}) return n", params );

索引查詢參數

Map<String, Object> params = new HashMap<String, Object>();

params.put( "query", "name:Andreas" );

ExecutionResult result = engine.execute( "start n=node:people({query}) return n", params );

• SKIP 與LIMIT * 的數字參數

Map<String, Object> params = new HashMap<String, Object>();

params.put( "s", 1 );

params.put( "l", 1 );

ExecutionResult result = engine.execute( "start n=node(0,1,2) return n.name skip {s} limit {l}", params );

• 正則表達式參數

Map<String, Object> params = new HashMap<String, Object>();

params.put( "regex", ".*h.*" );

ExecutionResult result = engine.execute( "start n=node(0,1,2) where n.name =~ {regex} return n.name", params );

標識符

當你參考部分的模式時，須要經過命名完成。定義的不一樣的命名部分就被稱爲標識符。

以下例中：

START n=node(1) MATCH n-->b RETURN b

標識符爲n和b。

標識符能夠是大寫或小些，能夠包含下劃線。當須要其餘字符時可使用符號。對於屬性名的規則也是同樣。

註解

能夠在查詢語句中使用雙斜槓來添加註解。如：

START n=node(1) RETURN b //這是行結束註釋

START n=node(1) RETURN b

START n=node(1) WHERE n.property = "//這部是一個註釋" RETURN b

Start

每個查詢都是描述一個圖案（模式），在這個圖案（模式）中能夠有多個限制點。一個限制點是爲模式匹配的從開始點出發的一條關係或一個節點。能夠經過id或索引查詢綁定點。

經過id綁定點

經過node(*)函數綁定一個節點做爲開始點

查詢：

START n=node(1)

RETURN n

返回引用的節點。

結果：

經過id綁定關係

能夠經過relationship()函數綁定一個關係做爲開始點。也能夠經過縮寫rel()。

查詢：

START r=relationship(0)

RETURN r

Id爲0的關係將被返回

結果：

經過id綁定多個節點

選擇多個節點能夠經過逗號分開。

查詢：

START n=node(1, 2, 3)

RETURN n

結果：

全部節點

獲得全部節點能夠經過星號（*），一樣對於關係也適用。

查詢：

START n=node(*)

RETURN n

這個查詢將返回圖中全部節點。

結果：

經過索引查詢獲取節點

若是開始節點能夠經過索引查詢獲得，能夠如此來寫：

node:index-name(key=」value」)。在此列子中存在一個節點索引叫nodes。

查詢：

START n=node:nodes(name = "A")

RETURN n

索引中命名爲A的節點將被返回。

結果：

經過索引查詢獲取關係

若是開始點能夠經過索引查詢獲得，能夠如此作：

Relationship:index-name(key=」value」)。

查詢：

START r=relationship:rels(property ="some_value")

RETURN r

索引中屬性名爲」some_value」的關係將被返回。

結果：

多個開始點

有時須要綁定多個開始點。只須要列出並以逗號分隔開。

查詢：

START a=node(1), b=node(2)

RETURN a,b

A和B兩個節點都將被返回。

結果：

Match

在一個查詢的匹配（match）部分申明圖形（模式）。模式的申明致使一個或多個以逗號隔開的路徑（path）。

節點標識符可使用或者不是用圓括號。使用圓括號與不使用圓括號徹底對等，如：

MATCH(a)-->(b) 與 MATCH a-->b 匹配模式徹底相同。

模式的全部部分都直接或者間接地綁定到開始點上。可選關係是一個可選描述模式的方法，但在真正圖中可能沒有匹配（節點可能沒有或者沒有此類關係時），將被估值爲null。與SQL中的外聯結相似，若是Cypher發現一個或者多個匹配，將會所有返回。若是沒有匹配，Cypher將返回null。

如如下例子，b和p都是可選的病均可能包含null：

START a=node(1) MATCH p = a-[?]->b

START a=node(1) MATCH p = a-[*?]->b

START a=node(1) MATCH p = a-[?]->x-->b

START a=node(1), x=node(100) MATCH p = shortestPath( a-[*?]->x )

相關節點

符號—意味着相關性，不須要關心方向和類型。

查詢：

START n=node(3)

MATCH (n)--(x)

RETURN x

全部與A相關節點都被返回。

結果：

接出關係（Outgong relationship）

當對關係的方向感興趣時，可使用-->或<--符號，如：

查詢：

START n=node(3)

MATCH (n)-->(x)

RETURN x

全部A的接出關係到達的節點將被返回.

結果：

定向關係和標識符

若是須要關係的標識符，爲了過濾關係的屬性或爲了返回關係，可以下例使用標識符。

查詢：

START n=node(3)

MATCH (n)-[r]->()

RETURN r

全部從節點A接出的關係將被返回。

結果：

經過關係類型匹配

當已知關係類型並想經過關係類型匹配時，能夠經過冒號詳細描述。

查詢：

START n=node(3)

MATCH (n)-[:BLOCKS]->(x)

RETURN x

返回A接出關係類型爲BLOCKS的節點。

結果：

經過關係類型匹配和使用標識符

若是既想得到關係又要經過已知的關係類型，那就都添加上，如：

查詢：

START n=node(3)

MATCH (n)-[r:BLOCKS]->()

RETURN r

全部從A接出的關係爲BLOCKS的關係都被返回。

結果：

帶有特殊字符的關係類型

有時候數據庫中有非字母字符類型，或有空格在內時，使用單引號。

查詢：

START n=node(3)

MATCH (n)-[r:TYPE WITH SPACE IN IT]->()

RETURN r

返回類型有空格的關係。

結果：

多重關係

關係能夠經過使用在()—()多個語句來表達，或能夠串在一塊兒。以下：

查詢:

START a=node(3)

MATCH (a)-[:KNOWS]->(b)-[:KNOWS]->(c)

RETURN a,b,c

路徑中的三個節點。

結果：

可變長度的關係

可變數量的關係->節點可使用-[:TYPE*minHops..maxHops]->。

查詢：

START a=node(3), x=node(2, 4)

MATCH a-[:KNOWS*1..3]->x

RETURN a,x

若是在1到3的關係中存在路徑，將返回開始點和結束點。

結果：

在可變長度關係的關係標識符

當鏈接兩個節點的長度是可變的不肯定的時，可使用一個關係標識符遍歷全部關係。

查詢：

START a=node(3), x=node(2, 4)

MATCH a-[r:KNOWS*1..3]->x

RETURN r

若是在1到3的關係中存在路徑，將返回開始點和結束點。

結果：

零長度路徑

當使用可變長度路徑，可能其路徑長度爲0，這也就是說兩個標識符指向的爲同一個節點。若是兩點間的距離爲0，能夠肯定這是同一個節點。

查詢：

START a=node(3)

MATCH p1=a-[:KNOWS*0..1]->b, p2=b-[:BLOCKS*0..1]->c

RETURN a,b,c, length(p1), length(p2)

這個查詢將返回四個路徑，其中有些路徑長度爲0.

結果：

可選關係

若是關係爲可選的，可使用問號表示。與SQL的外鏈接相似。若是關係存在，將被返回。若是不存在在其位置將以null代替。

查詢：

START a=node(2)

MATCH a-[?]->x

RETURN a,x

返回一個節點和一個null，由於這個節點沒有關係。

結果：

可選類型和命名關係

經過一個正常的關係，能夠決定哪一個標識符能夠進入，那些關係類型是須要的。

查詢：

START a=node(3)

MATCH a-[r?:LOVES]->()

RETURN a,r

返回一個節點和一個null，由於這個節點沒有關係。

結果：

可選元素的屬性

返回可選元素上的屬性，null值將返回null。

查詢：

START a=node(2)

MATCH a-[?]->x

RETURN x, x.name

元素x在查詢中爲null，全部其屬性name爲null。

結果：

複雜匹配

在Cypher中，可喲經過更多複雜模式來匹配，像一個鑽石形狀模式。

查詢：

START a=node(3)

MATCH (a)-[:KNOWS]->(b)-[:KNOWS]->(c),(a)-[:BLOCKS]-(d)-[:KNOWS]-(c)

RETURN a,b,c,d

路徑中的四個節點。

結果：

最短路徑

使用shortestPath函數能夠找出一條兩個節點間的最短路徑，以下。

查詢：

START d=node(1), e=node(2)

MATCH p = shortestPath( d-[*..15]->e )

RETURN p

這意味着：找出兩點間的一條最短路徑，最大關係長度爲15.圓括號內是一個簡單的路徑鏈接，開始節點，鏈接關係和結束節點。關係的字符描述像關係類型，最大數和方向在尋找最短路徑中都將被用到。也能夠標識路徑爲可選。

結果：

全部最但路徑

找出兩節點節點全部的最短路徑。

查詢：

START d=node(1), e=node(2)

MATCH p = allShortestPaths( d-[*..15]->e )

RETURN p

這將在節點d與e中找到兩條有方向的路徑。

結果：

命名路徑

若是想在模式圖上的路徑進行過濾或者返回此路徑，可使用命名路徑（named path）。

查詢：

START a=node(3)

MATCH p = a-->b

RETURN p

開始節點的兩個路徑。

結果：

在綁定關係上的匹配

當模式中包含一個綁定關係時，此關係模式沒有明確的方向，Cypher將嘗試着切換鏈接節點的邊匹配關係。

查詢：

START a=node(3), b=node(2)

MATCH a-[?:KNOWS]-x-[?:KNOWS]-b

RETURN x

將返回兩個鏈接節點，一次爲開始節點，一次爲結束節點。

結果：

Where

若是須要從查找的數據的圖中過濾，能夠在查詢語句中添加where子句。圖：

Boolean 操做類型

可使用boolean操做符and 和 or 或者也可使用not（）函數。

查詢：

START n=node(3, 1)

WHERE (n.age < 30 and n.name = "Tobias") ornot(n.name = "Tobias")

RETURN n

返回節點。

結果：

節點屬性上的過濾

查詢：

START n=node(3, 1)

WHERE n.age < 30

RETURN n

結果：

正則表達式

能夠經過使用=~ /regexp/來匹配正在表達式。以下：

查詢：

START n=node(3, 1)

WHERE n.name =~ /Tob.*/

RETURN n

返回名叫Tobias的節點。

結果：

 

轉義正則表達式

若是在正則表達式中須要有斜槓時能夠經過轉義實現。

查詢：

START n=node(3, 1)

WHERE n.name =~ /Some\/thing/

RETURN n

沒有匹配的節點返回。

結果：

不分大小些正則表達式

在正則表達式前加上?i，整個正則表達式將會忽略大小寫。

查詢：

START n=node(3, 1)

WHERE n.name =~ /(?i)ANDR.*/

RETURN n

屬性name爲Andres的節點將返回

結果：

 

關係類型上的過濾

能夠match模式中經過添加具體的關係類型，但有時須要針對類型的更加高級的過濾。可使用明確的type屬性來對比，查詢對關係類型名做一個正則比較。

查詢：

START n=node(3)

MATCH (n)-[r]->()

WHERE type(r) =~ /K.*/

RETURN r

關係整個以K開始的類型名都將返回。

結果：

 

屬性存在性

查詢：

START n=node(3, 1)

WHERE n.belt

RETURN n

結果：

若是缺失屬性默認爲true

僅當屬性存在時，比較一個圖的元素的此屬性，使用容許空屬性的語法。

查詢：

START n=node(3, 1)

WHERE n.belt? = 'white'

RETURN n

全部節點即便沒有belt屬性的 都將返回。此類比較返回爲true。

結果：

 

若是缺失屬性默認爲false

須要在缺失屬性時爲false，即不想返回此屬性不存在的節點時。使用感嘆號。

查詢：

START n=node(3, 1)

WHERE n.belt! = 'white'

RETURN n

結果：

 

空置null過濾

有時候須要測試值或者標識符是否爲null。與sql相似使用 is null 或 not（is null x）也能起做用。

查詢：

START a=node(1), b=node(3, 2)

MATCH a<-[r?]-b

WHERE r is null

RETURN b

Tobias節點沒有連接上。

結果：

 

關係過濾

爲過濾兩點間基於關係的子圖，在match子句中使用限制部分。能夠描述帶方向的關係和可能的類型。這些都是有效的表達：WHERE a-→b WHERE a←-b WHERE a←[:KNOWS]-bWHERE a-[:KNOWS]-b

查詢：

START a=node(1), b=node(3, 2)

WHERE a<--b

RETURN b

Tobias節點沒有連接

結果：

 

 

neo4j 綜合

目錄

1. 返回節點

2. 返回關係

3. 返回屬性

4. 帶特殊字符的標識符

5. 列的別名

6. 可選屬性

7. 特別的結果

 查詢中的返回部分，返回途中定義的感興趣的部分。能夠爲節點、關係或其上的屬性。圖

返回節點

返回一個節點，在返回語句中列出便可。

查詢：

START n=node(2)

RETURN n

 結果：

返回關係

查詢：

START n=node(1)

MATCH (n)-[r:KNOWS]->(c)

RETURN r

結果：

返回屬性

查詢：

START n=node(1)

RETURN n.name

結果：

帶特殊字符的標識符

使用不在英語字符表中的字符，可使用’單引號。

查詢：

START This isn't a commonidentifier=node(1)

RETURN This isn't a commonidentifier.<<!!__??>>`

結果：

列的別名

能夠給展現出來的列名起別名。

查詢：

START a=node(1)

RETURN a.age AS SomethingTotallyDifferent

 返回節點的age屬性，但重命名列名。

結果：

可選屬性

屬性在節點上可能存在也可能不存在，可使用問號來標識標識符便可。

查詢：

START n=node(1, 2)

RETURN n.age?

若是存在age屬性，則返回，不存在則返回null。

結果：

特別的結果

DISTINCT 僅檢索特別的行，基於選擇輸出的列。

查詢：

START a=node(1)

MATCH (a)-->(b)

RETURN distinct b

返回name爲B的節點，但僅爲一次。

結果：

neo4j 聚合函數

目錄

1. 聚合Aggregation

1. 計數

2. 計算節點數

3. 分組計算關係類型

4. 計算實體數

5. 計算非空能夠值數

6. 求和sum

7. 平均值avg

8. 最大值max

9. 最小值min

10. 聚類COLLECT

11. 相異DISTINCT

聚合（Aggregation）

爲集合計算數據，Cypher提供聚類功能，與SQL的group by相似。在return語句中發現的任何聚類函數，全部沒有聚類函數的列將做爲聚合key使用。圖：

計數

計數（count）使用來計算行數。Count有兩種使用方法。Count（*）計算匹配的行的行數，count（<標識符>）計算標識符中非空值數。

計算節點數

計算連接到一個節點的節點數，可使用count（*）。

查詢：

START n=node(2)

MATCH (n)-->(x)

RETURN n, count(*)

 返回開始節點和相關節點節點數。

結果：

分組計算關係類型

計算分組了得關係類型，返回關係類型並使用count（*）計算。

查詢：

START n=node(2)

MATCH (n)-[r]->()

RETURN type(r), count(*)

 返回關係類型和其分組數。

結果：

計算實體數

相比使用count（*），可能計算標識符更實在。

查詢：

START n=node(2)

MATCH (n)-->(x)

RETURN count(x)

 返回連接到開始節點上的節點數

結果：

計算非空能夠值數

查詢：

START n=node(2,3,4,1)

RETURN count(n.property?)

 結果：

求和（sum）

Sum集合簡單計算數值類型的值。Null值將自動去掉。以下：

查詢：

START n=node(2,3,4)

RETURN sum(n.property)

 計算全部節點屬性值之和。

結果：

平均值（avg）

Avg計算數量列的平均值

查詢：

START n=node(2,3,4)

RETURN avg(n.property)

 結果：

最大值（max）

Max查找數字列中的最大值。

查詢：

START n=node(2,3,4)

RETURN max(n.property)

 結果：

最小值（min）

Min使用數字屬性做爲輸入，並返回在列中最小的值。

查詢：

START n=node(2,3,4)

RETURN min(n.property)

 結果：

聚類（COLLECT）

Collect將全部值收集到一個集合list中。

查詢：

START n=node(2,3,4)

RETURN collect(n.property)

 返回一個帶有全部屬性值的簡單列。

結果：

相異（DISTINCT）

聚合函數中使用distinct來去掉值中重複的數據。

查詢：

START a=node(2)

MATCH a-->b

RETURN count(distinct b.eyes)

 結果：

neo4j 高級篇

目錄

1. 排序Order by

1. 經過節點屬性排序節點

2. 經過多節點屬性排序節點

3. 倒序排列節點

4. 空值排序

2. Skip

1. 跳過前三個

2. 返回中間兩個

3. Limit

1. 返回第一部分

4. 函數Functions

1. 判斷

2. All

3. Any

4. None

5. Single

6. Scalar函數

7. Length

8. Type

9. Id

10. Coalesce

11. Iterable函數

12. Nodes

13. Relationships

14. Extract

排序（Order by）

輸出結果排序可使用order by 子句。注意，不能使用節點或者關係排序，僅僅只針對其屬性有效。圖：

經過節點屬性排序節點

查詢：

START n=node(3,1,2)

RETURN n

ORDER BY n.name

 結果：

經過多節點屬性排序節點

在order by子句中能夠經過多個屬性來排序每一個標識符。Cypher首先將經過第一個標識符排序，若是第一個標識符或屬性相等，則在order by中檢查下一個屬性，依次類推。

查詢：

START n=node(3,1,2)

RETURN n

ORDER BY n.age, n.name

 首先經過age排序，而後再經過name排序。

結果：

倒序排列節點

能夠在標識符後添加desc或asc來進行倒序排列或順序排列。

查詢：

START n=node(3,1,2)

RETURN n

ORDER BY n.name DESC

 結果：

 

空值排序

當排列結果集時，在順序排列中null將永遠放在最後，而在倒序排列中放最前面。

查詢：

START n=node(3,1,2)

RETURN n.length?, n

ORDER BY n.length?

 結果：

 

Skip

Skip容許返回總結果集中的一個子集。此不保證排序，除非使用了order by’子句。 圖：

跳過前三個

返回結果中一個子集，從第三個結果開始，語法以下：

查詢：

START n=node(3, 4, 5, 1, 2)

RETURN n

ORDER BY n.name

SKIP 3

 前三個節點將略過，最後兩個節點將被返回。

結果：

 

返回中間兩個

查詢：

START n=node(3, 4, 5, 1, 2)

RETURN n

ORDER BY n.name

SKIP 1

LIMIT 2

 中間兩個節點將被返回。

結果：

 

Limit

Limit容許返回結果集中的一個子集。圖：

返回第一部分

查詢：

START n=node(3, 4, 5, 1, 2)

RETURN n

LIMIT 3

 結果：

函數（Functions）

在Cypher中有一組函數，可分爲三類不一樣類型：判斷、標量函數和聚類函數。圖：

判斷

判斷爲boolean函數，對給出的輸入集合作判斷並返回true或者false。經常使用在where子句中過濾子集。

All

迭代測試集合中全部元素的判斷。

語法：

All（標識符 in iterable where 判斷）

參數：

Ø  iterable ：一個集合屬性，或者可迭代的元素，或一個迭代函數。

Ø  標識符：可用於判斷比較的標識符。

Ø  判斷：一個測試全部迭代器中元素的判斷。

查詢：

START a=node(3), b=node(1)

MATCH p=a-[*1..3]->b

WHERE all(x in nodes(p) WHERE x.age > 30)

RETURN p

過濾包含age〈30的節點的路徑，返回符合條件路徑中全部節點。

結果：

Any

語法：ANY(identifierin iterable WHERE predicate)

參數：

Ø  Iterable（迭代器）：一個集合屬性，或者可迭代的元素，或一個迭代函數。

Ø  Identifier（標識符）：可用於判斷比較的標識符。

Ø  Predicate（判斷）：一個測試全部迭代器中元素的判斷。

查詢：

START a=node(2)

WHERE any(x in a.array WHERE x = "one")

RETURN a

結果：

None

在迭代器中沒有元素判斷將返回true。

語法：NONE(identifierin iterable WHERE predicate)

Ø  Iterable（迭代器）：一個集合屬性，或者可迭代的元素，或一個迭代函數。

Ø  Identifier（標識符）：可用於判斷比較的標識符。

Ø  Predicate（判斷）：一個測試全部迭代器中元素的判斷。

查詢：

START n=node(3)

MATCH p=n-[*1..3]->b

WHERE NONE(x in nodes(p) WHERE x.age = 25)

RETURN p

 結果：

Single

若是迭代器中僅有一個元素則返回true。

語法：SINGLE(identifierin iterable WHERE predicate)

參數：

Ø  Iterable（迭代器）：一個集合屬性，或者可迭代的元素，或一個迭代函數。

Ø Identifier（標識符）：可用於判斷比較的標識符。

Ø Predicate（判斷）：一個測試全部迭代器中元素的判斷。

查詢：

START n=node(3)

MATCH p=n-->b

WHERE SINGLE(var in nodes(p) WHERE var.eyes = "blue")

RETURN p

結果：

Scalar函數

標量函數返回單個值。

Length

使用詳細的length屬性，返回或過濾路徑的長度。

語法：LENGTH(iterable )

參數：

Ø  Iterable（迭代器）：一個集合屬性，或者可迭代的元素，或一個迭代函數。

查詢：

START a=node(3)

MATCH p=a-->b-->c

RETURN length(p)

返回路徑的長度。

結果：

Type

返回關係類型的字符串值。

語法：TYPE(relationship )

參數：

Ø  Relationship：一條關係。

查詢：

START n=node(3)

MATCH (n)-[r]->()

RETURN type(r)

返回關係r的類型。

結果：

Id

返回關係或者節點的id

語法：ID(property-container )

參數：

Ø  Property-container：一個節點或者一條關係。

查詢：

START a=node(3, 4, 5)

RETURN ID(a)

返回這三個節點的id。

結果：

Coalesce

返回表達式中第一個非空值。

語法：COALESCE(expression [, expression]* )

參數：

Ø  Expression：可能返回null的表達式。

查詢：

START a=node(3)

RETURN coalesce(a.hairColour?,a.eyes?)

結果：

Iterable函數

迭代器函數返回一個事物的迭代器---在路徑中的節點等等。

Nodes

返回一個路徑中的全部節點。

語法：NODES(path )

參數：

Ø  Path：路徑

查詢：

START a=node(3), c=node(2)

MATCH p=a-->b-->c

RETURN NODES(p)

結果：

Relationships

返回一條路徑中的全部關係。

語法：RELATIONSHIPS(path )

參數：

Ø  Path：路徑

查詢：

START a=node(3), c=node(2)

MATCH p=a-->b-->c

RETURN RELATIONSHIPS(p)

結果：

Extract

可使用extract單個屬性，或從關係或節點集合迭代一個函數的值。將遍歷迭代器中全部的節點並運行表達式返回結果。

語法：EXTRACT(identifier in iterable : expression )

Ø  Iterable（迭代器）：一個集合屬性，或者可迭代的元素，或一個迭代函數。

Ø  Identifier（標識符）：閉包中表述內容的標識符，這決定哪一個標識符將用到。

Ø  expression（表達式）：這個表達式將對於迭代器中每一個值運行一次，並生成一個結果迭代器。

查詢：

START a=node(3), b=node(4),c=node(1)

MATCH p=a-->b-->c

RETURN extract(n in nodes(p) : n.age)

返回路徑中全部age屬性值。

結果：