数据库一文了解各大图数据库查询语言

【金融特辑】光大银行科技部DBA女神带你从0到1揭秘MGR

文章的开头我们先来看下什么是图数据库，根据维基百科的定义：图数据库是使用图结构进行语义查询的数据库，它使用节点、边和属性来表示和存储数据。

虽然和关系型数据库存储的结构不同（关系型数据库为表结构，图数据库为图结构），但不计各自的性能问题，关系型数据库可以通过递归查询或者组合其他 SQL 语句（Join）完成图查询语言查询节点关系操作。得益于 1987 年 SQL 成为国际标准化组织（ISO）标准，关系型数据库行业得到了很好的发展。同 60、70 年代的关系型数据库类似，图数据库这个领域的查询语言目前也没有统一标准，虽然 19 年 9 月经过国际 SQL 标准委员会投票表决，决定将图查询语言（Graph Query Language）纳为一种新的数据库查询语言，但 GQL 的制定仍需要一段时间。

介于市面上没有统一的图查询语言标准，在本文中我们选取市面上主流的几款图查询语言来分析一波用法，由于篇幅原因本文旨在简单介绍图查询语言和常规用法，更详细的内容将在进阶篇中讲述。

图查询语言·介绍

图查询语言 Gremlin

Gremlin 是 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 是一种类 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 中直接

我们可以看到大体上对点和边的叫法类似，只不过 Cypher 中直接使用了 Relationship 关系一词代表边。其他的术语基本都非常直观。

图查询语言·语法篇

了解过 Gremlin、Cypher、nGQL 中常见的术语之后，我们来看看使用这 3 个图查询语言过程中会需要了解的常规语法。

图

1. # Gremlin 创建图  
2. g = TinkerGraph.open().traversal()  
3. # nGQL 创建图空间  
4. CREATE SPACE gods 

点

图结构由点和边组成，一条边连接两个点。在 Gremlin 和 nGQL 中称之为 Vertex，Cypher 则称之为 Node。如何在图数据库中新建一个点呢？可以参考下面的语法

1. # Gremlin 创建/插入点  
2. g.addV(vertexLabel).property()  
3. # Cypher 创建点  
4. CREATE (:nodeLabel {property})  
5. # nGQL 创建/插入点  
6. INSERT VERTEX tagName (propNameList) VALUES vid:(tagKey propValue) 

点类型

点允许有对应的类型，在 Gremlin 和 Cypher 叫 label ，在 nGQL 中为 tag 。点类型可对应有多种属性（Property），例如 _Person _可以有 name、_age _等属性。

创建点类型

点类型相关的语法示例如下：

1. # Gremlin 创建点类型  
2. g.addV(vertexLabel).property()  
3. # nGQL 创建点类型  
4. CREATE tagName(PropNameList) 

这里说明下，无论在 Gremlin 和 nGQL 中存在类似 IF NOT EXISTS  用法，即：如果不存在则创建，存在则直接返回。

查看点类型

创建好点之后如何查看点类型呢，可以参考以下方式。 

1. # Gremlin 查看（获取）点类型  
2. g.V().label().dedup();  
3. # Cypher 查看点类型方法 1  
4. MATCH (n)   
5. RETURN DISTINCT labels(n)  
6. # Cypher 查看点类型方法 2  
7. CALL db.labels();  
8. # nGQL 查看点类型  
9. SHOW TAGS 

点的 CRUD

上面简单介绍了点、点类型，下面进入数据库基本 DML——CRUD，在上文介绍点时顺便介绍了点的创建和插入，这里说下如何插入特定类型的点，和点的获取、删除和更新。

插入特定类型点

和插入点的操作类似，只不过需要指定某种点类型。语法参考：

1. # Gremlin 插入特定类型点  
2. g.addV(String vertexLabel).property()  
3. # Cypher 插入特定类型点  
4. CREATE (node:label)   
5. # nGQL 插入特定类型点 
6.  INSERT VERTEX <tag_name> (prop_name_list) VALUES <vid>:(prop_value_list) 

查看点

1. # Gremlin 查看点  
2. g.V(<vid>)  
3. # Cypher 查看点  
4. MATCH (n)   
5. WHERE condition  
6. RETURN properties(n)  
7. # nGQL 查看点  
8. FETCH PROP ON <tag_name> <vid> 

删除点

术语篇中提过 nGQL 中删除操作对应单词有 Delete 和 Drop ，在 nGQL 中 Delete 一般用于点边，Drop 用于 Schema 删除，这点和 SQL 的设计思路是一样的。

