一文了解各大数据库查询语言（Gremlin vs Cypher vs nGQL操作篇(1)

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

查看点

---

Gremlin 查看点

g.V()

Cypher 查看点

MATCH (n)

WHERE condition

RETURN properties(n)

nGQL 查看点

FETCH PROP ON <tag_name>

删除点

---

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

Gremlin 删除点

g.V().drop()

Cypher 删除点

MATCH (node:label)

DETACH DELETE node

nGQL 删除点

DELETE VERTEX

更新点

---

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

Gremlin 更新点

g.V().property()

Cypher 更新点

SET n.prop = V

nGQL 更新点

UPDATE VERTEX SET <update_columns>

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

边

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

边类型

---

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

Gremlin 创建边类型

g.edgeLabel()

nGQL 创建边类型

CREATE EDGE edgeTypeName(propNameList)

边的 CRUD

---

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

插入指定边类型的边

---

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

Gremlin 插入指定边类型的边

g.addE(String edgeLabel).from(v1).to(v2).property()

Cypher 插入指定边类型的边

CREATE (:)-

[(:)]

->(:)

nGQL 插入指定边类型的边

INSERT EDGE <edge_name> (<prop_name_list>) VALUES <src_vid> -> <dst_vid>: \

(<prop_value_list>)

删除边

---

Gremlin 删除边

g.E().drop()

Cypher 删除边

MATCH (:)-[r:relationship-label-name]->()

DELETE r

nGQL 删除边

DELETE EDGE <edge_type> <src_vid> -> <dst_vid>

查看指定边

---

Gremlin 查看指定边

g.E()

Cypher 查看指定边

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

WHERE condition

RETURN properties®

nGQL 查看指定边

FETCH PROP ON <edge_name> <src_vid> -> <dst_vid>

其他操作

---

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

指定点查指定边

---

Gremlin 指定点查指定边

g.V().outE()

Cypher 指定点查指定边

Match (n)->[r:label]->[]

WHERE id(n) = vid

RETURN r

nGQL 指定点查指定边

GO FROM OVER

沿指定点反向查询指定边

---

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

Gremlin 沿指定点反向查询指定边

g.V().inE()

Cypher 沿指定点反向查询指定边

MATCH (n)<-[r:label]-()

nGQL 沿指定点反向查询指定边

GO FROM OVER REVERSELY

无向遍历

---

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

Traverse edges with specified vertices Gremlin

g.V().bothE()

Traverse edges with specified vertices Cypher

MATCH (n)-[r:label]-()

Traverse edges with specified vertices nGQL

GO FROM OVER BIDIRECT

沿指定点查询指定边 N 跳

---

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

Gremlin 沿指定点查询指定边 N 跳

g.V().repeat(out()).times(N)

Cypher 沿指定点查询指定边 N 跳

MATCH (n)-[r:label*N]->()

WHERE condition

RETURN r

nGQL 沿指定点查询指定边 N 跳

GO N STEPS FROM OVER

返回指定两点路径

---

Gremlin 返回指定两点路径

g.V().repeat(out()).until().path()

Cypher 返回指定两点路径

MATCH p =(a)-[.*]->(b)

WHERE condition

RETURN p

nGQL 返回指定两点路径

FIND ALL PATH FROM TO OVER *

图查询语言·实操篇

---

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

示例图：The Graphs of Gods

---

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

插入数据

---

插入点

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)

删除数据

---

nGQL

nebula> DELETE VERTEX hash(“prometheus”);

Gremlin

gremlin> g.V(prometheus).drop();

Cypher

cypher> MATCH (n:character {name:“prometheus”}) DETACH DELETE n

更新数据

---

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

查看数据

---

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 的父亲

---

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 的祖父

---

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

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

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

[外链图片转存中…(img-HaSMtBop-1715375075035)]
[外链图片转存中…(img-inmb7p7L-1715375075036)]
[外链图片转存中…(img-NJM31lFG-1715375075036)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取