Gremlin 和 nGQL 对比

Gremlin 介绍

Gremlin 是 Apache ThinkerPop 框架下的图遍历语言。Gremlin 可以是声明性的也可以是命令性的。虽然 Gremlin 是基于 Groovy 的，但具有许多语言变体，允许开发人员以 Java、JavaScript、Python、Scala、Clojure 和 Groovy 等许多现代编程语言原生编写 Gremlin 查询。

nGQL 介绍

Nebula Graph 的查询语言为 nGQL， 是一种类 SQL 的声明型的文本查询语言。相比 SQL，nGQL 具有如下特点：

  • 类 SQL，易学易用
  • 可扩展
  • 关键词大小写不敏感
  • 支持图遍历
  • 支持模式匹配
  • 支持聚合运算
  • 支持图计算
  • 支持分布式事务（开发中）
  • 无嵌入支持组合语句，易于阅读

基本概念对比

名称GremlinnGQL
vertex, nodevertexvertex
edge, relationshipedgeedge
vertex typelabeltag
edge typelabeledge type
vertex idvidvid
edge ideid无

Gremlin 和 nGQL 均使用唯一标识符标记顶点和边。在 Nebula Graph 中，用户可以使用指定标识符、哈希或 uuid 函数自动生成标识符。

图基本操作

名称GremlinnGQL
新建图空间g = TinkerGraph.open().traversal()CREATE SPACE gods
查看点类型g.V().label()SHOW TAGS
插入指定类型点g.addV(String vertexLabel).property()INSERT VERTEX <tag_name> (prop_name_list) VALUES <vid>:(prop_value_list)
插入指定类型边g.addE(String edgeLabel).from(v1).to(v2).property()INSERT EDGE <edge_name> ( <prop_name_list> ) VALUES <src_vid> -> <dst_vid>: ( <prop_value_list> )
删除点g.V(<vid>).drop()DELETE VERTEX <vid>
删除边g.E(<vid>).outE(<type>).where(otherV().is(<vid>))drop()DELETE EDGE <edge_type> <src_vid> -> <dst_vid>
更新点属性g.V(<vid>).property()UPDATE VERTEX <vid> SET <update_columns>
查看指定点g.V(<vid>)FETCH PROP ON <tag_name> <vid>
查看指定边g.E(<src_vid> >> <dst_vid>)FETCH PROP ON <edge_name> <src_vid> -> <dst_vid>
沿指定点查询指定边g.V(<vid>).outE( <edge>)GO FROM <vid> OVER <edge>
沿指定点反向查询指定边g.V(<vid>).in( <edge>)GO FROM <vid> OVER <edge> REVERSELY
沿指定点查询指定边 N 跳g.V(<vid>).repeat(out(<edge>)).times(N)GO N STEPS FROM <vid> OVER <edge>
返回指定两点路径g.V(<vid>).repeat(out()).until(<vid>).path()FIND ALL PATH FROM <vid> TO <vid> OVER *

示例查询

本节中的示例使用了 Janus Graph 的示例图 The Graphs of Gods。该图结构如下图所示。此处使用属性图模型描述罗马万神话中诸神关系。

