Neo4j Cypher查詢語言詳解

<div class="ad-pc ad-site"><!--<a href="/go/jjim" rel="external nofollow" target="_blank"><img src="/wp-content/uploads/2017/12/jujin_im.jpg" alt="又拍雲upyun" /></a>-->

<h2>&nbsp;Cypher介紹</h2>

“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 );

節點對象參數

params.put( "node", andreasNode );

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

多節點id參數

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

字元串參數

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

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

索引鍵值參數

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

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

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

索引查詢參數

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

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

SKIP 與LIMIT * 的數字參數

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 );

正規表達式參數

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或索引查詢綁定點。



         Neo4j Cypher查詢語言詳解
           通過id綁定點
      
        

通過node(*)函數綁定一個節點作為開始點


查詢：


START n=node(1)


RETURN n


傳回引用的節點。


結果：



         Neo4j Cypher查詢語言詳解
           通過id綁定關系
      
        

可以通過relationship()函數綁定一個關系作為開始點。也可以通過縮寫rel()。


查詢：


START r=relationship(0)


RETURN r


Id為0的關系将被傳回


結果：



         Neo4j Cypher查詢語言詳解
           通過id綁定多個節點
      
        

選擇多個節點可以通過逗号分開。


查詢：


START n=node(1, 2, 3)


RETURN n


結果：



         Neo4j Cypher查詢語言詳解
           所有節點
      
        

得到所有節點可以通過星号（*），同樣對于關系也适用。


查詢：


START n=node(*)


RETURN n


這個查詢将傳回圖中所有節點。


結果：



         Neo4j Cypher查詢語言詳解
           通過索引查詢擷取節點
      
        

如果開始節點可以通過索引查詢得到，可以如此來寫：


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


查詢：


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


RETURN n


索引中命名為A的節點将被傳回。


結果：



         Neo4j Cypher查詢語言詳解
           通過索引查詢擷取關系
      
        

如果開始點可以通過索引查詢得到，可以如此做：


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


查詢：


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


RETURN r


索引中屬性名為”some_value”的關系将被傳回。


結果：



         Neo4j Cypher查詢語言詳解
           多個開始點
      
        

有時需要綁定多個開始點。隻需要列出并以逗号分隔開。


查詢：


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


RETURN a,b


A和B兩個節點都将被傳回。


結果：



         Neo4j Cypher查詢語言詳解
           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 )



         Neo4j Cypher查詢語言詳解
           相關節點
      
        

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


查詢：


START n=node(3)


MATCH (n)--(x)


RETURN x


所有與A相關節點都被傳回。


結果：



         Neo4j Cypher查詢語言詳解
           接出關系（Outgong relationship）
      
        

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


查詢：


START n=node(3)


MATCH (n)-->(x)


RETURN x


所有A的接出關系到達的節點将被傳回.


結果：



         Neo4j Cypher查詢語言詳解
           定向關系和辨別符
      
        

如果需要關系的辨別符，為了過濾關系的屬性或為了傳回關系，可如下例使用辨別符。


查詢：


START n=node(3)


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


RETURN r


所有從節點A接出的關系将被傳回。


結果：



         Neo4j Cypher查詢語言詳解
           通過關系類型比對
      
        

當已知關系類型并想通過關系類型比對時，可以通過冒号較長的描述。


查詢：


START n=node(3)


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


RETURN x


傳回A接出關系類型為BLOCKS的節點。


結果：



         Neo4j Cypher查詢語言詳解
           通過關系類型比對和使用辨別符
      
        

如果既想獲得關系又要通過已知的關系類型，那就都添加上，如：


查詢：


START n=node(3)


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


RETURN r


所有從A接出的關系為BLOCKS的關系都被傳回。


結果：



         Neo4j Cypher查詢語言詳解
           帶有特殊字元的關系類型
      
        

有時候資料庫中有非字母字元類型，或有空格在内時，使用單引号。


查詢：


START n=node(3)

MATCH (n)-[r:

TYPE WITH SPACE IN IT

]->()



RETURN r


傳回類型有空格的關系。


結果：



         Neo4j Cypher查詢語言詳解
           多重關系
      
        

關系可以通過使用在()—()多個語句來表達，或可以串在一起。如下：


查詢:


START a=node(3)


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


