文章的開頭我們先來看下什麼是圖資料庫，根據維基百科的定義：**圖資料庫是使用圖結構進行語義查詢的資料庫，它使用節點、邊和屬性來表示和儲存資料**。

雖然和關係型資料庫儲存的結構不同（關係型資料庫為表結構，圖資料庫為圖結構），但不計各自的效能問題，關係型資料庫可以透過遞迴查詢或者組合其他 SQL 語句（Join）完成圖查詢語言查詢節點關係操作。得益於 1987 年 SQL 成為國際標準化組織（ISO）標準，關係型資料庫行業得到了很好的發展。同 60、70 年代的關係型資料庫類似，圖資料庫這個領域的查詢語言目前也沒有統一標準，雖然 19 年 9 月經過國際 SQL 標準委員會投票表決，決定將圖查詢語言（Graph Query Language）納為一種新的資料庫查詢語言，但 GQL 的制定仍需要一段時間。

![image](https://user-images.githubusercontent.com/38887077/75741236-f357d380-5d44-11ea-8c43-65283b49bbef.png)

介於市面上沒有統一的圖查詢語言標準，在本文中我們選取市面上主流的幾款圖查詢語言來分析一波用法，由於篇幅原因本文旨在簡單介紹圖查詢語言和常規用法，更詳細的內容將在進階篇中講述。

## 圖查詢語言·介紹

![image](https://user-images.githubusercontent.com/38887077/75741240-f5ba2d80-5d44-11ea-80f6-f44d39fff43a.png)

### 圖查詢語言 Gremlin

[Gremlin](https://tinkerpop.apache.org/gremlin.html) 是 Apache ThinkerPop 框架下的圖遍歷語言。Gremlin 可以是**宣告性**的也可以是**命令性**的。雖然 Gremlin 是基於 Groovy 的，但具有許多語言變體，允許開發人員以 Java、JavaScript、Python、Scala、Clojure 和 Groovy 等許多現代程式語言**原生編寫 Gremlin 查詢**。

支援圖資料庫：Janus Graph、InfiniteGraph、Cosmos DB、DataStax Enterprise(5.0+)	、Amazon Neptune

### 圖查詢語言 Cypher

Cypher 是一個描述性的圖形查詢語言，允許不必編寫圖形結構的遍歷程式碼對圖形儲存有表現力和效率的查詢，和 SQL 很相似，Cypher 語言的關鍵字不區分大小寫，但是屬性值，標籤，關係型別和變數是區分大小寫的。

支援圖資料庫： Neo4j、RedisGraph、AgensGraph

### 圖查詢語言 nGQL

[nGQL](https://github.com/vesoft-inc/nebula/blob/master/docs/manual-CN/1.overview/1.concepts/2.nGQL-overview.md) 是一種類 SQL 的宣告型的文字查詢語言，nGQL 同樣是關鍵詞大小寫不敏感的查詢語言，目前支援模式匹配、聚合運算、圖計算，可無嵌入組合語句。

支援圖資料庫：Nebula Graph

## 圖查詢語言·術語篇

在比較這 3 個圖查詢語言之前，我們先來看看他們各自的術語，如果你翻閱他們的文件會經常見到下面這些“關鍵字”，在這裡我們不講用法，只看這些圖資料庫常用概念在這 3 個圖資料庫文件中的叫法。

| 術語 | Gremlin | Cypher | nGQL |
| --- | --- | --- | --- |
| 點 | Vertex | Node | Vertex |
| 邊 | Edge | Relationship | Edge |
| 點型別 | Label | Label | Tag |
| 邊型別 | label | RelationshipType | edge type |
| 點 ID | vid | id(n) | vid |
| 邊 ID | eid | id(r) | 無 |
| 插入 | add | create | insert |
| 刪除 | drop | delete | delete / drop |
| 更新屬性 | setProperty | set | update |

我們可以看到大體上對點和邊的叫法類似，只不過 Cypher 中直接使用了 Relationship 關係一詞代表邊。其他的術語基本都非常直觀。

## 圖查詢語言·語法篇

瞭解過 Gremlin、Cypher、nGQL 中常見的術語之後，我們來看看使用這 3 個圖查詢語言過程中會需要了解的常規語法。

### 圖

```shell
# Gremlin 建立圖
g = TinkerGraph.open().traversal()

# nGQL 建立圖空間
CREATE SPACE gods
```

### 點
圖結構由點和邊組成，一條邊連線兩個點。在 Gremlin 和 nGQL 中稱之為 Vertex，Cypher 則稱之為 Node。如何在圖資料庫中新建一個點呢？可以參考下面的語法

```shell
# Gremlin 建立/插入點
g.addV(vertexLabel).property()

# Cypher 建立點
CREATE (:nodeLabel {property})

# nGQL 建立/插入點
INSERT VERTEX tagName (propNameList) VALUES vid:(tagKey propValue)
```

#### 點型別

點允許有對應的型別，在 Gremlin 和 Cypher 叫 `label` ，在 nGQL 中為 `tag` 。點型別可對應有多種屬性（Property），例如 _Person _可以有 _name_、_age _等屬性。

![image](https://user-images.githubusercontent.com/38887077/75741241-f8b51e00-5d44-11ea-8a39-b02a88de44a3.png)

##### 建立點型別

點型別相關的語法示例如下：

```shell
# Gremlin 建立點型別
g.addV(vertexLabel).property()

# nGQL 建立點型別
CREATE tagName(PropNameList)
```

這裡說明下，無論在 Gremlin 和 nGQL 中存在類似 `IF NOT EXISTS`  用法，即：如果不存在則建立，存在則直接返回。

##### 檢視點型別

建立好點之後如何檢視點型別呢，可以參考以下方式。

```shell
# Gremlin 檢視（獲取）點型別
g.V().label().dedup();

# Cypher 檢視點型別方法 1
MATCH (n) 
RETURN DISTINCT labels(n)
# Cypher 檢視點型別方法 2
CALL db.labels();

# nGQL 檢視點型別
SHOW TAGS
```

#### 點的 CRUD

上面簡單介紹了點、點型別，下面進入資料庫基本 DML——CRUD，在上文介紹點時順便介紹了點的建立和插入，這裡說下如何插入特定型別的點，和點的獲取、刪除和更新。

##### 插入特定型別點

和插入點的操作類似，只不過需要指定某種點型別。語法參考：
```shell
# Gremlin 插入特定型別點
g.addV(String vertexLabel).property()

# Cypher 插入特定型別點
CREATE (node:label)

# nGQL 插入特定型別點
INSERT VERTEX <tag_name> (prop_name_list) VALUES <vid>:(prop_value_list)
```

##### 檢視點

```shell
# Gremlin 檢視點
g.V(<vid>)

# Cypher 檢視點
MATCH (n) 
WHERE condition
RETURN properties(n)

# nGQL 檢視點
FETCH PROP ON <tag_name> <vid>
```

##### 刪除點

術語篇中提過 nGQL 中刪除操作對應單詞有 `Delete` 和 `Drop` ，在 nGQL 中 Delete 一般用於點邊，Drop 用於 Schema 刪除，這點和 SQL 的設計思路是一樣的。
```shell
# Gremlin 刪除點
g.V(<vid>).drop()

# Cypher 刪除點
MATCH (node:label) 
DETACH DELETE node

# nGQL 刪除點
DELETE VERTEX <vid>
```

##### 更新點

用資料庫的小夥伴都知道資料的常態是資料變更，來瞅瞅這 3 個圖查詢是使用什麼語法來更新點資料的吧

```shell
# Gremlin 更新點
g.V(<vid>).property()

# Cypher 更新點
SET n.prop = V

# nGQL 更新點
UPDATE VERTEX <vid> SET <update_columns>
```

可以看到 Cypher 和 nGQL 都使用 SET 關鍵詞來設定點對應的型別值，只不過 nGQL 中多了 UPDATE 關鍵詞來標識操作，Gremlin 的操作和上文提到的檢視點類似，只不過增加了變更 property 值操作。

### 邊

在 Gremlin 和 nGQL 稱呼邊為 Edge，而 Cypher 稱之為 Relationship。下面進入到邊相關的語法內容

#### 邊型別

和點一樣，邊也可以有對應的型別

```shell
# Gremlin 建立邊型別
g.edgeLabel()

# nGQL 建立邊型別
CREATE EDGE edgeTypeName(propNameList)
```

#### 邊的 CRUD

說完邊型別應該進入到邊的常規操作部分了

##### 插入指定邊型別的邊

可以看到和點的使用語法類似，只不過在 Cypher 和 nGQL 中分別使用 `-[]->` 和 `->` 來表示關係，而 Gremlin 則用 `to()` 關鍵詞來標識指向關係，在使用這 3 種圖查詢語言的圖資料庫中的邊均為有向邊，下圖左邊為有向邊，右邊為無向邊。

![image](https://user-images.githubusercontent.com/38887077/75741248-fbb00e80-5d44-11ea-9c80-0c11fd41a277.png)

```shell
# Gremlin 插入指定邊型別的邊
g.addE(String edgeLabel).from(v1).to(v2).property()

# Cypher 插入指定邊型別的邊
CREATE (<node1-name>:<label1-name>)-
  [(<relationship-name>:<relationship-label-name>)]
  ->(<node2-name>:<label2-name>)

# nGQL 插入指定邊型別的邊
INSERT EDGE <edge_name> (<prop_name_list>) VALUES <src_vid> -> <dst_vid>: \
(<prop_value_list>)
```

##### 刪除邊

```shell
# Gremlin 刪除邊
g.E(<eid>).drop()

# Cypher 刪除邊
MATCH (<node1-name>:<label1-name>)-[r:relationship-label-name]->()
DELETE r

# nGQL 刪除邊
DELETE EDGE <edge_type> <src_vid> -> <dst_vid>
```

##### 檢視指定邊

```shell
# Gremlin 檢視指定邊
g.E(<eid>)

# Cypher 檢視指定邊
MATCH (n)-[r:label]->()
WHERE condition
RETURN properties(r)

# nGQL 檢視指定邊
FETCH PROP ON <edge_name> <src_vid> -> <dst_vid>
```

### 其他操作

除了常規的點、邊 CRUD 外，我們可以簡單看看這 3 種圖查詢語言的組合查詢。

#### 指定點查指定邊

```shell
# Gremlin 指定點查指定邊
g.V(<vid>).outE(<edge>)

# Cypher 指定點查指定邊
Match (n)->[r:label]->[]
WHERE id(n) = vid
RETURN r

# nGQL 指定點查指定邊
GO FROM <vid> OVER <edge>
```

#### 沿指定點反向查詢指定邊

在反向查詢中，Gremlin 使用了 in 來表示反向關係，而 Cypher 則更直觀的將指向箭頭反向變成 `).inE(<edge>)

# Cypher 沿指定點反向查詢指定邊
MATCH (n) OVER <edge> REVERSELY
```

#### 無向遍歷

如果在圖中，邊的方向不重要（正向、反向都可以），那 Gremlin 使用 `both()` ，Cypher 使用 `-[]-` ，nGQL使用關鍵詞 `BIDIRECT` 。

```shell
# Traverse edges with specified vertices Gremlin
g.V(<vid>).bothE(<edge>)

# Traverse edges with specified vertices Cypher
MATCH (n)-[r:label]-()

# Traverse edges with specified vertices nGQL
GO FROM <vid>  OVER <edge> BIDIRECT
```

#### 沿指定點查詢指定邊 N 跳

Gremlin 和 nGQL 分別用 times 和 step 來表示 N 跳關係，而 Cypher 用 `relationship*1..N` 來表示 N 跳關係。
```shell
# Gremlin 沿指定點查詢指定邊 N 跳
g.V(<vid>).repeat(out(<edge>)).times(N)

# Cypher 沿指定點查詢指定邊 N 跳
MATCH (n)-[r:label*N]->()
WHERE condition
RETURN r

# nGQL 沿指定點查詢指定邊 N 跳
GO N STEPS FROM <vid> OVER <edge>
```

#### 返回指定兩點路徑

```shell
# Gremlin 返回指定兩點路徑
g.V(<vid>).repeat(out()).until(<vid>).path()

# Cypher 返回指定兩點路徑
MATCH p =(a)-[.*]->(b)
WHERE condition
RETURN p

# nGQL 返回指定兩點路徑
FIND ALL PATH FROM <vid> TO <vid> OVER *
```

## 圖查詢語言·實操篇

說了一通語法之後，是時候展示真正的技術了——來個具體一點的例子。

### 示例圖：The Graphs of Gods

實操示例使用了 [Janus Graph](https://janusgraph.org/) 的示例圖 [_The Graphs of Gods_](https://docs.janusgraph.org/#getting-started)。該圖結構如下圖所示，描述了羅馬萬神話中諸神關係。

![image](https://user-images.githubusercontent.com/38887077/75741255-ffdc2c00-5d44-11ea-9da6-b15327f03ad4.png)

### 插入資料

```bash
# 插入點
## nGQL
nebula> INSERT VERTEX character(name, age, type) VALUES hash("saturn"):("saturn", 10000, "titan"), hash("jupiter"):("jupiter", 5000, "god");
## Gremlin
gremlin> saturn = g.addV("character").property(T.id, 1).property('name', 'saturn').property('age', 10000).property('type', 'titan').next();
==>v[1]
gremlin> jupiter = g.addV("character").property(T.id, 2).property('name', 'jupiter').property('age', 5000).property('type', 'god').next();
==>v[2]
gremlin> prometheus = g.addV("character").property(T.id, 31).property('name',  'prometheus').property('age', 1000).property('type', 'god').next();
==>v[31]
gremlin> jesus = g.addV("character").property(T.id, 32).property('name',  'jesus').property('age', 5000).property('type', 'god').next();
==>v[32]
## Cypher
cypher> CREATE (src:character {name:"saturn", age: 10000, type:"titan"})
cypher> CREATE (dst:character {name:"jupiter", age: 5000, type:"god"})

# 插入邊
## nGQL
nebula> INSERT EDGE father() VALUES hash("jupiter")->hash("saturn"):();
## Gremlin
gremlin> g.addE("father").from(jupiter).to(saturn).property(T.id, 13);
==>e[13][2-father->1]
## Cypher
cypher> CREATE (src)-[rel:father]->(dst)
```

### 刪除資料

```bash
# nGQL
nebula> DELETE VERTEX hash("prometheus");
# Gremlin
gremlin> g.V(prometheus).drop();
# Cypher
cypher> MATCH (n:character {name:"prometheus"}) DETACH DELETE n 
```

### 更新資料

```bash
# nGQL
nebula> UPDATE VERTEX hash("jesus") SET character.type = 'titan';
# Gremlin
gremlin> g.V(jesus).property('age', 6000);
==>v[32]
# Cypher
cypher> MATCH (n:character {name:"jesus"}) SET n.type = 'titan';
```

### 檢視資料

```bash
# nGQL
nebula> FETCH PROP ON character hash("saturn");
===================================================
| character.name | character.age | character.type |
===================================================
| saturn         | 10000         | titan          |
---------------------------------------------------
# Gremlin
gremlin> g.V(saturn).valueMap();
==>[name:[saturn],type:[titan],age:[10000]]
# Cypher
cypher> MATCH (n:character {name:"saturn"}) RETURN properties(n)
  ╒════════════════════════════════════════════╕
  │"properties(n)"                             │
  ╞════════════════════════════════════════════╡
  │{"name":"saturn","type":"titan","age":10000}│
  └────────────────────────────────────────────┘
```

### 查詢 hercules 的父親

```bash
# nGQL
nebula>  LOOKUP ON character WHERE character.name == 'hercules' | \
      -> GO FROM $-.VertexID OVER father YIELD $$.character.name;
=====================
| $$.character.name |
=====================
| jupiter           |
---------------------
# Gremlin
gremlin> g.V().hasLabel('character').has('name','hercules').out('father').values('name');
==>jupiter
# Cypher
cypher> MATCH (src:character{name:"hercules"})-[:father]->(dst:character) RETURN dst.name
      ╒══════════╕
      │"dst.name"│
      ╞══════════╡
      │"jupiter" │
      └──────────┘
```

### 查詢 hercules 的祖父

```bash
# nGQL
nebula> LOOKUP ON character WHERE character.name == 'hercules' | \
     -> GO 2 STEPS FROM $-.VertexID OVER father YIELD $$.character.name;
=====================
| $$.character.name |
=====================
| saturn            |
---------------------
# Gremlin
gremlin> g.V().hasLabel('character').has('name','hercules').out('father').out('father').values('name');
==>saturn
# Cypher
cypher> MATCH (src:character{name:"hercules"})-[:father*2]->(dst:character) RETURN dst.name
      ╒══════════╕
      │"dst.name"│
      ╞══════════╡
      │"saturn"  │
      └──────────┘
```

### 查詢年齡大於 100 的人物

```bash
# nGQL
nebula> LOOKUP ON character WHERE character.age > 100 YIELD character.name, character.age;
=========================================================
| VertexID             | character.name | character.age |
=========================================================
| 6761447489613431910  | pluto          | 4000          |
---------------------------------------------------------
| -5860788569139907963 | neptune        | 4500          |
---------------------------------------------------------
| 4863977009196259577  | jupiter        | 5000          |
---------------------------------------------------------
| -4316810810681305233 | saturn         | 10000         |
---------------------------------------------------------
# Gremlin
gremlin> g.V().hasLabel('character').has('age',gt(100)).values('name');
==>saturn
==>jupiter
==>neptune
==>pluto
# Cypher
cypher> MATCH (src:character) WHERE src.age > 100 RETURN src.name
      ╒═══════════╕
      │"src.name" │
      ╞═══════════╡
      │  "saturn" │
      ├───────────┤
      │ "jupiter" │
      ├───────────┤
      │ "neptune" │
      │───────────│
      │  "pluto"  │
      └───────────┘
```

### 從一起居住的人物中排除 pluto 本人

```bash
# nGQL
nebula>  GO FROM hash("pluto") OVER lives YIELD lives._dst AS place | GO FROM $-.place OVER lives REVERSELY WHERE \
$$.character.name != "pluto" YIELD $$.character.name AS cohabitants;
===============
| cohabitants |
===============
| cerberus    |
---------------
# Gremlin
gremlin> g.V(pluto).out('lives').in('lives').where(is(neq(pluto))).values('name');
==>cerberus
# Cypher
cypher> MATCH (src:character{name:"pluto"})-[:lives]->() GO FROM hash("pluto") OVER brother YIELD brother._dst AS god | \
GO FROM $-.god OVER lives YIELD $^.character.name AS Brother, $$.location.name AS Habitations;
=========================
| Brother | Habitations |
=========================
| jupiter | sky         |
-------------------------
| neptune | sea         |
-------------------------
## Gremlin
gremlin> g.V(pluto).out('brother').as('god').out('lives').as('place').select('god','place').by('name');
==>[god:jupiter, place:sky]
==>[god:neptune, place:sea]
## Cypher
cypher> MATCH (src:Character{name:"pluto"})-[:brother]->(bro:Character)-[:lives]->(dst)
RETURN bro.name, dst.name
      ╒═════════════════════════╕
      │"bro.name"    │"dst.name"│
      ╞═════════════════════════╡
      │ "jupiter"    │  "sky"   │
      ├─────────────────────────┤
      │ "neptune"    │ "sea"    │
      └─────────────────────────┘
```

## 附錄

- Nebula Graph：一個開源的分散式圖資料庫
- GitHub：[https://github.com/vesoft-inc/nebula](https://0x7.me/itpub2github)
- 官方論壇：[https://discuss.nebula-graph.io](https://discuss.nebula-graph.io)
- 知乎：[zhihu.com/org/nebulagraph/posts](https://www.zhihu.com/org/nebulagraph/posts)
- 微博：[weibo.com/nebulagraph](https://weibo.com/nebulagraph)</vid></vid></vid></vid></edge></vid></edge></vid></edge></vid></edge></vid></edge></edge></edge></vid></edge></vid></dst_vid></src_vid></edge_name></eid></dst_vid></src_vid></edge_type></label1-name></node1-name></eid></prop_value_list></dst_vid></src_vid></prop_name_list></edge_name></label2-name></node2-name></relationship-label-name></relationship-name></label1-name></node1-name></update_columns></vid></vid></vid></vid></vid></tag_name></vid></vid></tag_name>

一文了解各大圖資料庫查詢語言（Gremlin vs Cypher vs nGQL）| 操作入門篇

相關文章