国产 无码 综合区,色欲AV无码国产永久播放,无码天堂亚洲国产AV,国产日韩欧美女同一区二区

  1. Toy模板網(wǎng)首頁
  2. >Toy博客

neo4j查詢語言Cypher詳解(一)--語法和子句

2年前作者：demon7552003分類：Toy博客閱讀(31)違法舉報

這篇具有很好參考價值的文章主要介紹了neo4j查詢語言Cypher詳解(一)--語法和子句。希望對大家有所幫助。如果存在錯誤或未考慮完全的地方，請大家不吝賜教，您也可以點擊"舉報違法"按鈕提交疑問。

前言

neo4j的圖查詢語言叫Cypher。Cypher的獨特之處在于它提供了一種匹配模式和關(guān)系的可視化方式。 (nodes)-[:ARE_CONNECTED_TO]->(otherNodes)使用圓角括號表示節(jié)點(nodes)， -[:ARROWS]->表示關(guān)系。

語法

解析

Cypher解析器接受任意輸入字符串。

unicode通常可以使用轉(zhuǎn)義 \uxxx。

支持的空白符

描述 Unicode 字符列表
Unicode General Category Zp \u2029
Unicode General Category Zs \u0020 (space), \u1680, \u2000-200A, \u202F, \u205F, \u3000
Unicode General Category class Zl \u2028
Horizontal Tabulation \t, \u0009
Line Feed \n, \u000A
Vertical Tabulation \u000B
Form Feed \f, \u000C
Carriage Return \r, \u000D
File Separator \u001C
Group Separator \u001D
Record Separator \u001E
Unit Separator \u001F

表達式

字面量

  • 數(shù)值：13, -40000, 3.14,6.022E23，Inf, Infinity, NaN
  • 十六進制： 0x13af, 0xFC3A9, -0x66eff。 以0x開頭
  • 八進制：0o1372, -0o5671 。以0o開頭。
  • 字符串：'Hello' , "World" 。單引號或者雙引號
  • boolean：true, false

通用表達式

  • 變量：n, x, rel, myFancyVariable
  • 屬性： n.prop, x.prop, rel.thisProperty, myFancyVariable.
  • 動態(tài)屬性： n["prop"], rel[n.city + n.zip], map[coll[0]].
  • 參數(shù)：$param, $0
  • List：['a', 'b'], [1, 2, 3], ['a', 2, n.property, $param], []
  • 函數(shù)調(diào)用：length(p), nodes(p)
  • 聚合函數(shù)：avg(x.prop), count(*)
  • path-pattern： (a)-[r]->(b), (a)-[r]-(b), (a)--(b), (a)-->()<--(b)
  • 操作符： 1 + 2, 3 < 4
  • 斷言表達式：a.prop = 'Hello', length(p) > 10, a.name IS NOT NULL
  • 標簽和關(guān)系類型表達式：(n:A|B), ()-[r:R1|R2]→().
  • 子查詢：EXISTS { MATCH (n)-[r]→(p) WHERE p.name = 'Sven' }
  • 正則表達式：a.name =~ 'Tim.*'
  • 字符串匹配：a.surname STARTS WITH 'Sven', a.surname ENDS WITH 'son' or a.surname CONTAINS 'son'
  • CASE：

CASE

通用條件表達式可以使用CASE結(jié)構(gòu)表示。Cypher中存在CASE的兩種變體:

  • 簡單形式(允許將一個表達式與多個值進行比較)
  • 通用形式(允許表示多個條件語句)。

如果您想在后續(xù)子句或語句中使用CASE表達式的結(jié)果，CASE只能作為RETURN或WITH的一部分使用。

簡單形式
CASE test
  WHEN value THEN result
  [WHEN ...]
  [ELSE default]
END
   
MATCH (n)
RETURN
CASE n.eyes
  WHEN 'blue'  THEN 1
  WHEN 'brown' THEN 2
  ELSE 3
END AS result
通用形式

謂詞將按順序求值，直到找到一個真值，并使用結(jié)果值。如果沒有找到匹配項，則返回ELSE子句中的表達式。但是，如果沒有ELSE情況并且沒有找到匹配，則返回null。

MATCH (n)
RETURN
CASE
  WHEN n.eyes = 'blue' THEN 1
  WHEN n.age < 40      THEN 2
  ELSE 3
END AS result
后續(xù)語句使用CASE表達式結(jié)果

您可以使用CASE的結(jié)果來設(shè)置節(jié)點或關(guān)系的屬性。例如，你可以為表達式選擇的節(jié)點設(shè)置屬性，而不是直接指定節(jié)點:

MATCH (n)
WITH n,                                               // 使用WITH 來處理結(jié)果
CASE n.eyes
  WHEN 'blue'  THEN 1
  WHEN 'brown' THEN 2
  ELSE 3
END AS colourCode
SET n.colourCode = colourCode
處理null
MATCH (n)
RETURN n.name,
CASE n.age
  WHEN null THEN -1
  ELSE n.age - 10
END AS age_10_years_ago

子查詢

子查詢表達式可以出現(xiàn)在表達式有效的任何地方。子查詢有一個范圍，由開始和結(jié)束大括號{和}表示。在外部作用域中定義的任何變量都可以在子查詢自己的作用域中引用。在子查詢內(nèi)部引入的變量不是外部作用域的一部分，因此不能在外部訪問。

EXISTS子查詢

EXISTS子查詢可用于查明指定模式在數(shù)據(jù)中是否至少存在一次。它的用途與路徑模式相同，但功能更強大，因為它允許在內(nèi)部使用MATCH和WHERE子句。此外，與路徑模式不同，它可以出現(xiàn)在任何表達式位置。如果子查詢的求值至少為一行，則整個表達式將變?yōu)檎?。這也意味著系統(tǒng)只需要評估是否至少有一行，并且可以跳過其余的工作。

任何非寫查詢都是允許的。EXISTS子查詢與常規(guī)查詢的不同之處在于，最終的RETURN子句可以省略，因為在子查詢中定義的任何變量在表達式之外都不可用，即使使用了最終的RETURN子句。

值得注意的是，如果EXISTS只包含一個模式和一個可選的where子句，則可以在子查詢中省略MATCH關(guān)鍵字。

簡單形式：

MATCH (person:Person)
WHERE EXISTS {                                    //對Person進行關(guān)系判斷
    (person)-[:HAS_DOG]->(:Dog)
}
RETURN person.name AS name

Where子查詢：

MATCH (person:Person)
WHERE EXISTS {
  MATCH (person)-[:HAS_DOG]->(dog:Dog)                     //有match，where ，更細的判斷
  WHERE person.name = dog.name
}
RETURN person.name AS name

嵌套Exists：

MATCH (person:Person)
WHERE EXISTS {
  MATCH (person)-[:HAS_DOG]->(dog:Dog)
  WHERE EXISTS {
    MATCH (dog)-[:HAS_TOY]->(toy:Toy)
    WHERE toy.name = 'Banana'
  }
}
RETURN person.name AS name

作為結(jié)果：

MATCH (person:Person)
RETURN person.name AS name, EXISTS {
  MATCH (person)-[:HAS_DOG]->(:Dog)
} AS hasDog												//作為一個boolean值結(jié)果
UNION 結(jié)合

Exists可以與UNION子句一起使用，而RETURN子句不是必需的。值得注意的是，如果一個分支有RETURN子句，那么所有分支都需要RETURN子句。下面的示例演示了如果UNION分支中的一個至少返回一行，那么整個EXISTS表達式將求值為true。