image

  • 插入数据
  1. # 插入点
  2. nebula> INSERT VERTEX character(name, age, type) VALUES hash("saturn"):("saturn", 10000, "titan"), hash("jupiter"):("jupiter", 5000, "god");
  4. gremlin> saturn = g.addV("character").property(T.id, 1).property('name', 'saturn').property('age', 10000).property('type', 'titan').next();
  5. ==>v[1]
  6. gremlin> jupiter = g.addV("character").property(T.id, 2).property('name', 'jupiter').property('age', 5000).property('type', 'god').next();
  7. ==>v[2]
  8. gremlin> prometheus = g.addV("character").property(T.id, 31).property('name',  'prometheus').property('age', 1000).property('type', 'god').next();
  9. ==>v[31]
  10. gremlin> jesus = g.addV("character").property(T.id, 32).property('name',  'jesus').property('age', 5000).property('type', 'god').next();
  11. ==>v[32]
  13. # 插入边
  14. nebula> INSERT EDGE father() VALUES hash("jupiter")->hash("saturn"):();
  15. gremlin> g.addE("father").from(jupiter).to(saturn).property(T.id, 13);
  16. ==>e[13][2-father->1]
  • 删除数据
  1. nebula> DELETE VERTEX hash("prometheus");
  2. gremlin> g.V(prometheus).drop();
  • 更新数据
  1. nebula> UPDATE VERTEX hash("jesus") SET character.type = 'titan';
  2. gremlin> g.V(jesus).property('age', 6000);
  • 查看数据
  1. nebula> FETCH PROP ON character hash("saturn");
  2. ===================================================
  3. | character.name | character.age | character.type |
  4. ===================================================
  5. | saturn         | 10000         | titan          |
  6. ---------------------------------------------------
  8. gremlin> g.V(saturn).valueMap();
  9. ==>[name:[saturn],type:[titan],age:[10000]]
  • 查询 hercules 的祖父
  1. nebula> LOOKUP ON character WHERE character.name == 'hercules' | \
  2.      -> GO 2 STEPS FROM $-.VertexID OVER father YIELD $$.character.name;
  3. =====================
  4. | $$.character.name |
  5. =====================
  6. | saturn            |
  7. ---------------------
  9. gremlin> g.V().hasLabel('character').has('name','hercules').out('father').out('father').values('name');
  10. ==>saturn
  • 查询 hercules 的父亲
  1. nebula> LOOKUP ON character WHERE character.name == 'hercules' | \
  2.      -> GO FROM $-.VertexID OVER father YIELD $$.character.name;
  3. =====================
  4. | $$.character.name |
  5. =====================
  6. | jupiter           |
  7. ---------------------
  9. gremlin> g.V().hasLabel('character').has('name','hercules').out('father').values('name');
  10. ==>jupiter
  • 查询年龄大于 100 的人物
  1. nebula> LOOKUP ON character WHERE character.age > 100 YIELD character.name, character.age;
  2. =========================================================
  3. | VertexID             | character.name | character.age |
  4. =========================================================
  5. | 6761447489613431910  | pluto          | 4000          |
  6. ---------------------------------------------------------
  7. | -5860788569139907963 | neptune        | 4500          |
  8. ---------------------------------------------------------
  9. | 4863977009196259577  | jupiter        | 5000          |
  10. ---------------------------------------------------------
  11. | -4316810810681305233 | saturn         | 10000         |
  12. ---------------------------------------------------------
  14. gremlin> g.V().hasLabel('character').has('age',gt(100)).values('name');
  15. ==>saturn
  16. ==>jupiter
  17. ==>neptune
  18. ==>pluto
  • 查询和 pluto 一起居住的人物
  1. nebula> GO FROM hash("pluto") OVER lives YIELD lives._dst AS place | \
  2. GO FROM $-.place OVER lives REVERSELY YIELD $$.character.name AS cohabitants;
  3. ===============
  4. | cohabitants |
  5. ===============
  6. | pluto       |
  7. ---------------
  8. | cerberus    |
  9. ---------------
  11. gremlin> g.V(pluto).out('lives').in('lives').values('name');
  12. ==>pluto
  13. ==>cerberus
  • 从一起居住的人物中排除 pluto 本人
  1. nebula> GO FROM hash("pluto") OVER lives YIELD lives._dst AS place | GO FROM $-.place OVER lives REVERSELY WHERE \
  2. $$.character.name != "pluto" YIELD $$.character.name AS cohabitants;
  3. ===============
  4. | cohabitants |
  5. ===============
  6. | cerberus    |
  7. ---------------
  9. gremlin> g.V(pluto).out('lives').in('lives').where(is(neq(pluto))).values('name');
  10. ==>cerberus
  • Pluto 的兄弟们
  1. # where do pluto's brothers live?
  3. nebula> GO FROM hash("pluto") OVER brother YIELD brother._dst AS brother | \
  4. GO FROM $-.brother OVER lives YIELD $$.location.name;
  5. ====================
  6. | $$.location.name |
  7. ====================
  8. | sky              |
  9. --------------------
  10. | sea              |
  11. --------------------
  13. gremlin> g.V(pluto).out('brother').out('lives').values('name');
  14. ==>sky
  15. ==>sea
  17. # which brother lives in which place?
  19. nebula> GO FROM hash("pluto") OVER brother YIELD brother._dst AS god | \
  20. GO FROM $-.god OVER lives YIELD $^.character.name AS Brother, $$.location.name AS Habitations;
  21. =========================
  22. | Brother | Habitations |
  23. =========================
  24. | jupiter | sky         |
  25. -------------------------
  26. | neptune | sea         |
  27. -------------------------
  29. gremlin> g.V(pluto).out('brother').as('god').out('lives').as('place').select('god','place').by('name');
  30. ==>[god:jupiter, place:sky]
  31. ==>[god:neptune, place:sea]

高级查询