1. # Gremlin 删除点  
2. g.V(<vid>).drop()  
3. # Cypher 删除点  
4. MATCH (node:label)   
5. DETACH DELETE node  
6. # nGQL 删除点  
7. DELETE VERTEX <vid> 

更新点

用数据库的小伙伴都知道数据的常态是数据变更，来瞅瞅这 3 个图查询是使用什么语法来更新点数据的吧

1. # Gremlin 更新点  
2. g.V(<vid>).property()  
3. # Cypher 更新点  
4. SET n.prop = V  
5. # nGQL 更新点  
6. UPDATE VERTEX <vid> SET <update_columns> 

可以看到 Cypher 和 nGQL 都使用 SET 关键词来设置点对应的类型值，只不过 nGQL 中多了 UPDATE 关键词来标识操作，Gremlin 的操作和上文提到的查看点类似，只不过增加了变更 property 值操作。

边

在 Gremlin 和 nGQL 称呼边为 Edge，而 Cypher 称之为 Relationship。下面进入到边相关的语法内容

边类型 

和点一样，边也可以有对应的类型

1. # Gremlin 创建边类型  
2. g.edgeLabel()  
3. # nGQL 创建边类型  
4. CREATE EDGE edgeTypeName(propNameList) 

边的 CRUD

说完边类型应该进入到边的常规操作部分了

插入指定边类型的边

可以看到和点的使用语法类似，只不过在 Cypher 和 nGQL 中分别使用 -[]-> 和 -> 来表示关系，而 Gremlin 则用 to() 关键词来标识指向关系，在使用这 3 种图查询语言的图数据库中的边均为有向边，下图左边为有向边，右边为无向边。

1. # Gremlin 插入指定边类型的边  
2. g.addE(String edgeLabel).from(v1).to(v2).property()  
3. # Cypher 插入指定边类型的边  
4. CREATE (<node1-name>:<label1-name>)-  
5.   [(<relationship-name>:<relationship-label-name>)]  
6.   ->(<node2-name>:<label2-name>)  
7. # nGQL 插入指定边类型的边  
8. INSERT EDGE <edge_name> (<prop_name_list>) VALUES <src_vid> -> <dst_vid>: \\  
9. (<prop_value_list>) 

删除边

1. # Gremlin 删除边  
2. g.E(<eid>).drop()  
3. # Cypher 删除边  
4. MATCH (<node1-name>:<label1-name>)-[r:relationship-label-name]->()  
5. DELETE r  
6. # nGQL 删除边  
7. DELETE EDGE <edge_type> <src_vid> -> <dst_vid> 

查看指定边

1. # Gremlin 查看指定边  
2. g.E(<eid>)  
3. # Cypher 查看指定边  
4. MATCH (n)-[r:label]->()  
5. WHERE condition  
6. RETURN properties(r)  
7. # nGQL 查看指定边  
8. FETCH PROP ON <edge_name> <src_vid> -> <dst_vid> 

其他操作

除了常规的点、边 CRUD 外，我们可以简单看看这 3 种图查询语言的组合查询。

指定点查指定边

1. # Gremlin 指定点查指定边  
2. g.V(<vid>).outE(<edge>)  
3. # Cypher 指定点查指定边  
4. Match (n)->[r:label]->[]  
5. WHERE id(n) = vid  
6. RETURN r  
7. # nGQL 指定点查指定边  
8. GO FROM <vid> OVER <edge> 

沿指定点反向查询指定边

在反向查询中，Gremlin 使用了 in 来表示反向关系，而 Cypher 则更直观的将指向箭头反向变成 <- 来表示反向关系，nGQL 则用关键词 REVERSELY 来标识反向关系。

1. # Gremlin 沿指定点反向查询指定边  
2. g.V(<vid>).inE(<edge>)  
3. # Cypher 沿指定点反向查询指定边  
4. MATCH (n)<-[r:label]-()  
5. # nGQL 沿指定点反向查询指定边  
6. GO FROM <vid> OVER <edge> REVERSELY 

无向遍历

如果在图中，边的方向不重要（正向、反向都可以），那 Gremlin 使用 both() ，Cypher 使用 -[]- ，nGQL使用关键词 BIDIRECT 。

1. # Traverse edges with specified vertices Gremlin  
2. g.V(<vid>).bothE(<edge>)  
3. # Traverse edges with specified vertices Cypher  
4. MATCH (n)-[r:label]-()  
5. # Traverse edges with specified vertices nGQL  
6. GO FROM <vid>  OVER <edge> BIDIRECT 

沿指定点查询指定边 N 跳

Gremlin 和 nGQL 分别用 times 和 step 来表示 N 跳关系，而 Cypher 用 relationship*1..N 来表示 N 跳关系。