MATCH (person:Person)
RETURN
    person.name AS name,
    EXISTS {                                                    //至少有1個 Pet。
        MATCH (person)-[:HAS_DOG]->(:Dog)
        UNION                                                   //UNION ，表示多個聯(lián)合作為一個結(jié)果集，
        MATCH (person)-[:HAS_CAT]->(:Cat)
    } AS hasPet
WITH 結(jié)合

外部范圍的變量對整個子查詢都是可見的，即使使用WITH子句也是如此。為了避免混淆，不允許隱藏這些變量。當內(nèi)部作用域內(nèi)新引入的變量用相同的變量定義時，外部作用域變量將被遮蔽。在下面的示例中，外部變量名被遮蔽，因此會拋出錯誤。

WITH 'Peter' as name
MATCH (person:Person {name: name})
WHERE EXISTS {
    WITH "Ozzy" AS name
    MATCH (person)-[:HAS_DOG]->(d:Dog)
    WHERE d.name = name
}
RETURN person.name AS name
// The variable `name` is shadowing a variable with the same name from the outer scope and needs to be renamed (line 4, column 20 (offset: 90))
RETURN 結(jié)合

EXISTS子查詢不需要在子查詢的末尾使用RETURN子句。如果存在，則不需要使用別名，這與CALL子查詢不同。EXISTS子查詢返回的任何變量在該子查詢之后都不可用。

MATCH (person:Person)
WHERE EXISTS {
    MATCH (person)-[:HAS_DOG]->(:Dog)
    RETURN person.name
}
RETURN person.name AS name
COUNT 子查詢

可以使用COUNT子查詢表達式對子查詢返回的行數(shù)進行計數(shù)。

任何非寫查詢都是允許的。COUNT子查詢與常規(guī)查詢的不同之處在于，最終的RETURN子句可以省略，因為在子查詢中定義的任何變量在表達式之外都不可用，即使使用了最終的RETURN子句。一個例外是，對于DISTINCT UNION子句，RETURN子句仍然是強制性的。

值得注意的是，如果COUNT僅由一個模式和一個可選的where子句組成，則可以在子查詢中省略MATCH關(guān)鍵字。

簡單 Count 子查詢
MATCH (person:Person)
WHERE COUNT { (person)-[:HAS_DOG]->(:Dog) } > 1      // count 關(guān)系
RETURN person.name AS name
Count中Where語句
MATCH (person:Person)
WHERE COUNT {
  (person)-[:HAS_DOG]->(dog:Dog)
  WHERE person.name = dog.name                   //限定了 dog的name。
} = 1
RETURN person.name AS name
Count中Union
MATCH (person:Person)
RETURN
    person.name AS name,
    COUNT {
        MATCH (person)-[:HAS_DOG]->(dog:Dog)
        RETURN dog.name AS petName                              // dog
        UNION
        MATCH (person)-[:HAS_CAT]->(cat:Cat)
        RETURN cat.name AS petName                               // cat
    } AS numPets                                               // count (union結(jié)果集)
Count 中 With
WITH 'Peter' as name
MATCH (person:Person {name: name})
WHERE COUNT {
    WITH "Ozzy" AS name                          //變量名沖突
    MATCH (person)-[:HAS_DOG]->(d:Dog)
    WHERE d.name = name
} = 1
RETURN person.name AS name
    
    
MATCH (person:Person)
WHERE COUNT {
    WITH "Ozzy" AS dogName                      //新的變量
    MATCH (person)-[:HAS_DOG]->(d:Dog)
    WHERE d.name = dogName
} = 1
RETURN person.name AS name
Count在其他語句
MATCH (person:Person)
RETURN person.name, COUNT { (person)-[:HAS_DOG]->(:Dog) } as howManyDogs  //統(tǒng)計dog
                                                  
MATCH (person:Person) WHERE person.name ="Andy"
SET person.howManyDogs = COUNT { (person)-[:HAS_DOG]->(:Dog) }                   //設(shè)置dog 數(shù)量
RETURN person.howManyDogs as howManyDogs
 
MATCH (person:Person)
RETURN
   CASE
     WHEN COUNT { (person)-[:HAS_DOG]->(:Dog) } > 1 THEN "Doglover " + person.name
     ELSE person.name
   END AS result
                                        
MATCH (person:Person)
RETURN COUNT { (person)-[:HAS_DOG]->(:Dog) } AS numDogs,            //作為 Group key。
       avg(person.age) AS averageAge
 ORDER BY numDogs
COLLECT 子查詢

可以使用COLLECT子查詢表達式創(chuàng)建一個包含給定子查詢返回的行的列表。返回的數(shù)據(jù)類型是個List。

簡單Collect子查詢
MATCH (person:Person)
WHERE 'Ozzy' IN COLLECT { MATCH (person)-[:HAS_DOG]->(dog:Dog) RETURN dog.name }  //類似 SQL 中的 in。
RETURN person.name AS name
Collect結(jié)合Where
MATCH (person:Person)
RETURN person.name as name, COLLECT {
  MATCH (person)-[r:HAS_DOG]->(dog:Dog)
  WHERE r.since > 2017
  RETURN dog.name
} as youngDogs             //返回的是個List，[]。
Collect結(jié)合Union
MATCH (person:Person)
RETURN
    person.name AS name,
    COLLECT {
        MATCH (person)-[:HAS_DOG]->(dog:Dog)
        RETURN dog.name AS petName
        UNION												// 類似 SQL union，結(jié)果集
        MATCH (person)-[:HAS_CAT]->(cat:Cat)
        RETURN cat.name AS petName
    } AS petNames      //返回的是個List，[]。
Collect 結(jié)合 WITH
MATCH (person:Person)
RETURN person.name AS name, COLLECT {
    WITH 2018 AS yearOfTheDog    //定義 變量
    MATCH (person)-[r:HAS_DOG]->(d:Dog)
    WHERE r.since = yearOfTheDog
    RETURN d.name
} as dogsOfTheYear    //返回的是個List，[]。
Collect在其他語句
MATCH (person:Person) WHERE person.name = "Peter"
SET person.dogNames = COLLECT { MATCH (person)-[:HAS_DOG]->(d:Dog) RETURN d.name }
RETURN person.dogNames as dogNames

MATCH (person:Person)
RETURN
   CASE
     WHEN COLLECT { MATCH (person)-[:HAS_DOG]->(d:Dog) RETURN d.name } = []  THEN "No Dogs " + person.name
     ELSE person.name
   END AS result
         
MATCH (person:Person)
RETURN COLLECT { MATCH (person)-[:HAS_DOG]->(d:Dog) RETURN d.name } AS dogNames, //作為 group key
       avg(person.age) AS averageAge
 ORDER BY dogNames
COLLECT vs collect()

Collect() 會移除 null。collect{}不移除null，如果需要移除，要加過濾條件。

MATCH (p:Person)
RETURN collect(p.nickname) AS names
//  ["Pete", "Tim"]
RETURN COLLECT {
        MATCH (p:Person)
        RETURN p.nickname ORDER BY p.nickname
      } AS names
//["Pete", "Tim", null]
               
RETURN COLLECT {
        MATCH (p:Person)
        WHERE p.nickname IS NOT NULL				// 過濾條件。
        RETURN p.nickname ORDER BY p.nickname
      } AS names