图探索

  1. # gremlin 版本
  2. gremlin> Gremlin.version();
  3. ==>3.3.5
  5. # 返回所有点
  6. gremlin> g.V();
  7. ==>v[1]
  8. ==>v[2]
  9. ...
  10. nebula> # Coming soon
  12. # 统计点数
  13. gremlin> g.V().count();
  14. ==>12
  15. nebula> # Coming soon
  17. # 按照点边类型统计点边个数
  18. gremlin> g.V().groupCount().by(label);
  19. ==>[character:9,location:3]
  20. gremlin> g.E().groupCount().by(label);
  21. ==>[mother:1,lives:5,father:2,brother:6,battled:3,pet:1]
  22. nebula> # Coming soon
  24. # 返回所有边
  25. gremlin> g.E();
  26. ==>e[13][2-father->1]
  27. ==>e[14][2-lives->3]
  28. ...
  29. nebula> # Coming soon
  31. # 查询所有点类型
  32. gremlin> g.V().label().dedup();
  33. ==>character
  34. ==>location
  36. nebula> SHOW TAGS;
  37. ==================
  38. | ID | Name      |
  39. ==================
  40. | 15 | character |
  41. ------------------
  42. | 16 | location  |
  43. ------------------
  45. # 查询所有边类型
  46. gremlin> g.E().label().dedup();
  47. ==>father
  48. ==>lives
  49. ...
  50. nebula> SHOW EDGES;
  51. ================
  52. | ID | Name    |
  53. ================
  54. | 17 | father  |
  55. ----------------
  56. | 18 | brother |
  57. ----------------
  58. ...
  60. # 查询所有顶点的属性
  61. gremlin> g.V().valueMap();
  62. ==>[name:[saturn],type:[titan],age:[10000]]
  63. ==>[name:[jupiter],type:[god],age:[5000]]
  64. ...
  65. nebula> # Coming soon
  67. # 查询 character 顶点属性
  68. gremlin> g.V().hasLabel('character').valueMap();
  69. ==>[name:[saturn],type:[titan],age:[10000]]
  70. ==>[name:[jupiter],type:[god],age:[5000]]
  71. ...

边的遍历