RETURN a,b,c


路徑中的三個節點。


結果：



         Neo4j Cypher查詢語言詳解
           可變長度的關系
      
        

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


查詢：


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


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


RETURN a,x


如果在1到3的關系中存在路徑，将傳回開始點和結束點。


結果：



         Neo4j Cypher查詢語言詳解
           在可變長度關系的關系辨別符
      
        

當連接配接兩個節點的長度是可變的不确定的時，可以使用一個關系辨別符周遊所有關系。


查詢：


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


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


RETURN r


如果在1到3的關系中存在路徑，将傳回開始點和結束點。


結果：



         Neo4j Cypher查詢語言詳解
           零長度路徑
      
        

當使用可變長度路徑，可能其路徑長度為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.


結果：



         Neo4j Cypher查詢語言詳解
           可選關系
      
        

如果關系為可選的，可以使用問号表示。與SQL的外連接配接類似。如果關系存在，将被傳回。如果不存在在其位置将以null代替。


查詢：


START a=node(2)


MATCH a-[?]->x


RETURN a,x


傳回一個節點和一個null，因為這個節點沒有關系。


結果：



         Neo4j Cypher查詢語言詳解
           可選類型和命名關系
      
        

通過一個正常的關系，可以決定哪個辨別符可以進入，那些關系類型是需要的。


查詢：


START a=node(3)


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


RETURN a,r


傳回一個節點和一個null，因為這個節點沒有關系。


結果：



         Neo4j Cypher查詢語言詳解
           可選元素的屬性
      
        

傳回可選元素上的屬性，null值将傳回null。


查詢：


START a=node(2)


MATCH a-[?]->x


RETURN x, x.name


元素x在查詢中為null，所有其屬性name為null。


結果：



         Neo4j Cypher查詢語言詳解
           複雜比對
      
        

在Cypher中，可喲通過更多複雜模式來比對，像一個鑽石形狀模式。


查詢：


START a=node(3)


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


RETURN a,b,c,d


路徑中的四個節點。


結果：



         Neo4j Cypher查詢語言詳解
           最短路徑
      
        

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


查詢：


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


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


RETURN p


這意味着：找出兩點間的一條最短路徑，最大關系長度為15.圓括号内是一個簡單的路徑連接配接，開始節點，連接配接關系和結束節點。關系的字元描述像關系類型，最大數和方向在尋找最短路徑中都将被用到。也可以辨別路徑為可選。


結果：



         Neo4j Cypher查詢語言詳解
           所有最但路徑
      
        

找出兩節點節點所有的最短路徑。


查詢：


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


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


RETURN p


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


結果：



         Neo4j Cypher查詢語言詳解
           命名路徑
      
        

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


查詢：


START a=node(3)


MATCH p = a-->b


RETURN p


開始節點的兩個路徑。


結果：



         Neo4j Cypher查詢語言詳解
           在綁定關系上的比對
      
        

當模式中包含一個綁定關系時，此關系模式沒有明确的方向，Cypher将嘗試着切換連接配接節點的邊比對關系。


查詢：


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


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


RETURN x


将傳回兩個連接配接節點，一次為開始節點，一次為結束節點。


結果：



         Neo4j Cypher查詢語言詳解
               Where
      
        

如果需要從查找的資料的圖中過濾，可以在查詢語句中添加where子句。圖：



         Neo4j Cypher查詢語言詳解
           Boolean 操作類型
      
        

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


查詢：


START n=node(3, 1)


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


RETURN n


傳回節點。


結果：



         Neo4j Cypher查詢語言詳解
           節點屬性上的過濾
      
        

查詢：


START n=node(3, 1)


WHERE n.age < 30


RETURN n


結果：



         Neo4j Cypher查詢語言詳解
           正規表達式
      
        

可以通過使用
        =~ /regexp/
             來比對正在表達式。如下：
             查詢：
              


START n=node(3, 1)


WHERE n.name =~ /Tob.*/


RETURN n


傳回名叫Tobias的節點。


結果：


 
         Neo4j Cypher查詢語言詳解
           轉義正規表達式
      
        

如果在正規表達式中需要有斜杠時可以通過轉義實作。


查詢：


START n=node(3, 1)


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


RETURN n


沒有比對的節點傳回。