// ["Pete", "Tim"]

type斷言表達式

<expr> IS :: <TYPE>

UNWIND [42, true, 'abc'] AS val
RETURN val, val IS :: INTEGER AS isInteger

//從變量里每個元素都進行判斷。
val	isInteger
42 true
true false
'abc' false
// NOT 
UNWIND [42, true, 'abc'] AS val
RETURN val, val IS NOT :: STRING AS notString
// IS :: returns true for all expressions evaluating to null
toFloat(null)  IS :: BOOLEAN  // true。
// IS NOT :: returns false for all expressions evaluating to null
(null + 1) IS NOT :: DATE // false

//屬性斷言
MATCH (n:Person)
WHERE n.age IS :: INTEGER AND n.age > 18
RETURN n.name AS name, n.age AS age

Cypher將把任何精確的數(shù)值參數(shù)視為INTEGER，而不管其聲明的大小。

同義詞
<expr> IS TYPED <TYPE>
<expr> :: <TYPE>
<expr> IS NOT TYPED <TYPE>
ANY 、NOTHING

ANY是一個超類型，它匹配所有類型的值。NOTHING是包含一組空值的類型。這意味著它對所有值返回false。

RETURN 42 IS :: ANY AS isOfTypeAny, 42 IS :: NOTHING AS isOfTypeNothing
//true   false
LIST類型
UNWIND [[42], [42, null], [42, 42.0]] as val
RETURN val, val IS :: LIST<INTEGER> AS isIntList  //注意LIST 的 內(nèi)部類型，類似JAVA 泛型
//
[42]           true
[42, null]     true
[42, 42.0]     false        //42.0不是INTEGER

空列表匹配任何內(nèi)部類型，包括NOTHING。

RETURN
    [] IS :: LIST<NOTHING> AS isNothingList,                       //TRUE
    [] IS :: LIST<INTEGER> AS isIntList,						// true
    [] IS :: LIST<FLOAT NOT NULL> AS isFloatNotNullList            //true

標簽表達式

在早期版本的Neo4j中，節(jié)點的標簽表達式只有一個冒號操作符，表示AND操作符。隨著版本5的發(fā)布，除了單個冒號操作符之外，還引入了一個帶有擴展邏輯操作符集的新標簽表達式。重要的是要注意，不能混合使用這些不同類型的標簽表達式語法。

當應(yīng)用于節(jié)點的標簽集時，標簽表達式的計算結(jié)果為true或false。假設(shè)沒有應(yīng)用其他篩選器，那么求值為true的標簽表達式表示匹配該節(jié)點。

Node
Label expression () (:A) (:B) (:C) (:A:B) (:A:C) (:B:C) (:A:B:C)
() √ √ √ √ √ √ √ √
(:A) √ √ √ √
(:A&B) √ √
(:A|B) √ √ √ √ √ √
(:!A) √ √ √ √
(:!!A) √ √ √ √
(:A&!A)
(:A|!A) √ √ √ √ √ √ √ √
(:%) √ √ √ √ √ √ √
(:!%) √
(:%|!%) √ √ √ √ √ √ √ √
(:%&!%)
(:A&%) √ √ √ √
(:A|%) √ √ √ √ √ √ √
(:(A&B)&!(B&C)) √
(:!(A&%)&%) √ √ √
語法
  • 沒有標簽：MATCH (n)
  • 單個標簽：MATCH (n:A)
  • AND：MATCH (n:A&B)
  • OR：MATCH (n:A|B)
  • NOT：MATCH (n:!A)
  • 通配符：MATCH (n:%)， 至少一個標簽
  • 嵌套Lable：MATCH (n:(!A&!B)|C)
  • WHERE：MATCH (n) WHERE n:A|B
  • WITH,RETURN：MATCH (n) RETURN n:A&B

關(guān)系類型表達式

關(guān)系必須有準確的一種類型。例如，模式(a)-[r:R&Q]-(b)或(a)-[r:!%]-(b)永遠不會返回任何結(jié)果。

變長關(guān)系只能有由|組成的關(guān)系類型表達式。這意味著()-[r:!R*]-()是不允許的,而 ()-[r:Q|R*]-()是允許的。

關(guān)系
關(guān)系類型表達式 [:A] [:B] [:C]
[] √ √ √
[:A] √
[:A&B]
[:A|B] √ √
[:!A] √ √
[:!!A] √
[:A&!A]
[:A|!A] √ √ √
[:%] √ √ √
[:!%]
[:%|!%] √ √ √
[:%&!%]
[:A&%] √
[:A|%] √ √ √

標簽表達式不能與標簽語法結(jié)合使用。例如:A:B&C將拋出錯誤。相反，使用:A&B&C或:A:B:C。

語法

  • 沒有標簽：MATCH ()-[r]->()

  • 單個標簽：MATCH ()-[r:R1]->()

  • OR：MATCH ()-[r:R1|R2]->()

  • NOT：MATCH ()-[r:!R1]->()

  • 嵌套Lable：MATCH ()-[r:(!R1&!R2)|R3]->()

  • WHERE：MATCH (n)-[r]->(m) WHERE r:R1|R2

  • WITH,RETURN：MATCH (n)-[r]->(m) RETURN r:R1|R2 AS result

  • CASE

    MATCH (n)-[r]->(m)
RETURN
CASE
  WHEN n:A&B THEN 1
  WHEN r:!R1&!R2 THEN 2
  ELSE -1
END AS result

沒有AND，因為AND不返回任何結(jié)果

參數(shù)

Cypher支持帶參數(shù)查詢。參數(shù)化查詢是一種查詢，其中占位符用于參數(shù)，并在執(zhí)行時提供參數(shù)值。這意味著開發(fā)人員不必借助字符串構(gòu)建來創(chuàng)建查詢。此外，參數(shù)使Cypher更容易緩存執(zhí)行計劃，從而加快查詢執(zhí)行時間。

參數(shù)可用于:

  • 字面量和表達式

  • 節(jié)點和關(guān)系id

參數(shù)不能用于以下結(jié)構(gòu)，因為它們構(gòu)成了編譯成查詢計劃的查詢結(jié)構(gòu)的一部分:

  • 屬性key：MATCH (n) WHERE n.$param = 'something'
  • 關(guān)系類型： MATCH (n)-[:$param]→(m)
  • 標簽： (n:$param)

參數(shù)可以由字母和數(shù)字組成，也可以由字母和數(shù)字的任意組合組成，但不能以數(shù)字或貨幣符號開頭。

在運行查詢時設(shè)置參數(shù)取決于客戶端環(huán)境。例如:

  • Shell環(huán)境： :param name => 'Joe'

  • Neo4j Browser： :param name => 'Joe'

  • 驅(qū)動：根據(jù)語言

  • Neo4j HTTP API：

參數(shù)以JSON格式給出，提交它們的確切方式取決于所使用的驅(qū)動程序。

Auto-parameterization

從版本5開始，即使查詢是部分參數(shù)化的，Cypher也會嘗試推斷參數(shù)。查詢中的每個文字都被一個參數(shù)替換。這增加了計算計劃的可重用性，這些查詢除了字面量之外都是相同的。不建議依賴這種行為——用戶應(yīng)該在他們認為合適的地方使用參數(shù)。