1. # Gremlin 沿指定点查询指定边 N 跳  
2. g.V(<vid>).repeat(out(<edge>)).times(N)  
3. # Cypher 沿指定点查询指定边 N 跳  
4. MATCH (n)-[r:label*N]->()  
5. WHERE condition  
6. RETURN r  
7. # nGQL 沿指定点查询指定边 N 跳  
8. GO N STEPS FROM <vid> OVER <edge> 

返回指定两点路径

1. # Gremlin 返回指定两点路径  
2. g.V(<vid>).repeat(out()).until(<vid>).path()  
3. # Cypher 返回指定两点路径  
4. MATCH p =(a)-[.*]->(b)  
5. WHERE condition  
6. RETURN p  
7. # nGQL 返回指定两点路径  
8. FIND ALL PATH FROM <vid> TO <vid> OVER * 

图查询语言·实操篇

说了一通语法之后，是时候展示真正的技术了——来个具体一点的例子。

示例图：The Graphs of Gods

实操示例使用了 Janus Graph 的示例图 The Graphs of Gods。该图结构如下图所示，描述了罗马万神话中诸神关系。

插入数据

1. # 插入点  
2. ## nGQL  
3. nebula> INSERT VERTEX character(name, age, type) VALUES hash("saturn"):("saturn", 10000, "titan"), hash("jupiter"):("jupiter", 5000, "god");  
4. ## Gremlin  
5. gremlin> saturn = g.addV("character").property(T.id, 1).property('name', 'saturn').property('age', 10000).property('type', 'titan').next();  
6. ==>v[1]  
7. gremlin> jupiter = g.addV("character").property(T.id, 2).property('name', 'jupiter').property('age', 5000).property('type', 'god').next();  
8. ==>v[2]  
9. gremlin> prometheus = g.addV("character").property(T.id, 31).property('name',  'prometheus').property('age', 1000).property('type', 'god').next();  
10. ==>v[31]  
11. gremlin> jesus = g.addV("character").property(T.id, 32).property('name',  'jesus').property('age', 5000).property('type', 'god').next();  
12. ==>v[32]  
13. ## Cypher  
14. cypher> CREATE (src:character {name:"saturn", age: 10000, type:"titan"})  
15. cypher> CREATE (dst:character {name:"jupiter", age: 5000, type:"god"})   
16. # 插入边  
17. ## nGQL  
18. nebula> INSERT EDGE father() VALUES hash("jupiter")->hash("saturn"):();  
19. ## Gremlin  
20. gremlin> g.addE("father").from(jupiter).to(saturn).property(T.id, 13);  
21. ==>e[13][2-father->1]  
22. ## Cypher  
23. cypher> CREATE (src)-[rel:father]->(dst) 

删除数据

1. # nGQL  
2. nebula> DELETE VERTEX hash("prometheus");  
3. # Gremlin  
4. gremlin> g.V(prometheus).drop();  
5. # Cypher  
6. cypher> MATCH (n:character {name:"prometheus"}) DETACH DELETE n  

更新数据

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

查看数据

1. # nGQL  
2. nebula> FETCH PROP ON character hash("saturn");  
3. ===================================================  
4. | character.name | character.age | character.type |  
5. ===================================================  
6. | saturn         | 10000         | titan          |  
7. ---------------------------------------------------  
8. # Gremlin  
9. gremlin> g.V(saturn).valueMap();  
10. ==>[name:[saturn],type:[titan],age:[10000]]  
11. # Cypher  
12. cypher> MATCH (n:character {name:"saturn"}) RETURN properties(n)  
13.   ╒════════════════════════════════════════════╕  
14.   │"properties(n)"                             │  
15.   ╞════════════════════════════════════════════╡  
16.   │{"name":"saturn","type":"titan","age":10000}│  
17.   └────────────────────────────────────────────┘ 

查询 hercules 的父亲

1. # nGQL  
2. nebula>  LOOKUP ON character WHERE character.name == 'hercules' | \\  
3.       -> GO FROM $-.VertexID OVER father YIELD $$.character.name;  
4. =====================  
5. | $$.character.name |  
6. =====================  
7. | jupiter           |  
8. ---------------------  
9. # Gremlin  
10. gremlin> g.V().hasLabel('character').has('name','hercules').out('father').values('name');  
11. ==>jupiter 
12.  # Cypher  
13. cypher> MATCH (src:character{name:"hercules"})-[:father]->(dst:character) RETURN dst.name  
14.       ╒══════════╕  
15.       │"dst.name"│  
16.       ╞══════════╡  
17.       │"jupiter" │  
18.       └──────────┘ 