結果：



         Neo4j Cypher查詢語言詳解
           不分大小些正規表達式
      
        

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


查詢：


START n=node(3, 1)


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


RETURN n


屬性name為Andres的節點将傳回


結果：



         Neo4j Cypher查詢語言詳解
           關系類型上的過濾
      
        

可以match模式中通過添加具體的關系類型，但有時需要針對類型的更加進階的過濾。可以使用明确的type屬性來對比，查詢對關系類型名作一個正則比較。


查詢：


START n=node(3)


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


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


RETURN r


關系整個以K開始的類型名都将傳回。


結果：



         Neo4j Cypher查詢語言詳解
           屬性存在性
      
        

查詢：


START n=node(3, 1)


WHERE n.belt


RETURN n


結果：



         Neo4j Cypher查詢語言詳解
           如果缺失屬性預設為true
      
        

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


查詢：


START n=node(3, 1)


WHERE n.belt? = 'white'


RETURN n


所有節點即使沒有belt屬性的 都将傳回。此類比較傳回為true。


結果：



         Neo4j Cypher查詢語言詳解
           如果缺失屬性預設為false
      
        

需要在缺失屬性時為false，即不想傳回此屬性不存在的節點時。使用感歎号。


查詢：


START n=node(3, 1)


WHERE n.belt! = 'white'


RETURN n


結果：



         Neo4j Cypher查詢語言詳解
           空置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節點沒有連結上。


結果：



         Neo4j Cypher查詢語言詳解
           關系過濾
      
        

為過濾兩點間基于關系的子圖，在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 Cypher查詢語言詳解
           neo4j 綜合
      
        


目錄

         傳回節點
      
       傳回關系
      
       傳回屬性
      
       帶特殊字元的辨別符
      
       列的别名
      
       可選屬性
      
       特别的結果
      
     
        

 查詢中的傳回部分，傳回途中定義的感興趣的部分。可以為節點、關系或其上的屬性。圖

  Neo4j Cypher查詢語言詳解
           傳回節點
      
        

傳回一個節點，在傳回語句中列出即可。


查詢：


START n=node(2)


RETURN n


 結果：



         Neo4j Cypher查詢語言詳解
           傳回關系
      
        

查詢：


START n=node(1)


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


RETURN r


結果：



         Neo4j Cypher查詢語言詳解
           傳回屬性
      
        

查詢：


START n=node(1)


RETURN n.name


結果：



         Neo4j Cypher查詢語言詳解
           帶特殊字元的辨別符
      
        

使用不在英語字元表中的字元，可以使用’單引号。


查詢：

START

This isn't a commonidentifier

=node(1)

RETURN