字符串字面量
// 參數(shù)
{
  "name": "Johan"
}
//用法1：
MATCH (n:Person)
WHERE n.name = $name
RETURN n
//用法2：
MATCH (n:Person {name: $name})
RETURN n
正則表達式
//輸入?yún)?shù)
{
  "regex": ".*h.*"
}
//用法：      
MATCH (n:Person)
WHERE n.name =~ $regex
RETURN n.name
字符串
MATCH (n:Person)
WHERE n.name STARTS WITH $name
RETURN n.name
使用屬性創(chuàng)建節(jié)點
{
  "props": {
    "name": "Andy",
    "position": "Developer"
  }
}

CREATE ($props)
創(chuàng)建多個節(jié)點
{
  "props": [ {
    "awesome": true,
    "name": "Andy",
    "position": "Developer"
  }, {
    "children": 3,
    "name": "Michael",
    "position": "Developer"
  } ]
}

UNWIND $props AS properties       //把屬性展開
CREATE (n:Person)
SET n = properties              //賦值所有屬性
RETURN n
set屬性
{
  "props": {
    "name": "Andy",
    "position": "Developer"
  }
}

MATCH (n:Person)
WHERE n.name = 'Michaela'
SET n = $props
SKIP LIMIT
{
  "s": 1,
  "l": 1
}
//
MATCH (n:Person)
RETURN n.name
SKIP $s			//
LIMIT $l		//
node id
//單id
{  "id" : "4:1fd57deb-355d-47bb-a80a-d39ac2d2bcdb:0"}
MATCH (n)
WHERE elementId(n) = $id
RETURN n.name
//多id
{
  "ids" : [ "4:1fd57deb-355d-47bb-a80a-d39ac2d2bcdb:0", "4:1fd57deb-355d-47bb-a80a-d39ac2d2bcdb:1" ]
}
MATCH (n)
WHERE elementId(n) IN $ids
RETURN n.name
方法調(diào)用
{
  "indexname" : "My_index"
}
CALL db.resampleIndex($indexname)

操作符

Operators at a glance

操作符類型
聚合操作符 DISTINCT
屬性操作符 . 靜態(tài)屬性訪問
[] 動態(tài)屬性訪問
= 替換節(jié)點或?qū)傩缘娜繉傩?br>+= 修改已存在屬性，新增不存在屬性
數(shù)學(xué)操作符 +, -, *, /, %, ^
比較操作符 =, <>, <, >, <=, >=, IS NULL, IS NOT NULL
字符串特定操作符 STARTS WITH, ENDS WITH, CONTAINS, =~ (正則匹配)
邏輯操作符 AND, OR, XOR, NOT
字符串操作符 + (字符串連接)
時間操作符 + and - for operations between durations and temporal instants/durations,
* and / for operations between durations and numbers
map操作符 . 靜態(tài)key訪問,
[]動態(tài)key訪問
List操作符 +連接List，所有元素放一個List
IN List是否存在元素
[]動態(tài)訪問元素

注釋

Cypher使用 // 來記性注釋。

MATCH (n) RETURN n //This is an end of line comment

子句

Match

MATCH (n)				//匹配所有節(jié)點
MATCH (movie:Movie)		//匹配指定節(jié)點
// 關(guān)聯(lián)節(jié)點 
MATCH (director {name: 'Oliver Stone'})--(movie)  //關(guān)聯(lián)的任意節(jié)點
RETURN movie.title		
    
MATCH (:Person {name: 'Oliver Stone'})--(movie:Movie)        //關(guān)聯(lián)到movie                               
RETURN movie.title

關(guān)系

//出關(guān)系：-->
MATCH (:Person {name: 'Oliver Stone'})-->(movie)
RETURN movie.title
//無方向關(guān)系
MATCH (a)-[:ACTED_IN {role: 'Bud Fox'}]-(b)
RETURN a, b
//多關(guān)系
MATCH (wallstreet {title: 'Wall Street'})<-[:ACTED_IN|DIRECTED]-(person)
RETURN person.name

關(guān)系深度

在單個模式中，關(guān)系只匹配一次。在關(guān)系獨特性一節(jié)中了解更多。

關(guān)系類型一般用字母數(shù)字混合命名，如果有特殊字符，需用反引號( `)括起來。eg：(rob)-[:`OLD FRIENDS`]->(martin)。

// 2層關(guān)系
MATCH (charlie {name: 'Charlie Sheen'})-[:ACTED_IN]->(movie)<-[:DIRECTED]-(director)
RETURN movie.title, director.name

OPTIONAL MATCH

OPTIONAL MATCH 與Match模式基本類似，唯一差別是，如果沒有匹配上，則用null 表示，類似于SQL中的Outer Join。

Cypher中的查詢是作為管道運行的。如果一個子句沒有返回結(jié)果，它將有效地結(jié)束查詢，因為后續(xù)子句將沒有數(shù)據(jù)可執(zhí)行。

//不會返回結(jié)果。
MATCH (a:Person {name: 'Martin Sheen'})
MATCH (a)-[r:DIRECTED]->()			//沒有匹配，則不會執(zhí)行下一步。
RETURN a.name, r
//會返回結(jié)果。
MATCH (p:Person {name: 'Martin Sheen'})
OPTIONAL MATCH (p)-[r:DIRECTED]->()		//沒有匹配，則返回null。
RETURN p.name, r                        //OUTER JOIN，p 是有值的，空Node用null表示。

Optional 關(guān)系

MATCH (a:Person {name: 'Charlie Sheen'})
OPTIONAL MATCH (a)-->(x)
RETURN x			//返回 null

Optional元素的屬性

如果元素返回null，則元素的屬性也返回null。不會拋出空指針。

MATCH (a:Movie {title: 'Wall Street'})
OPTIONAL MATCH (a)-->(x)
RETURN x, x.name	//返回：null  null

Optional 命名關(guān)系

MATCH (a:Movie {title: 'Wall Street'})
OPTIONAL MATCH (a)-[r:ACTED_IN]->()
RETURN a.title, r		// 關(guān)系返回 null。
                 
MATCH (a:Movie {title: 'Wall Street'})
OPTIONAL MATCH (x)-[r:ACTED_IN]->(a)
RETURN a.title, x.name, type(r)   // 返回的是ACTED_IN，不是null。

注意：雖然關(guān)系r 返回null，但是type? 返回的是ACTED_IN。

RETURN

MATCH p = (keanu:Person {name: 'Keanu Reeves'})-[r]->(m)
RETURN *                //返回所有元素。即所有匹配的變量：p，keanu，r，m

含有特殊字符的變量名，使用反引號( `?)括起來。

列別名使用 AS ，eg：RETURN p.nationality AS citizenship

Optional 屬性

如果一個元素沒有指定的屬性，則返回null。

其他表達式

RETURN m.released < 2012, "I'm a literal",[p=(m)--() | p] AS `(m)--()`

結(jié)果去重

MATCH (p:Person {name: 'Keanu Reeves'})-->(m)
RETURN DISTINCT m

WITH

WITH子句允許將查詢部分鏈接在一起，將一個查詢部分的結(jié)果作為下一個查詢部分的起點或標準。

重要的是要注意WITH影響作用域中的變量。沒有包含在WITH子句中的任何變量都不會轉(zhuǎn)移到查詢的其余部分。通配符*可用于包含當前范圍內(nèi)的所有變量。

使用WITH，您可以在將輸出傳遞給后續(xù)查詢部分之前對其進行操作?？梢詫Y(jié)果集中的項的Shape和(或)數(shù)量進行操作。