名称GremlinnGQL
指定点沿指定边的出顶点out(\GO FROM \ OVER \
指定点沿指定边的入顶点in(\GO FROM \ OVER \ REVERSELY
指定点沿指定边的双向顶点both(\GO FROM \ OVER \ BIDIRECT
  1. # 访问某个顶点沿某条边的 OUT 方向邻接点
  2. gremlin> g.V(jupiter).out('brother');
  3. ==>v[8]
  4. ==>v[5]
  5. nebula> GO FROM hash("jupiter") OVER brother;
  6. ========================
  7. | brother._dst         |
  8. ========================
  9. | 6761447489613431910  |
  10. ------------------------
  11. | -5860788569139907963 |
  12. ------------------------
  14. # 访问某个顶点沿某条边的 IN 方向邻接点
  15. gremlin> g.V(jupiter).in('brother');
  16. ==>v[5]
  17. ==>v[8]
  18. nebula> GO FROM hash("jupiter") OVER brother REVERSELY;
  19. =======================
  20. | brother._dst        |
  21. =======================
  22. | 4863977009196259577 |
  23. -----------------------
  24. | 4863977009196259577 |
  25. -----------------------
  27. # 访问某个顶点沿某条边的双向邻接点
  28. gremlin> g.V(jupiter).both('brother');
  29. ==>v[8]
  30. ==>v[5]
  31. ==>v[5]
  32. ==>v[8]
  33. nebula> GO FROM hash("jupiter") OVER brother BIDIRECT;
  34. =======================
  35. | brother._dst        |
  36. =======================
  37. | 6761447489613431910 |
  38. ------------------------
  39. | -5860788569139907963|
  40. | 4863977009196259577 |
  41. -----------------------
  42. | 4863977009196259577 |
  43. -----------------------
  45. # 2度 out 查询
  46. gremlin> g.V(hercules).out('father').out('lives');
  47. ==>v[3]
  48. nebula> GO FROM hash("hercules") OVER father YIELD father._dst AS id | \
  49. GO FROM $-.id OVER lives;
  50. ========================
  51. | lives._dst           |
  52. ========================
  53. | -1121386748834253737 |
  54. ------------------------

has 条件过滤

名称GremlinnGQL
通过 ID 来过滤顶点hasId(\)FETCH PROP ON \
通过 label 和属性的名字和值过滤顶点和边has(\LOOKUP \ | \ WHERE \
  1. # 查询 ID 为 saturn 的顶点
  2. gremlin> g.V().hasId(saturn);
  3. ==>v[1]
  4. nebula> FETCH PROP ON * hash("saturn");
  5. ==========================================================================
  6. | VertexID             | character.name | character.age | character.type |
  7. ==========================================================================
  8. | -4316810810681305233 | saturn         | 10000         | titan          |
  9. --------------------------------------------------------------------------
  11. # 查询 tag 为 character 且 name 属性值为 hercules 的顶点
  13. gremlin> g.V().has('character','name','hercules').valueMap();
  14. ==>[name:[hercules],type:[demigod],age:[30]]
  15. nebula> LOOKUP ON character WHERE character.name == 'hercules' YIELD character.name, character.age, character.type;
  16. =========================================================================
  17. | VertexID            | character.name | character.age | character.type |
  18. =========================================================================
  19. | 5976696804486077889 | hercules       | 30            | demigod        |
  20. -------------------------------------------------------------------------

返回结果限制

名称GremlinnGQL
指定返回结果行数limit()LIMIT
获取后 n 个元素tail()ORDER BY \ DESC LIMIT
跳过前 n 个元素skip()LIMIT \
  1. # 查询前两个顶点
  2. gremlin> g.V().has('character','name','hercules').out('battled').limit(2);
  3. ==>v[9]
  4. ==>v[10]
  5. nebula> GO FROM hash('hercules') OVER battled | LIMIT 2;
  6. =======================
  7. | battled._dst        |
  8. =======================
  9. | 530133512982221454  |
  10. -----------------------
  11. | -695163537569412701 |
  12. -----------------------
  14. # 查询最后一个顶点
  15. gremlin> g.V().has('character','name','hercules').out('battled').values('name').tail(1);
  16. ==>cerberus
  17. nebula> GO FROM hash('hercules') OVER battled YIELD $$.character.name AS name | ORDER BY name | LIMIT 1;
  18. ============
  19. | name     |
  20. ============
  21. | cerberus |
  22. ------------
  24. # 跳过第 1 个元素并返回一个元素
  25. gremlin> g.V().has('character','name','hercules').out('battled').values('name').skip(1).limit(1);
  26. ==>hydra
  27. nebula> GO FROM hash('hercules') OVER battled YIELD $$.character.name AS name | ORDER BY name | LIMIT 1,1;
  28. =========
  29. | name  |
  30. =========
  31. | hydra |
  32. ---------

路径查询

名称GremlinnGQL
所有路径path()FIND ALL PATH
不包含环路simplePath()\
只包含环路cyclicPath()\
最短路径\FIND SHORTEST PATH

注意： Nebula Graph 需要起始点和终点方可返回路径， Gremlin 仅需要起始点。

  1. # pluto 顶点到与其有直接关联的出边顶点的路径
  2. gremlin> g.V().hasLabel('character').has('name','pluto').out().path();
  3. ==>[v[8],v[12]]
  4. ==>[v[8],v[2]]
  5. ==>[v[8],v[5]]
  6. ==>[v[8],v[11]]
  8. # 查询点 pluto 到点 jupiter 的最短路径
  9. nebula> LOOKUP ON character WHERE character.name== "pluto" YIELD character.name AS name | \
  10.     FIND SHORTEST PATH FROM $-.VertexID TO hash("jupiter") OVER *;
  11. ============================================================
  12. | _path_              |
  13. ============================================================
  14. | 6761447489613431910 <brother,0> 4863977009196259577
  15. ------------------------------------------------------------

多度查询

名称GremlinnGQL
指定重复执行的语句repeat()N STEPS
指定重复执行的次数times()N STEPS
指定循环终止的条件until()\
指定收集数据的条件emit()\
  1. # 查询点 pluto 出边邻点
  2. gremlin> g.V().hasLabel('character').has('name','pluto').repeat(out()).times(1);
  3. ==>v[12]
  4. ==>v[2]
  5. ==>v[5]
  6. ==>v[11]
  7. nebula> LOOKUP ON character WHERE character.name== "pluto" YIELD character.name AS name | \
  8.     GO FROM $-.VertexID OVER *;
  9. ================================================================================================================
  10. | father._dst | brother._dst         | lives._dst           | mother._dst | pet._dst            | battled._dst |
  11. ================================================================================================================
  12. | 0           | -5860788569139907963 | 0                    | 0           | 0                   | 0            |
  13. ----------------------------------------------------------------------------------------------------------------
  14. | 0           | 4863977009196259577  | 0                    | 0           | 0                   | 0            |
  15. ----------------------------------------------------------------------------------------------------------------
  16. | 0           | 0                    | -4331657707562925133 | 0           | 0                   | 0            |
  17. ----------------------------------------------------------------------------------------------------------------
  18. | 0           | 0                    | 0                    | 0           | 4594048193862126013 | 0            |
  19. ----------------------------------------------------------------------------------------------------------------
  21. # 查询顶点 hercules 到顶点 cerberus 之间的路径
  22. # 循环的终止条件是遇到名称是 cerberus 的顶点
  23. gremlin> g.V().hasLabel('character').has('name','hercules').repeat(out()).until(has('name', 'cerberus')).path();
  24. ==>[v[6],v[11]]
  25. ==>[v[6],v[2],v[8],v[11]]
  26. ==>[v[6],v[2],v[5],v[8],v[11]]
  27. ...
  28. nebula> # Coming soon
  30. # 查询点 hercules 的所有出边可到达点的路径
  31. # 且终点必须是 character 类型的点
  32. gremlin> g.V().hasLabel('character').has('name','hercules').repeat(out()).emit(hasLabel('character')).path();
  33. ==>[v[6],v[7]]
  34. ==>[v[6],v[2]]
  35. ==>[v[6],v[9]]
  36. ==>[v[6],v[10]]
  37. ...
  38. nebula> # Coming soon
  40. # 查询两顶点 pluto 和 saturn 之间的最短路径
  41. # 且最大深度为 3
  42. gremlin> g.V('pluto').repeat(out().simplePath()).until(hasId('saturn').and().loops().is(lte(3))).hasId('saturn').path();
  43. nebula> FIND SHORTEST PATH FROM hash('pluto') TO hash('saturn') OVER * UPTO 3 STEPS;
  44. =================================================================================================
  45. | _path_              |
  46. =================================================================================================
  47. | 6761447489613431910 <brother,0> 4863977009196259577 <father,0> -4316810810681305233
  48. -------------------------------------------------------------------------------------------------

查询结果排序

名称GremlinnGQL
升序排列order().by()ORDER BY
降序排列order().by(decr)ORDER BY DESC
随机排列order().by(shuffle)\
  1. # 查询 pluto 的兄弟并按照年龄降序排列
  2. gremlin> g.V(pluto).out('brother').order().by('age', decr).valueMap();
  3. ==>[name:[jupiter],type:[god],age:[5000]]
  4. ==>[name:[neptune],type:[god],age:[4500]]
  5. nebula> GO FROM hash('pluto') OVER brother YIELD $$.character.name AS Name, $$.character.age as Age | ORDER BY Age DESC;
  6. ==================
  7. | Name    | Age  |
  8. ==================
  9. | jupiter | 5000 |
  10. ------------------
  11. | neptune | 4500 |
  12. ------------------

Group By

名称GremlinnGQL
对结果集进行分组group().by()GROUP BY
去除相同元素dedup()DISTINCT
对结果集进行分组并统计groupCount()GROUP BY COUNT

注意： GROUP BY 函数只能与 YIELD 语句一起使用。

  1. # 根据顶点类别进行分组并统计各个类别的数量
  2. gremlin> g.V().group().by(label).by(count());
  3. ==>[character:9,location:3]
  4. nebula> # Coming soon
  6. # 查询点 jupiter 出边邻点，使用 name 分组并统计
  7. gremlin> g.V(jupiter).out().group().by('name').by(count());
  8. ==>[sky:1,saturn:1,neptune:1,pluto:1]
  9. nebula> GO FROM hash('jupiter') OVER * YIELD $$.character.name AS Name, $$.character.age as Age, $$.location.name | \
  10. GROUP BY $-.Name YIELD $-.Name, COUNT(*);
  11. ======================
  12. | $-.Name | COUNT(*) |
  13. ======================
  14. |         | 1        |
  15. ----------------------
  16. | pluto   | 1        |
  17. ----------------------
  18. | saturn  | 1        |
  19. ----------------------
  20. | neptune | 1        |
  21. ----------------------
  23. # 查找点 jupiter 出边到达的点并去重
  24. gremlin> g.V(jupiter).out().hasLabel('character').dedup();
  25. ==>v[1]
  26. ==>v[8]
  27. ==>v[5]
  28. nebula> GO FROM hash('jupiter') OVER * YIELD DISTINCT $$.character.name, $$.character.age, $$.location.name;
  29. ===========================================================
  30. | $$.character.name | $$.character.age | $$.location.name |
  31. ===========================================================
  32. | pluto             | 4000             |                  |
  33. -----------------------------------------------------------
  34. | neptune           | 4500             |                  |
  35. -----------------------------------------------------------
  36. | saturn            | 10000            |                  |
  37. -----------------------------------------------------------
  38. |                   | 0                | sky              |
  39. -----------------------------------------------------------

where 条件过滤

名称GremlinnGQL
where 条件过滤where()WHERE

过滤条件对比：

名称GremlinnGQL
等于eq(object)==
不等于neq(object)!=
小于lt(number)<
小于等于lte(number)<=
大于gt(number)>
大于等于gte(number)>=
判断值是否在指定的列表中within(objects…​)udf_is_in()
  1. gremlin> eq(2).test(3);
  2. ==>false
  3. nebula> YIELD 3 == 2;
  4. ==========
  5. | (3==2) |
  6. ==========
  7. | false  |
  8. ----------
  10. gremlin> within('a','b','c').test('d');
  11. ==>false
  12. nebula> YIELD udf_is_in('d', 'a', 'b', 'c');
  13. ======================
  14. | udf_is_in(d,a,b,c) |
  15. ======================
  16. | false              |
  17. ----------------------
  1. # 找出 pluto 和谁住并排队他本人
  2. gremlin> g.V(pluto).out('lives').in('lives').where(is(neq(pluto))).values('name');
  3.  ==>cerberus
  4. nebula> GO FROM hash("pluto") OVER lives YIELD lives._dst AS place | GO FROM $-.place OVER lives REVERSELY WHERE \
  5. $$.character.name != "pluto" YIELD $$.character.name AS cohabitants;
  6. ===============
  7. | cohabitants |
  8. ===============
  9. | cerberus    |
  10. ---------------

逻辑运算

名称GremlinnGQL
Isis()==
Notnot()!=
Andand()AND
Oror()OR
  1. # 查询年龄大于 30 的人物
  2. gremlin> g.V().values('age').is(gte(30));
  3. ==>10000
  4. ==>5000
  5. ==>4500
  6. ==>30
  7. ==>45
  8. ==>4000
  9. nebula> LOOKUP ON character WHERE character.age >= 30 YIELD character.age;
  10. ========================================
  11. | VertexID             | character.age |
  12. ========================================
  13. | -4316810810681305233 | 10000         |
  14. ---------------------------------------–
  15. | 4863977009196259577  | 5000          |
  16. ---------------------------------------–
  17. | -5860788569139907963 | 4500          |
  18. ---------------------------------------–
  19. | 5976696804486077889  | 30            |
  20. ---------------------------------------–
  21. | -6780323075177699500 | 45            |
  22. ---------------------------------------–
  23. | 6761447489613431910  | 4000          |
  24. ---------------------------------------–
  26. # 查询名称为 pluto 且年龄为 4000 的人物
  27. gremlin> g.V().has('name','pluto').and().has('age',4000);
  28. ==>v[8]
  29. nebula> LOOKUP ON character WHERE character.name == 'pluto' AND character.age == 4000;
  30. =======================
  31. | VertexID            |
  32. =======================
  33. | 6761447489613431910 |
  34. -----------------------
  36. # 逻辑非的用法
  37. gremlin> g.V().has('name','pluto').out('brother').not(values('name').is('neptune')).values('name');
  38. ==>jupiter
  39. nebula> LOOKUP ON character WHERE character.name == 'pluto' YIELD character.name AS name | \
  40. GO FROM $-.VertexID OVER brother WHERE $$.character.name != 'neptune' YIELD $$.character.name;
  41. =====================
  42. | $$.character.name |
  43. =====================
  44. | jupiter           |
  45. ---------------------

统计运算

名称GremlinnGQL
求和sum()SUM()
最大值max()MAX()
最小值min()MIN()
平均值mean()AVG()

Nebula Graph 统计运算必须同 GROUP BY 一起使用。

  1. # 计算所有 character 的年龄的总和
  2. gremlin> g.V().hasLabel('character').values('age').sum();
  3. ==>23595
  4. nebula> # Coming soon
  6. # 计算所有 character 的 brother 出边数的总和
  7. gremlin> g.V().hasLabel('character').map(outE('brother').count()).sum();
  8. ==>6
  9. nebula> # Coming soon
  11. # 返回所有 character 的年龄中的最大值
  12. gremlin> g.V().hasLabel('character').values('age').max();
  13. ==>10000
  14. nebula> # Coming soon

路径选取与过滤

  1. # 从路径中选取第 1 步和第 3 步的结果作为最终结果
  2. gremlin> g.V(pluto).as('a').out().as('b').out().as('c').select('a','c');
  3. ==>[a:v[8],c:v[3]]
  4. ==>[a:v[8],c:v[1]]
  5. ...
  6. nebula> # Coming soon
  8. # 通过 by() 指定选取的维度
  9. gremlin> g.V(pluto).as('a').out().as('b').out().as('c').select('a','c').by('name');
  10. ==>[a:pluto,c:sky]
  11. ==>[a:pluto,c:saturn]
  12. ...
  13. nebula> # Coming soon
  15. # 从 map 中选择指定 key 的值
  16. gremlin> g.V().valueMap().select('name').dedup();
  17. ==>[saturn]
  18. ==>[jupiter]
  19. ...
  20. nebula> # Coming soon

分支

  1. # 查找所有类型为 'character' 的顶点
  2. # name 属性为 'jupiter' 的顶点输出其 age 属性
  3. # 否则输出顶点的 name 属性
  4. gremlin> g.V().hasLabel('character').choose(values('name')).option('jupiter', values('age')).option(none, values('name'));
  5. ==>saturn
  6. ==>5000
  7. ==>neptune
  8. ...
  10. # Lambda
  11. gremlin> g.V().branch {it.get().value('name')}.option('jupiter', values('age')).option(none, values('name'));
  12. ==>saturn
  13. ==>5000
  14. ...
  16. # Traversal
  17. gremlin> g.V().branch(values('name')).option('jupiter', values('age')).option(none, values('name'));
  18. ==>saturn
  19. ==>5000
  21. # Branch
  22. gremlin> g.V().choose(has('name','jupiter'),values('age'),values('name'));
  23. ==>saturn
  24. ==>5000
  26. # 基于 if then 进行分组
  27. gremlin> g.V().hasLabel("character").groupCount().by(values("age").choose(
  28.            is(lt(40)),constant("young"),
  29.             choose(is(lt(4500)),
  30.                    constant("old"),
  31.                   constant("very old"))));
  32. ==>[young:4,old:2,very old:3]

Nebula Graph 尚无类似功能。

合并

coalesce() 可以接受任意数量的遍历器（traversal），按顺序执行，并返回第一个能产生输出的遍历器的结果。

optional() 只能接受一个遍历器（traversal），如果该遍历器能产生一个结果，则返回该结果，否则返回调用 optionalStep 的元素本身。

union() 可以接受任意数量的遍历器，并能够将各个遍历器的输出合并到一起。

  1. # 如果类型为 monster 则返回类型否则返回 'Not a monster'
  2. gremlin> g.V(pluto).coalesce(has('type','monster').values('type'),constant("Not a monster"));
  3. ==>Not a monster
  5. # 按优先级寻找到顶点 jupiter 的以下边和邻接点，找到一个就停止
  6. # 1、brother 出边和邻接点
  7. # 2、father 出边和邻接点
  8. # 3、father 入边和邻接点
  9. gremlin> g.V(jupiter).coalesce(outE('brother'), outE('father'), inE('father')).inV().path().by('name').by(label);
  10. ==>[jupiter,brother,pluto]
  11. ==>[jupiter,brother,neptune]
  13. # 查找顶点 pluto 的 father 出顶点，如果没有就返回 pluto 自己
  14. gremlin> g.V(pluto).optional(out('father')).valueMap();
  15. ==>[name:[pluto],type:[god],age:[4000]]
  17. # 寻找顶点 pluto 的出 father 顶点，邻接 brother 顶点，并将结果合并，最后打印出路径
  18. gremlin> g.V(pluto).union(out('father'),both('brother')).path();
  19. ==>[v[8],v[2]]
  20. ==>[v[8],v[5]]

Nebula Graph 尚无类似功能。

结果聚集与展开

  1. # 收集第 1 步的结果到集合 x 中
  2. # 注意：不影响后续结果
  3. gremlin> g.V(pluto).out().aggregate('x');
  4. ==>v[12]
  5. ==>v[2]
  6. ...
  8. # 通过 by() 指定聚集的维度
  9. gremlin> g.V(pluto).out().aggregate('x').by('name').cap('x');
  10. ==>[tartarus,jupiter,neptune,cerberus]
  12. # 查询与 pluto 的两度 OUT 邻居
  13. # 并收集这些到 x 集合里面
  14. # 最终以 name 属性展示其邻居
  15. gremlin> g.V(pluto).out().aggregate('x').out().aggregate('x').cap('x').unfold().values('name');
  16. ==>tartarus
  17. ==>tartarus
  18. ...

Nebula Graph 尚无类似功能。

模式匹配

match() 语句为图查询提供了一种基于模式匹配的方式，以便用更具描述性的方式进行图查询。match()语句通过多个模式片段 traversal fragments 来进行模式匹配。这些 traversal fragments 中会定义一些变量，只有满足所有用变量表示的约束的对象才能够通过。

  1. # 对每一个顶点，用以下模式去匹配，满足则生成一个 map<String, Object>，不满足则过滤掉
  2. # 模式1：a 为沿 father 出边指向 jupiter 的顶点
  3. # 模式2：b 对应当前顶点 jupiter
  4. # 模式3：c 对应创建 jupiter 的 brother 年龄为 4000 的 顶点
  5. gremlin> g.V().match(__.as('a').out('father').has('name', 'jupiter').as('b'), __.as('b').in('brother').has('age', 4000).as('c'));
  6. ==>[a:v[6],b:v[2],c:v[8]]
  8. # match() 语句可以与 select() 语句配合使用，从 Map<String, Object> 中选取部分结果
  9. gremlin> g.V().match(__.as('a').out('father').has('name', 'jupiter').as('b'), __.as('b').in('brother').has('age', 4000).as('c')).select('a', 'c').by('name');
  10. ==>[a:hercules,c:pluto]
  12. # match() 语句可以与 where() 语句配合使用，过滤结果
  13. gremlin> g.V().match(__.as('a').out('father').has('name', 'jupiter').as('b'), __.as('b').in('brother').has('age', 4000).as('c')).where('a', neq('c')).select('a', 'c').by('name');
  14. ==>[a:hercules,c:pluto]

随机过滤

sample() 接受一个整数值，从前一步的遍历器中采样（随机）出最多指定数目的结果。

coin() 字面意思是抛硬币过滤，接受一个浮点值，该浮点值表示硬币出现正面的概率。

  1. # 从所有顶点的出边中随机选择 2 条
  2. gremlin> g.V().outE().sample(2);
  3. ==>e[15][2-brother->5]
  4. ==>e[18][5-brother->2]
  6. # 从所顶点的 name 属性中随机选取 3 个
  7. gremlin> g.V().values('name').sample(3);
  8. ==>hercules
  9. ==>sea
  10. ==>jupiter
  12. # 从所有的 character 中根据 age 随机选择 3 个
  13. gremlin> g.V().hasLabel('character').sample(3).by('age');
  14. ==>v[1]
  15. ==>v[2]
  16. ==>v[6]
  18. # 与 local 联合使用做随机漫游
  19. # 从顶点 pluto 出发做 3 次随机漫游
  20. gremlin> g.V(pluto).repeat(local(bothE().sample(1).otherV())).times(3).path();
  21. ==>[v[8],e[26][8-brother->5],v[5],e[18][5-brother->2],v[2],e[13][2-father->1],v[1]]
  23. # 每个顶点按 0.5 的概率过滤
  24. gremlin> g.V().coin(0.5);
  25. ==>v[1]
  26. ==>v[2]
  27. ...
  29. # 输出所有 location 类顶点的 name 属性，否则输出 not a location
  30. gremlin> g.V().choose(hasLabel('location'), values('name'), constant('not a location'));
  31. ==>not a location
  32. ==>not a location
  33. ==>sky
  34. ...

结果存取口袋 Sack

包含本地数据结构的遍历器称为口袋。sack() 将数据放入口袋，或者从口袋取出数据。每个遍历器的每个口袋都是通过 withSack（） 创建的。

  1. # 创建一个包含常数 1 的口袋，并且在最终取出口袋中的值
  2. gremlin> g.withSack(1).V().sack();
  3. ==>1
  4. ==>1
  5. ...

遍历栅栏 barrier

barrier() 在某个位置插入一个栅栏，以强制该位置之前的步骤必须都执行完成才可以继续往后执行。

  1. # 利用隐式 barrier 计算特征向量中心性
  2. # 包括 groupCount、cap，按照降序排序
  3. gremlin> g.V().repeat(both().groupCount('m')).times(5).cap('m').order(local).by(values, decr);

局部操作 local

通过 Gremlin 进行图遍历通常是当前 step 处理前一 step 传递过来的对象流。很多操作是针对传递过来的对象流中的全部对象进行操作，但也有很多时候需要针对对象流中的单个对象而非对象流中的全部对象进行操作。这种对单个对象的局部操作，可以使用 local() 语句实现。

  1. # 不使用 local()
  2. gremlin> g.V().hasLabel('character').as('character').properties('age').order().by(value,decr).limit(2).value().as('age').select('character', 'age').by('name').by();
  3. ==>[character:saturn,age:10000]
  4. ==>[character:jupiter,age:5000]
  6. # 使用 local()
  7. gremlin> g.V().hasLabel('character').as('character').local(properties('age').order().by(value).limit(2)).value().as('age').select('character', 'age').by('name').by()
  8. ==>[character:saturn,age:10000]
  9. ==>[character:jupiter,age:5000]
  10. ==>[character:neptune,age:4500]
  11. ==>[character:hercules,age:30]
  12. ...
  14. # 查询 monster 的属性 map
  15. gremlin> g.V()hasLabel('character').has('type', 'type').propertyMap();
  16. ==>[name:[vp[name->nemean]],type:[vp[type->monster]],age:[vp[age->20]]]
  17. ==>[name:[vp[name->hydra]],type:[vp[type->monster]],age:[vp[age->0]]]
  18. ==>[name:[vp[name->cerberus]],type:[vp[type->monster]],age:[vp[age->0]]]
  20. # 查询 monster 的属性个数
  21. gremlin> g.V()hasLabel('character').has('type', 'monster').propertyMap().count(local);
  22. ==>3
  23. ==>3
  24. ==>3
  26. # 数目最多的顶点类型的顶点数目
  27. gremlin> g.V().groupCount().by(label).select(values).max(local);
  28. ==>9
  30. # 所有顶点的属性列表中的第一个属性
  31. gremlin> g.V().valueMap().limit(local, 1);
  32. ==>[name:[saturn]]
  33. ==>[name:[jupiter]]
  34. ==>[name:[sky]]
  35. ...
  37. # 不加 local
  38. gremlin> g.V().valueMap().limit(1);
  39. ==>[name:[saturn],type:[titan],age:[10000]]
  41. # 所有顶点作为一个集合，从中采样 2 个
  42. gremlin> g.V().fold().sample(local,2);
  43. ==>[v[8],v[1]]

执行统计和分析

Gremlin 提供两种语句对执行的查询语句进行统计和分析：

  • explain()，详细描述原始的 Gremlin 语句在编译期是如何转变为最终要执行的 step 集合的
  • profile()，统计 Gremlin 语句执行过程中的每个 step 消耗的时间和通过的对象等统计信息
  1. # explain()
  2. gremlin> g.V().hasLabel('character').explain();
  3. ==>Traversal Explanation
  4. ==========================================================================================
  5. Original Traversal                 [GraphStep(vertex,[]), HasStep([~label.eq(character)])]
  7. ConnectiveStrategy           [D]   [GraphStep(vertex,[]), HasStep([~label.eq(character)])]
  8. MatchPredicateStrategy       [O]   [GraphStep(vertex,[]), HasStep([~label.eq(character)])]
  9. ...
  10. StandardVerificationStrategy [V]   [TinkerGraphStep(vertex,[~label.eq(character)])]
  12. Final Traversal                    [TinkerGraphStep(vertex,[~label.eq(character)])]
  14. # profile()
  15. gremlin> g.V().out('father').profile()
  16. ==>Traversal Metrics
  17. Step                                                               Count  Traversers       Time (ms)    % Dur
  18. =============================================================================================================
  19. TinkerGraphStep(vertex,[])                                            12          12           0.644    45.66
  20. VertexStep(OUT,[father],vertex)                                        2           2           0.534    37.83
  21. NoOpBarrierStep(2500)                                                  2           2           0.233    16.51
  22.                                             >TOTAL                     -           -           1.411        -