查询 hercules 的祖父

1. # nGQL  
2. nebula> LOOKUP ON character WHERE character.name == 'hercules' | \\  
3.      -> GO 2 STEPS FROM $-.VertexID OVER father YIELD $$.character.name;  
4. =====================  
5. | $$.character.name |  
6. =====================  
7. | saturn            |  
8. ---------------------  
9. # Gremlin  
10. gremlin> g.V().hasLabel('character').has('name','hercules').out('father').out('father').values('name');  
11. ==>saturn  
12. # Cypher  
13. cypher> MATCH (src:character{name:"hercules"})-[:father*2]->(dst:character) RETURN dst.name  
14.       ╒══════════╕  
15.       │"dst.name"│  
16.       ╞══════════╡  
17.       │"saturn"  │  
18.       └──────────┘ 

查询年龄大于 100 的人物

1. # nGQL  
2. nebula> LOOKUP ON character WHERE character.age > 100 YIELD character.name, character.age;  
3. =========================================================  
4. | VertexID             | character.name | character.age |  
5. =========================================================  
6. | 6761447489613431910  | pluto          | 4000          |  
7. ---------------------------------------------------------  
8. | -5860788569139907963 | neptune        | 4500          |  
9. ---------------------------------------------------------  
10. | 4863977009196259577  | jupiter        | 5000          |  
11. ---------------------------------------------------------  
12. | -4316810810681305233 | saturn         | 10000         |  
13. ---------------------------------------------------------  
14. # Gremlin  
15. gremlin> g.V().hasLabel('character').has('age',gt(100)).values('name');  
16. ==>saturn  
17. ==>jupiter  
18. ==>neptune  
19. ==>pluto  
20. # Cypher  
21. cypher> MATCH (src:character) WHERE src.age > 100 RETURN src.name  
22.       ╒═══════════╕  
23.       │"src.name" │  
24.       ╞═══════════╡  
25.       │  "saturn" │  
26.       ├───────────┤  
27.       │ "jupiter" │  
28.       ├───────────┤  
29.       │ "neptune" │  
30.       │───────────│  
31.       │  "pluto"  │  
32.       └───────────┘ 

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

1. # nGQL  
2. nebula>  GO FROM hash("pluto") OVER lives YIELD lives._dst AS place | GO FROM $-.place OVER lives REVERSELY WHERE \\  
3. $$.character.name != "pluto" YIELD $$.character.name AS cohabitants;  
4. ===============  
5. | cohabitants |  
6. ===============  
7. | cerberus    |  
8. ---------------  
9. # Gremlin  
10. gremlin> g.V(pluto).out('lives').in('lives').where(is(neq(pluto))).values('name');  
11. ==>cerberus  
12. # Cypher  
13. cypher> MATCH (src:character{name:"pluto"})-[:lives]->()<-[:lives]-(dst:character) RETURN dst.name  
14.       ╒══════════╕  
15.       │"dst.name"│  
16.       ╞══════════╡  
17.       │"cerberus"│  
18.       └──────────┘ 

Pluto 的兄弟们

1. # which brother lives in which place?  
2. ## nGQL  
3. nebula> GO FROM hash("pluto") OVER brother YIELD brother._dst AS god | \\  
4. GO FROM $-.god OVER lives YIELD $^.character.name AS Brother, $$.location.name AS Habitations;  
5. =========================  
6. | Brother | Habitations |  
7. =========================  
8. | jupiter | sky         |  
9. -------------------------  
10. | neptune | sea         |  
11. -------------------------  
12. ## Gremlin  
13. gremlin> g.V(pluto).out('brother').as('god').out('lives').as('place').select('god','place').by('name');  
14. ==>[god:jupiter, place:sky]  
15. ==>[god:neptune, place:sea]  
16. ## Cypher  
17. cypher> MATCH (src:Character{name:"pluto"})-[:brother]->(bro:Character)-[:lives]->(dst)  
18. RETURN bro.name, dst.name  
19.       ╒═════════════════════════╕  
20.       │"bro.name"    │"dst.name"│  
21.       ╞═════════════════════════╡  
22.       │ "jupiter"    │  "sky"   │  
23.       ├─────────────────────────┤  
24.       │ "neptune"    │ "sea"    │  
25.       └─────────────────────────┘  
    数据库(Database)是按照 数据结构来组织、 存储和管理数据的建立在计算机存储设备上的仓库。
    
    简单来说是本身可视为 电子化的文件柜——存储电子 文件的处所，用户可以对文件中的数据进行新增、截取、更新、删除等操作。