WITH的一種常見用法是限制傳遞給其他MATCH子句的條目數(shù)量。通過組合ORDER By和LIMIT，可以根據(jù)某些條件獲得前X個條目，然后從圖中引入額外的數(shù)據(jù)。

WITH還可以用于引入包含表達式結(jié)果的新變量，以供后續(xù)查詢部分使用。為方便起見，通配符*擴展為當前范圍內(nèi)的所有變量，并將它們攜帶到下一個查詢部分。

另一個用途是對聚合值進行過濾。WITH用于引入聚合，然后在WHERE中的謂詞中使用聚合。這些聚合表達式在結(jié)果中創(chuàng)建新的綁定。

WITH還用于分離圖的讀取和更新。查詢的每個部分必須是只讀的或只寫的。當從寫部分切換到讀部分時，必須使用with子句進行切換。

引入變量

MATCH (george {name: 'George'})<--(otherPerson)
WITH otherPerson, toUpper(otherPerson.name) AS upperCaseName  //upperCaseName 新變量
WHERE upperCaseName STARTS WITH 'C'
RETURN otherPerson.name

通配符擴展

MATCH (person)-[r]->(otherPerson)
WITH *, type(r) AS connectionType   //把幾個變量攜帶下去。person，r，otherPerson
RETURN person.name, otherPerson.name, connectionType

過濾聚合結(jié)果

MATCH (david {name: 'David'})--(otherPerson)-->()
WITH otherPerson, count(*) AS foaf			//聚合 COUNT
WHERE foaf > 1								//過濾，類似SQL HAVING
RETURN otherPerson.name

結(jié)果排序

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

分支限制

可以匹配路徑，限制到一定數(shù)量，然后使用這些路徑作為基礎(chǔ)再次匹配，以及任意數(shù)量的類似有限搜索。

MATCH (n {name: 'Anders'})--(m)
WITH m								//從這個地方開始，對m進行限制
ORDER BY m.name DESC
LIMIT 1								//返回第一個記錄
MATCH (m)--(o)						//基于返回的記錄，再進行匹配。
RETURN o.name

限制后過濾

UNWIND [1, 2, 3, 4, 5, 6] AS x
WITH x					
LIMIT 5						//先限制
WHERE x > 2					//再過濾
RETURN x

UNWIND

展開List的元素。

UNWIND [1, 2, 3, null] AS x			//結(jié)果為4行記錄：1,2,3,null  
UNWIND [] AS empty					//返回0行記錄。
UNWIND null AS x                    //展開一個非List元素，返回0行記錄
UNWIND $events AS event				//可以對參數(shù)進行展開

WHERE

WHERE子句本身并不是一個子句— —相反，它是MATCH、OPTIONAL MATCH和WITH子句的一部分。

當與MATCH和OPTIONAL MATCH一起使用時，WHERE會向所描述的模式添加約束。在匹配完成后，它不應(yīng)該被視為一個過濾器。然而，在WITH的情況下，WHERE只是過濾結(jié)果。

在有多個MATCH / OPTIONAL MATCH子句的情況下，WHERE中的謂詞總是最為最接近的前面的MATCH / OPTIONAL MATCH中的模式的一部分。如果將WHERE放在錯誤的MATCH子句中，結(jié)果和性能都可能受到影響。

//節(jié)點模式斷言
WITH 30 AS minAge
MATCH (a:Person WHERE a.name = 'Andy')-[:KNOWS]->(b:Person WHERE b.age > minAge)
RETURN b.name
///約束Label 1
MATCH (a:Person {name: 'Andy'})
RETURN [(a)-->(b WHERE b:Person) | b.name] AS friends  //約束b。
//boolean操作
MATCH (n:Person)
WHERE n.name = 'Peter' XOR (n.age < 30 AND n.name = 'Timothy') OR NOT (n.name = 'Timothy' OR n.name = 'Peter')
RETURN
  n.name AS name,
  n.age AS age
ORDER BY name
//約束Label 2
MATCH (n)
WHERE n:Swedish
RETURN n.name, n.age
//約束節(jié)點屬性
MATCH (n:Person)
WHERE n.age < 30
RETURN n.name, n.age
//約束關(guān)系屬性
MATCH (n:Person)-[k:KNOWS]->(f)
WHERE k.since < 2000
RETURN f.name, f.age, f.email
//約束動態(tài)節(jié)點屬性
WITH 'AGE' AS propname
MATCH (n:Person)
WHERE n[toLower(propname)] < 30
RETURN n.name, n.age
//約束關(guān)系
WITH 2000 AS minYear
MATCH (a:Person)-[r:KNOWS WHERE r.since < minYear]->(b:Person)
RETURN r.since

與With一起使用

MATCH (n:Person)
WITH n.name as name
WHERE n.age = 25
RETURN name

字符串匹配

MATCH (n:Person)
WHERE n.name STARTS WITH 'Pet'

WHERE n.name ENDS WITH 'ter'

WHERE n.name CONTAINS 'ete'

WHERE NOT n.name ENDS WITH 'y'

WHERE n.name =~ 'Tim.*'

WHERE n.email =~ '.*\\.com'

WHERE n.name =~ '(?i)AND.*'  //大小寫不敏感

路徑模式約束

模式是Cypher中的表達式，它返回一個路徑列表。列表表達式也是謂詞;空列表表示false，非空列表表示true。

模式不僅是表達式，也是謂詞。模式的唯一限制是它必須能夠在單一路徑中表達它。與MATCH不同，不能在多個路徑之間使用逗號。要使用WHERE組合多個模式，請使用AND。注意，不能引入新的變量。盡管它可能看起來與MATCH模式非常相似，但WHERE子句用于消除匹配的路徑。MATCH (a)-[]→(b)與WHERE (a)-[]→(b)非常不同。前者將為它能找到的a和b之間的每一條路徑生成一條路徑，而后者將消除a和b之間沒有直接關(guān)系鏈的任何匹配路徑。

MATCH
  (timothy:Person {name: 'Timothy'}),
  (other:Person)
WHERE other.name IN ['Andy', 'Peter'] AND (other)-->(timothy)  //約束關(guān)系。
RETURN other.name, other.age

ORDER BY

ORDER BY是RETURN或WITH后續(xù)的子句，它指定輸出應(yīng)該排序以及如何排序。

MATCH (n)
WITH n ORDER BY n.age
RETURN collect(n.name) AS names

ORDER BY 可以基于表達式結(jié)果排序。

MATCH (n)
RETURN n.name, n.age, n.length
ORDER BY keys(n)				//keys

SKIP,LIMIT

MATCH (n)
RETURN n.name
ORDER BY n.name
SKIP 1
LIMIT 2

可以基于表達式結(jié)果

MATCH (n)
RETURN n.name
ORDER BY n.name
SKIP 1 + toInteger(3*rand())

CREATE

創(chuàng)建Node

CREATE (n)								//創(chuàng)建單個節(jié)點
CREATE (n), (m)							//創(chuàng)建多個節(jié)點
CREATE (n:Person)
CREATE (n:Person:Swedish)
CREATE (n:Person {name: 'Andy', title: 'Developer'})

// 創(chuàng)建的節(jié)點，定義個變量，后續(xù)引用
CREATE (a {name: 'Andy'})
RETURN a.name

創(chuàng)建關(guān)系

MATCH
  (a:Person),
  (b:Person)