<<!!__??>>`

結果：

列的别名

可以給展示出來的列名起别名。

查詢：

START a=node(1)

RETURN a.age AS SomethingTotallyDifferent

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

可選屬性

屬性在節點上可能存在也可能不存在，可以使用問号來辨別辨別符即可。

START n=node(1, 2)

RETURN n.age?

如果存在age屬性，則傳回，不存在則傳回null。

特别的結果

DISTINCT 僅檢索特别的行，基于選擇輸出的列。

MATCH (a)-->(b)

RETURN distinct b

傳回name為B的節點，但僅為一次。

neo4j 聚合函數

聚合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（*）計算。

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

RETURN type(r), count(*)

傳回關系類型和其分組數。

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

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計算數量列的平均值

RETURN avg(n.property)

最大值（max）

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

RETURN max(n.property)

最小值（min）

Min使用數字屬性作為輸入，并傳回在列中最小的值。

RETURN min(n.property)

聚類（COLLECT）

Collect将所有值收集到一個集合list中。

RETURN collect(n.property)

傳回一個帶有所有屬性值的簡單列。

相異（DISTINCT）

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

START a=node(2)

MATCH a-->b

RETURN count(distinct b.eyes)

neo4j 進階篇

排序Order by
1. 通過節點屬性排序節點
2. 通過多節點屬性排序節點
3. 倒序排列節點
4. 空值排序
Skip
1. 跳過前三個
2. 傳回中間兩個
Limit
1. 傳回第一部分
函數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中檢查下一個屬性，依次類推。

ORDER BY n.age, n.name

首先通過age排序，然後再通過name排序。

可以在辨別符後添加desc或asc來進行倒序排列或順序排列。

ORDER BY n.name DESC

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

RETURN n.length?, n

ORDER BY n.length?

Neo4j Cypher查詢語言詳解

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

傳回結果中一個子集，從第三個結果開始，文法如下：

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

SKIP 3

前三個節點将略過，最後兩個節點将被傳回。

SKIP 1

LIMIT 2

中間兩個節點将被傳回。

Neo4j Cypher查詢語言詳解

Limit允許傳回結果集中的一個子集。圖：

LIMIT 3

函數（Functions）

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

判斷為boolean函數，對給出的輸入集合做判斷并傳回true或者false。常用在where子句中過濾子集。

疊代測試集合中所有元素的判斷。

文法：

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(identifierin iterable WHERE predicate)

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

Ø Identifier（辨別符）：可用于判斷比較的辨別符。

Ø Predicate（判斷）：一個測試所有疊代器中元素的判斷。

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

RETURN a

在疊代器中沒有元素判斷将傳回true。

文法：NONE(identifierin iterable WHERE predicate)

START n=node(3)

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

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

如果疊代器中僅有一個元素則傳回true。

文法：SINGLE(identifierin iterable WHERE predicate)

Ø Identifier（辨別符）：可用于判斷比較的辨別符。

Ø Predicate（判斷）：一個測試所有疊代器中元素的判斷。

MATCH p=n-->b

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

标量函數傳回單個值。

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

文法：LENGTH(iterable )

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

START a=node(3)

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

RETURN length(p)

傳回路徑的長度。

傳回關系類型的字元串值。

文法：TYPE(relationship )

Ø Relationship：一條關系。

RETURN type(r)

傳回關系r的類型。

傳回關系或者節點的id

文法：ID(property-container )

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

START a=node(3, 4, 5)

RETURN ID(a)

傳回這三個節點的id。

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

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

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

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

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

傳回一個路徑中的所有節點。

文法：NODES(path )

Ø Path：路徑

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

RETURN NODES(p)

傳回一條路徑中的所有關系。

文法：RELATIONSHIPS(path )

Ø Path：路徑

RETURN RELATIONSHIPS(p)

可以使用extract單個屬性，或從關系或節點集合疊代一個函數的值。将周遊疊代器中所有的節點并運作表達式傳回結果。

文法：EXTRACT(identifier in iterable : expression )

Ø Identifier（辨別符）：閉包中表述内容的辨別符，這決定哪個辨別符将用到。

Ø expression（表達式）：這個表達式将對于疊代器中每個值運作一次，并生成一個結果疊代器。

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

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

傳回路徑中所有age屬性值。

收藏原文位址:http://www.ttlsa.com/nosql/how-to-neo4j-cypher-query-language/

Neo4j Cypher查詢語言詳解

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

在下例中看三個關鍵字

示例圖檔如下：

操作符

參數

辨別符

注解

Start

通過id綁定點

通過id綁定關系

通過id綁定多個節點

所有節點

通過索引查詢擷取節點

通過索引查詢擷取關系

多個開始點

Match

相關節點

接出關系（Outgong relationship）

定向關系和辨別符

通過關系類型比對

通過關系類型比對和使用辨別符

帶有特殊字元的關系類型

多重關系

可變長度的關系

在可變長度關系的關系辨別符

零長度路徑

可選關系

可選類型和命名關系

可選元素的屬性

複雜比對

最短路徑

所有最但路徑

命名路徑

在綁定關系上的比對

Where

Boolean 操作類型

節點屬性上的過濾

正規表達式

轉義正規表達式

不分大小些正規表達式

關系類型上的過濾

屬性存在性

如果缺失屬性預設為true

如果缺失屬性預設為false

空置null過濾

關系過濾

neo4j 綜合

傳回節點

傳回關系

傳回屬性

帶特殊字元的辨別符

列的别名

可選屬性

特别的結果

neo4j 聚合函數

聚合（Aggregation）

求和（sum）

平均值（avg）

最大值（max）

最小值（min）

聚類（COLLECT）

相異（DISTINCT）

neo4j 進階篇

排序（Order by）

Neo4j Cypher查詢語言詳解

Neo4j Cypher查詢語言詳解

函數（Functions）

繼續閱讀