WHERE a.name = 'A' AND b.name = 'B'
CREATE (a)-[r:RELTYPE {name: a.name + '<->' + b.name}]->(b)  //創(chuàng)建關(guān)系，并設(shè)置屬性。
RETURN type(r), r.name
//一個路徑
CREATE p = (:Person {name:'Andy'})-[:WORKS_AT]->(:Company {name: 'Neo4j'})<-[:WORKS_AT]-(:Person {name: 'Michael'})
RETURN p

DELETE

MATCH (n:Person {name: 'Laurence Fishburne'})-[r:ACTED_IN]->()
DELETE r
//刪除節(jié)點，并刪除它的關(guān)系
MATCH (n:Person {name: 'Carrie-Anne Moss'})
DETACH DELETE n							//關(guān)系一起刪除

SET

MATCH (n {name: 'Andy'})
SET n.surname = 'Taylor'    //設(shè)置屬性
RETURN n.name, n.surname
    
MATCH (n {name: 'Andy'})
SET n.surname = 'Taylor'	//設(shè)置屬性
RETURN n.name, n.surname
//移除屬性
MATCH (n {name: 'Andy'})
SET n.name = null			//null
RETURN n.name, n.age
//替換所有屬性
MATCH (p {name: 'Peter'})
SET p = {name: 'Peter Smith', position: 'Entrepreneur'}
RETURN p.name, p.age, p.position
//移除所有屬性
MATCH (p {name: 'Peter'})
SET p = {}
RETURN p.name, p.age

操作屬性

使用map和+=改變特定屬性：

  • map中不在節(jié)點或關(guān)系上的任何屬性都將被添加。

  • map中不在節(jié)點或關(guān)系上的任何屬性將保持原樣。

  • map和節(jié)點或關(guān)系中的任何屬性都將在節(jié)點或關(guān)系中被替換。但是，如果映射中的任何屬性為null，則將從節(jié)點或關(guān)系中刪除該屬性。

MATCH (p {name: 'Peter'})
SET p += {age: 38, hungry: true, position: 'Entrepreneur'}
RETURN p.name, p.age, p.hungry, p.position

REMOVE

//移除屬性
MATCH (a {name: 'Andy'})
REMOVE a.age
RETURN a.name, a.age
//移除 Label
MATCH (n {name: 'Peter'})
REMOVE n:German
RETURN n.name, labels(n)

FOREACH

FOREACH子句用于更新集合中的數(shù)據(jù)，無論是路徑的組件還是聚合的結(jié)果。

FOREACH括號內(nèi)的變量上下文與其外部的變量上下文是分開的。這意味著，如果在FOREACH語句中創(chuàng)建節(jié)點變量，則不能在FOREACH語句之外使用它，除非進行匹配才能找到它。

在FOREACH括號內(nèi)，您可以執(zhí)行任何更新命令:SET、REMOVE、CREATE、MERGE、DELETE和FOREACH。

MATCH p=(start)-[*]->(finish)
WHERE start.name = 'A' AND finish.name = 'D'
FOREACH (n IN nodes(p) | SET n.marked = true)

MERGE

MERGE子句要么匹配圖中的現(xiàn)有節(jié)點模式并綁定它們，要么(如果不存在)創(chuàng)建新數(shù)據(jù)并綁定它。通過這種方式，它充當MATCH和CREATE的組合，允許根據(jù)是否匹配或創(chuàng)建指定數(shù)據(jù)執(zhí)行特定操作。

出于性能原因，強烈建議在使用MERGE時在標簽或?qū)傩陨蟿?chuàng)建模式索引。

當對完整模式使用MERGE時，行為是要么匹配整個模式，要么創(chuàng)建整個模式。MERGE不會部分地使用現(xiàn)有模式。如果需要部分匹配，可以通過將模式拆分為多個MERGE子句來實現(xiàn)。

在并發(fā)更新下，MERGE只保證MERGE模式的存在，而不保證唯一性。為了保證具有某些屬性的節(jié)點的唯一性，應(yīng)該使用屬性唯一性約束。

與MATCH類似，MERGE可以匹配模式的多次出現(xiàn)。如果有多個匹配項，它們都將被傳遞到查詢的后面階段。

MERGE子句的最后一部分是ON CREATE和(或)ON MATCH操作符。這允許查詢表達對節(jié)點或關(guān)系屬性的附加更改，具體取決于元素是在數(shù)據(jù)庫中匹配(MATCH)還是創(chuàng)建(CREATE)。

MERGE (robert:Critic)
RETURN robert, labels(robert)
                      
MERGE (charlie {name: 'Charlie Sheen', age: 10})
RETURN charlie
                 
MERGE (michael:Person {name: 'Michael Douglas'})
RETURN michael.name, michael.bornIn
    
MATCH (person:Person)
MERGE (location:Location {name: person.bornIn})  // 引用person的屬性
RETURN person.name, person.bornIn, location

ON CREATE 和ON MATCH

Merge事件觸發(fā)器

MERGE (keanu:Person {name: 'Keanu Reeves', bornIn: 'Beirut', chauffeurName: 'Eric Brown'})
ON CREATE
  SET keanu.created = timestamp()                //創(chuàng)建時，set 創(chuàng)建時間
RETURN keanu.name, keanu.created
    
MERGE (person:Person)
ON MATCH
  SET person.found = true						//可以設(shè)置多個屬性的。
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

//直接關(guān)系
MATCH
  (charlie:Person {name: 'Charlie Sheen'}),
  (wallStreet:Movie {title: 'Wall Street'})
MERGE (charlie)-[r:ACTED_IN]->(wallStreet)
RETURN charlie.name, type(r), wallStreet.title
//非直接關(guān)系
MATCH
  (charlie:Person {name: 'Charlie Sheen'}),
  (oliver:Person {name: 'Oliver Stone'})
MERGE (charlie)-[r:KNOWS]-(oliver)
RETURN r

MATCH (person:Person)
MERGE (person)-[r:HAS_CHAUFFEUR]->(chauffeur:Chauffeur {name: person.chauffeurName})//引用變量
RETURN person.name, person.chauffeurName, chauffeur

CALL

CALL { }

以RETURN語句結(jié)束的子查詢稱為返回子查詢，而沒有RETURN語句的子查詢稱為單元子查詢。

對每個輸入行求值一個子查詢。返回子查詢的每個輸出行都與輸入行組合以構(gòu)建子查詢的結(jié)果。這意味著返回的子查詢將影響行數(shù)。如果子查詢不返回任何行，則子查詢之后將沒有行可用。

另一方面，調(diào)用單元子查詢是因為它們的副作用(即只用于修改，而不用于返回)，而不是因為它們的結(jié)果，因此不會影響封閉查詢的結(jié)果。

子查詢({}中的子句)如何與封閉查詢(外面的子句)交互是有限制的:

  • 子查詢只能引用封閉查詢中的變量，如果它們是顯式導(dǎo)入的。

  • 子查詢不能返回與封閉查詢中的變量名稱相同的變量。

  • 從子查詢返回的所有變量隨后都可以在封閉查詢中使用。

UNWIND [0, 1, 2] AS x
CALL {										//子查詢
  MATCH (n:Counter)
    SET n.count = n.count + 1
  RETURN n.count AS innerCount               //返回的變量
}
WITH innerCount
MATCH (n:Counter)
RETURN
  innerCount,
  n.count AS totalCount
Post-union
CALL {
  MATCH (p:Person)
  RETURN p
  ORDER BY p.age ASC
  LIMIT 1
UNION							//返回結(jié)果集
  MATCH (p:Person)
  RETURN p
  ORDER BY p.age DESC
  LIMIT 1
}
RETURN p.name, p.age
ORDER BY p.name
事務(wù)
LOAD CSV FROM 'file:///friends.csv' AS line
CALL {
  WITH line
  CREATE (:Person {name: line[1], age: toInteger(line[2])})
} IN TRANSACTIONS
                                                      
MATCH (n)
CALL {
  WITH n
  DETACH DELETE n
} IN TRANSACTIONS
事務(wù)批次處理

可以根據(jù)提交當前事務(wù)和開始新事務(wù)之前要處理的輸入行數(shù)來指定每個單獨事務(wù)中要完成的工作量。輸入行數(shù)是用of n rows(或of n ROW)修飾符設(shè)置的。如果省略，默認批處理大小為1000行。行數(shù)可以使用計算結(jié)果為正整數(shù)且不引用節(jié)點或關(guān)系的任何表達式來表示。

LOAD CSV FROM 'file:///friends.csv' AS line
CALL {
  WITH line
  CREATE (:Person {name: line[1], age: toInteger(line[2])})
} IN TRANSACTIONS OF 2 ROWS                                 //2行一個事務(wù)
異常處理

用戶可以從三個不同的選項標志中選擇一個來控制在CALL{…}中的事務(wù):

ON ERROR CONTINUE：忽略可恢復(fù)的錯誤并繼續(xù)執(zhí)行后續(xù)的內(nèi)部事務(wù)。外部事務(wù)成功。它將導(dǎo)致來自失敗的內(nèi)部查詢的預(yù)期變量被綁定為該特定事務(wù)的空值。

ON ERROR BREAK：忽略可恢復(fù)的錯誤并停止后續(xù)內(nèi)部事務(wù)的執(zhí)行。外部事務(wù)成功。它將導(dǎo)致來自失敗內(nèi)部查詢的預(yù)期變量被綁定為空，用于所有后續(xù)事務(wù)(包括失敗的事務(wù))。

ON ERROR FAIL不能確認可恢復(fù)的錯誤并停止后續(xù)內(nèi)部事務(wù)的執(zhí)行。外部事務(wù)失敗。如果沒有顯式指定標志，這是默認行為。

UNWIND [1, 0, 2, 4] AS i
CALL {
  WITH i
  CREATE (n:Person {num: 100/i}) // Note, fails when i = 0
  RETURN n
} IN TRANSACTIONS
  OF 1 ROW
  ON ERROR CONTINUE
RETURN n.num;
狀態(tài)報告

可以使用report status作為變量來報告內(nèi)部事務(wù)的執(zhí)行狀態(tài)，這個標志在ON ERROR FAIL時是不允許的。每次內(nèi)部查詢執(zhí)行完成后(無論成功與否)，都會創(chuàng)建一個狀態(tài)值，記錄有關(guān)執(zhí)行和執(zhí)行它的事務(wù)的信息:

如果內(nèi)部執(zhí)行產(chǎn)生一行或多行作為輸出，則在所選變量名稱下向每一行添加到此狀態(tài)值的綁定。

如果內(nèi)部執(zhí)行失敗，則生成單行，其中包含到所選變量下的此狀態(tài)值的綁定，以及內(nèi)部查詢(如果有的話)應(yīng)該返回的所有變量的空綁定。

狀態(tài)值是一個Map值，包含以下字段:

  • Started:內(nèi)部事務(wù)啟動時為true，否則為false。
  • Committed，當內(nèi)部事務(wù)更改成功提交時為true，否則為false。
  • transactionId:內(nèi)部事務(wù)id，如果事務(wù)沒有啟動，則為空。
  • errorMessage，內(nèi)部事務(wù)錯誤消息，如果沒有錯誤則為null。
UNWIND [1, 0, 2, 4] AS i
CALL {
  WITH i
  CREATE (n:Person {num: 100/i}) // Note, fails when i = 0
  RETURN n
} IN TRANSACTIONS
  OF 1 ROW
  ON ERROR CONTINUE
  REPORT STATUS AS s
RETURN n.num, s;
限制

  • 嵌套的CALL{…}子句不受支持。

  • 不支持UNION中的IN TRANSACTIONS。

  • 不支持在寫子句之后的IN TRANSACTIONS，除非該寫子句是在CALL{…}中。

另外，當在CALL子查詢中使用 WITH子句時，有一些限制:

  • 只有通過with子句導(dǎo)入的變量才能被使用。

  • 在導(dǎo)入的WITH子句中不允許使用表達式或別名。

  • 不可能在導(dǎo)入WITH子句之后加上以下任何子句:DISTINCT、ORDER BY、WHERE、SKIP和LIMIT。

CALL 方法

UNION

USE

Load CSV

  • CSV文件的URL是通過使用FROM指定的，后面跟著一個URL的任意表達式。

  • 需要使用AS為CSV數(shù)據(jù)指定一個變量。

  • CSV文件可以存儲在數(shù)據(jù)庫服務(wù)器上，然后使用file:/// URL訪問。另外，LOAD CSV還支持通過HTTPS、HTTP和FTP訪問CSV文件。

  • LOAD CSV支持使用gzip和Deflate壓縮的資源。此外，LOAD CSV支持本地存儲的CSV文件壓縮與ZIP。

  • LOAD CSV將遵循HTTP重定向，但出于安全原因，它不會遵循更改協(xié)議的重定向，例如，如果重定向從HTTPS轉(zhuǎn)到HTTP。

  • LOAD CSV通常與查詢子句CALL{…}in TRANSACTIONS一起使用。

文件URLs配置

dbms.security.allow_csv_import_from_file_urls：是否支持 file:/// 協(xié)議。默認true。

server.directories.import：file:/// 文件的根目錄，僅對本地文件有效。

CSV文件格式

  • 字符編碼為UTF-8

  • 結(jié)束行終止取決于系統(tǒng)，例如，在Unix上是\n，在windows上是\r\n;

  • 默認的字段結(jié)束符是,

  • 字段結(jié)束符可以通過使用LOAD CSV命令中的FIELDTERMINATOR選項來更改;

  • CSV文件中允許使用帶引號的字符串，并且在讀取數(shù)據(jù)時刪除引號;

  • 字符串引號的字符是雙引號"

  • 如果dbms.import.csv.legacy_quote_escaping設(shè)置為默認值true， \用作轉(zhuǎn)義字符;

  • 雙引號必須位于帶引號的字符串中，并使用轉(zhuǎn)義字符或第二個雙引號進行轉(zhuǎn)義。

導(dǎo)入

LOAD CSV FROM 'file:///artists.csv' AS line                    //給每行命名一個變量
CREATE (:Artist {name: line[1], year: toInteger(line[2])})           //變量通過[]引用屬性
                                                     
LOAD CSV FROM 'https://data.neo4j.com/bands/artists.csv' AS line
CREATE (:Artist {name: line[1], year: toInteger(line[2])})
//第一行為列頭： WITH HEADERS
LOAD CSV WITH HEADERS FROM 'file:///artists-with-headers.csv' AS line
CREATE (:Artist {name: line.Name, year: toInteger(line.Year)})
//自定義 字段分隔符
LOAD CSV FROM 'file:///artists-fieldterminator.csv' AS line FIELDTERMINATOR ';'
CREATE (:Artist {name: line[1], year: toInteger(line[2])})
                                                     
//事務(wù)支持
LOAD CSV FROM 'file:///artists.csv' AS line
CALL {
  WITH line
  CREATE (:Artist {name: line[1], year: toInteger(line[2])})
} IN TRANSACTIONS
//linenumber() 返回行記錄
LOAD CSV FROM 'file:///artists.csv' AS line
RETURN linenumber() AS number, line
// file() 獲取文件path
LOAD CSV FROM 'file:///artists.csv' AS line
RETURN DISTINCT file() AS path

SHOW

SHOW [ALL|BUILT IN|USER DEFINED] FUNCTION[S]
[YIELD { * | field[, ...] } [ORDER BY field[, ...]] [SKIP n] [LIMIT n]]
[WHERE expression]
[RETURN field[, ...] [ORDER BY field[, ...]] [SKIP n] [LIMIT n]]
                                                       
                                                       
SHOW PROCEDURE[S]
[YIELD { * | field[, ...] } [ORDER BY field[, ...]] [SKIP n] [LIMIT n]]
[WHERE expression]
[RETURN field[, ...] [ORDER BY field[, ...]] [SKIP n] [LIMIT n]]
                                                       
SHOW SETTING[S] [setting-name[,...]]
[YIELD { * | field[, ...] } [ORDER BY field[, ...]] [SKIP n] [LIMIT n]]
[WHERE expression]
[RETURN field[, ...] [ORDER BY field[, ...]] [SKIP n] [LIMIT n]]
                                                       
SHOW TRANSACTION[S] [transaction-id[,...]]
[YIELD { * | field[, ...] } [ORDER BY field[, ...]] [SKIP n] [LIMIT n]]
[WHERE expression]
[RETURN field[, ...] [ORDER BY field[, ...]] [SKIP n] [LIMIT n]]
                                                       
TERMINATE TRANSACTION[S] transaction_id[, ...]
[YIELD { * \| field[, ...] }
  [ORDER BY field[, ...]]
  [SKIP n]
  [LIMIT n]
  [WHERE expression]
  [RETURN field[, ...] [ORDER BY field[, ...]] [SKIP n] [LIMIT n]]
]

節(jié)點變量 (Node variables)

如果我們以后想要引用某個節(jié)點，我們可以給它一個變量，比如§代表person或者(t)代表thing。

如果節(jié)點與返回的結(jié)果不相關(guān)，可以使用空括號()指定一個匿名節(jié)點。這意味著您不能在稍后的查詢中返回此節(jié)點。

節(jié)點標簽 (Node labels)

如果您還記得屬性圖數(shù)據(jù)模型，還可以通過分配節(jié)點標簽將相似的節(jié)點分組在一起。標簽允許你指定要查找或創(chuàng)建的特定類型的實體。在我們的示例中，Person、Technology和Company是標簽。

你可以把這想象成告訴SQL在哪個表中查找特定的行。就像告訴SQL從person或Employee或Customer表中查詢一個人的信息一樣，您也可以告訴Cypher只檢查這些信息的標簽。這有助于Cypher區(qū)分實體并優(yōu)化查詢的執(zhí)行。在可能的情況下，在查詢中使用節(jié)點標簽總是更好。

不指定標簽，則會查詢所有節(jié)點，性能會嚴重下降。

()                  //匿名節(jié)點(no label or variable) ，后面不能引用
(p:Person)          //using variable p and label Person
(:Technology)       //no variable, label Technology
(work:Company)      //using variable work and label Company

關(guān)系類型 (Relationship types)

關(guān)系類型對關(guān)系進行分類并添加意義，類似于標簽對節(jié)點進行分組的方式。在我們的屬性圖數(shù)據(jù)模型中，關(guān)系表示節(jié)點如何相互連接和關(guān)聯(lián)。通常可以通過查找動作或動詞來識別數(shù)據(jù)模型中的關(guān)系。

[:LIKES] - makes sense when we put nodes on either side of the relationship (Sally LIKES Graphs)
[:IS_FRIENDS_WITH] - makes sense when we put nodes with it (Sally IS_FRIENDS_WITH John)
[:WORKS_FOR] - makes sense with nodes (Sally WORKS_FOR Neo4j)

關(guān)系變量 (Relationship variables)

想在查詢的后面引用一個關(guān)系，我們可以給它一個變量，比如[r]或[rel]。如果以后不需要引用該關(guān)系，則可以使用兩個破折號--, -->, <--指定匿名關(guān)系。

例如，您可以使用-[rel]->或-[rel:LIKES]->并在稍后的查詢中調(diào)用rel變量來引用關(guān)系及其詳細信息。

如果您忘記了關(guān)系類型前面的冒號(:)，例如-[LIKES]->，它表示一個變量(而不是關(guān)系類型)。由于沒有聲明關(guān)系類型，Cypher搜索所有類型的關(guān)系。

節(jié)點或關(guān)系屬性 (Node or relationship properties)

屬性是名稱-值對，它為節(jié)點和關(guān)系提供了額外的細節(jié)。在Cypher中，我們可以在節(jié)點的括號內(nèi)或關(guān)系的括號內(nèi)使用花括號。然后將屬性的名稱和值放入花括號內(nèi)。我們的示例圖有一個節(jié)點屬性(name)和一個關(guān)系屬性(since)。

Node property: (p:Person {name: 'Sally'})
Relationship property: -[rel:IS_FRIENDS_WITH {since: 2018}]->

屬性可以具有各種數(shù)據(jù)類型的值。

Cypher模式

節(jié)點和關(guān)系構(gòu)成了圖形模式的構(gòu)建塊。這些構(gòu)建塊可以組合在一起來表達簡單或復(fù)雜的模式。模式是圖最強大的功能。在Cypher中，它們可以寫成連續(xù)的路徑，也可以分成更小的模式，并用逗號連接在一起。

要在Cypher中顯示模式，需要將目前所學(xué)的節(jié)點和關(guān)系語法結(jié)合起來。

在Cypher中，該模式類似于下面的代碼。

(p:Person {name: "Sally"})-[rel:LIKES]->(g:Technology {type: "Graphs"})

普通

:guide cypher                                  #

附錄

參考

導(dǎo)入數(shù)據(jù)：https://neo4j.com/docs/getting-started/data-import/

Cypher ：https://neo4j.com/docs/cypher-manual/current/introduction/文章來源地址http://www.zghlxwxcb.cn/news/detail-629731.html

到了這里，關(guān)于neo4j查詢語言Cypher詳解(一)--語法和子句的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！

本文來自互聯(lián)網(wǎng)用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務(wù)，不擁有所有權(quán)，不承擔相關(guān)法律責任。如若轉(zhuǎn)載，請注明出處： 如若內(nèi)容造成侵權(quán)/違法違規(guī)/事實不符，請點擊違法舉報進行投訴反饋，一經(jīng)查實，立即刪除！

領(lǐng)支付寶紅包贊助服務(wù)器費用

相關(guān)文章

覺得文章有用就打賞一下文章作者

支付寶掃一掃打賞

博客贊助

微信掃一掃打賞

請作者喝杯咖啡吧~博客贊助

支付寶掃一掃領(lǐng)取紅包，優(yōu)惠每天領(lǐng)

二維碼1

領(lǐng)取紅包

二維碼2

領(lǐng)紅包