3.1 traverser API概述

HugeGraphServer为HugeGraph图数据库提供了RESTful API接口。除了顶点和边的CRUD基本操作以外,还提供了一些遍历(traverser)方法,我们称为traverser API。这些遍历方法实现了一些复杂的图算法,方便用户对图进行分析和挖掘。

HugeGraph支持的Traverser API包括:

  • K-out API,根据起始顶点,查找恰好N步可达的邻居,分为基础版和高级版:
    • 基础版使用GET方法,根据起始顶点,查找恰好N步可达的邻居
    • 高级版使用POST方法,根据起始顶点,查找恰好N步可达的邻居,与基础版的不同在于:
      • 支持只统计邻居数量
      • 支持边属性过滤
      • 支持返回到达邻居的最短路径
  • K-neighbor API,根据起始顶点,查找N步以内可达的所有邻居,分为基础版和高级版:
    • 基础版使用GET方法,根据起始顶点,查找N步以内可达的所有邻居
    • 高级版使用POST方法,根据起始顶点,查找N步以内可达的所有邻居,与基础版的不同在于:
      • 支持只统计邻居数量
      • 支持边属性过滤
      • 支持返回到达邻居的最短路径
  • Same Neighbors, 查询两个顶点的共同邻居
  • Jaccard Similarity API,计算jaccard相似度,包括两种:
    • 一种是使用GET方法,计算两个顶点的邻居的相似度(交并比)
    • 一种是使用POST方法,在全图中查找与起点的jaccard similarity最高的N个点
  • Shortest Path API,查找两个顶点之间的最短路径
  • All Shortest Paths,查找两个顶点间的全部最短路径
  • Weighted Shortest Path,查找起点到目标点的带权最短路径
  • Single Source Shortest Path,查找一个点到其他各个点的加权最短路径
  • Multi Node Shortest Path,查找指定顶点集之间两两最短路径
  • Paths API,查找两个顶点间的全部路径,分为基础版和高级版:
    • 基础版使用GET方法,根据起点和终点,查找两个顶点间的全部路径
    • 高级版使用POST方法,根据一组起点和一组终点,查找两个集合间符合条件的全部路径
  • Customized Paths API,从一批顶点出发,按(一种)模式遍历经过的全部路径
  • Template Path API,指定起点和终点以及起点和终点间路径信息,查找符合的路径
  • Crosspoints API,查找两个顶点的交点(共同祖先或者共同子孙)
  • Customized Crosspoints API,从一批顶点出发,按多种模式遍历,最后一步到达的顶点的交点
  • Rings API,从起始顶点出发,可到达的环路路径
  • Rays API,从起始顶点出发,可到达边界的路径(即无环路径)
  • Fusiform Similarity API,查找一个顶点的梭形相似点
  • Vertices API
    • 按ID批量查询顶点;
    • 获取顶点的分区;
    • 按分区查询顶点;
  • Edges API
    • 按ID批量查询边;
    • 获取边的分区;
    • 按分区查询边;

3.2. traverser API详解

使用方法中的例子,都是基于TinkerPop官网给出的图:

tinkerpop示例图

数据导入程序如下:

  1. public class Loader {
  2. public static void main(String[] args) {
  3. HugeClient client = new HugeClient("http://127.0.0.1:8080", "hugegraph");
  4. SchemaManager schema = client.schema();
  5. schema.propertyKey("name").asText().ifNotExist().create();
  6. schema.propertyKey("age").asInt().ifNotExist().create();
  7. schema.propertyKey("city").asText().ifNotExist().create();
  8. schema.propertyKey("weight").asDouble().ifNotExist().create();
  9. schema.propertyKey("lang").asText().ifNotExist().create();
  10. schema.propertyKey("date").asText().ifNotExist().create();
  11. schema.propertyKey("price").asInt().ifNotExist().create();
  12. schema.vertexLabel("person")
  13. .properties("name", "age", "city")
  14. .primaryKeys("name")
  15. .nullableKeys("age")
  16. .ifNotExist()
  17. .create();
  18. schema.vertexLabel("software")
  19. .properties("name", "lang", "price")
  20. .primaryKeys("name")
  21. .nullableKeys("price")
  22. .ifNotExist()
  23. .create();
  24. schema.indexLabel("personByCity")
  25. .onV("person")
  26. .by("city")
  27. .secondary()
  28. .ifNotExist()
  29. .create();
  30. schema.indexLabel("personByAgeAndCity")
  31. .onV("person")
  32. .by("age", "city")
  33. .secondary()
  34. .ifNotExist()
  35. .create();
  36. schema.indexLabel("softwareByPrice")
  37. .onV("software")
  38. .by("price")
  39. .range()
  40. .ifNotExist()
  41. .create();
  42. schema.edgeLabel("knows")
  43. .multiTimes()
  44. .sourceLabel("person")
  45. .targetLabel("person")
  46. .properties("date", "weight")
  47. .sortKeys("date")
  48. .nullableKeys("weight")
  49. .ifNotExist()
  50. .create();
  51. schema.edgeLabel("created")
  52. .sourceLabel("person").targetLabel("software")
  53. .properties("date", "weight")
  54. .nullableKeys("weight")
  55. .ifNotExist()
  56. .create();
  57. schema.indexLabel("createdByDate")
  58. .onE("created")
  59. .by("date")
  60. .secondary()
  61. .ifNotExist()
  62. .create();
  63. schema.indexLabel("createdByWeight")
  64. .onE("created")
  65. .by("weight")
  66. .range()
  67. .ifNotExist()
  68. .create();
  69. schema.indexLabel("knowsByWeight")
  70. .onE("knows")
  71. .by("weight")
  72. .range()
  73. .ifNotExist()
  74. .create();
  75. GraphManager graph = client.graph();
  76. Vertex marko = graph.addVertex(T.label, "person", "name", "marko",
  77. "age", 29, "city", "Beijing");
  78. Vertex vadas = graph.addVertex(T.label, "person", "name", "vadas",
  79. "age", 27, "city", "Hongkong");
  80. Vertex lop = graph.addVertex(T.label, "software", "name", "lop",
  81. "lang", "java", "price", 328);
  82. Vertex josh = graph.addVertex(T.label, "person", "name", "josh",
  83. "age", 32, "city", "Beijing");
  84. Vertex ripple = graph.addVertex(T.label, "software", "name", "ripple",
  85. "lang", "java", "price", 199);
  86. Vertex peter = graph.addVertex(T.label, "person", "name", "peter",
  87. "age", 35, "city", "Shanghai");
  88. marko.addEdge("knows", vadas, "date", "20160110", "weight", 0.5);
  89. marko.addEdge("knows", josh, "date", "20130220", "weight", 1.0);
  90. marko.addEdge("created", lop, "date", "20171210", "weight", 0.4);
  91. josh.addEdge("created", lop, "date", "20091111", "weight", 0.4);
  92. josh.addEdge("created", ripple, "date", "20171210", "weight", 1.0);
  93. peter.addEdge("created", lop, "date", "20170324", "weight", 0.2);
  94. }
  95. }

顶点ID为:

  1. "2:ripple",
  2. "1:vadas",
  3. "1:peter",
  4. "1:josh",
  5. "1:marko",
  6. "2:lop"

边ID为:

  1. "S1:peter>2>>S2:lop",
  2. "S1:josh>2>>S2:lop",
  3. "S1:josh>2>>S2:ripple",
  4. "S1:marko>1>20130220>S1:josh",
  5. "S1:marko>1>20160110>S1:vadas",
  6. "S1:marko>2>>S2:lop"

3.2.1 K-out API(GET,基础版)

3.2.1.1 功能介绍

根据起始顶点、方向、边的类型(可选)和深度depth,查找从起始顶点出发恰好depth步可达的顶点

Params
  • source:起始顶点id,必填项
  • direction:起始顶点向外发散的方向(OUT,IN,BOTH),选填项,默认是BOTH
  • max_depth:步数,必填项
  • label:边的类型,选填项,默认代表所有edge label
  • nearest:nearest为true时,代表起始顶点到达结果顶点的最短路径长度为depth,不存在更短的路径;nearest为false时,代表起始顶点到结果顶点有一条长度为depth的路径(未必最短且可以有环),选填项,默认为true
  • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,选填项,默认为10000
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
  • limit:返回的顶点的最大数目,选填项,默认为10000000
3.2.1.2 使用方法
Method & Url
  1. GET http://localhost:8080/graphs/{graph}/traversers/kout?source="1:marko"&max_depth=2
Response Status
  1. 200
Response Body
  1. {
  2. "vertices":[
  3. "2:ripple",
  4. "1:peter"
  5. ]
  6. }
3.2.1.3 适用场景

查找恰好N步关系可达的顶点。两个例子:

  • 家族关系中,查找一个人的所有孙子,person A通过连续的两条“儿子”边到达的顶点集合。
  • 社交关系中发现潜在好友,例如:与目标用户相隔两层朋友关系的用户,可以通过连续两条“朋友”边到达的顶点。

3.2.2 K-out API(POST,高级版)

3.2.2.1 功能介绍

根据起始顶点、步骤(包括方向、边类型和过滤属性)和深度depth,查找从起始顶点出发恰好depth步可达的顶点。

与K-out基础版的不同在于:

  • 支持只统计邻居数量
  • 支持边属性过滤
  • 支持返回到达邻居的最短路径
Params
  • source:起始顶点id,必填项
  • 从起始点出发的Step,必填项,结构如下:
    • direction:表示边的方向(OUT,IN,BOTH),默认是BOTH
    • labels:边的类型列表
    • properties:通过属性的值过滤边
    • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,默认为 10000 (注: 0.12版之前 step 内仅支持 degree 作为参数名, 0.12开始统一使用 max_degree, 并向下兼容 degree 写法)
    • skip_degree:用于设置查询过程中舍弃超级顶点的最小边数,即当某个顶点的邻接边数目大于 skip_degree 时,完全舍弃该顶点。选填项,如果开启时,需满足 skip_degree >= max_degree 约束,默认为0 (不启用),表示不跳过任何点 (注意: 开启此配置后,遍历时会尝试访问一个顶点的 skip_degree 条边,而不仅仅是 max_degree 条边,这样有额外的遍历开销,对查询性能影响可能有较大影响,请确认理解后再开启)
  • max_depth:步数,必填项
  • nearest:nearest为true时,代表起始顶点到达结果顶点的最短路径长度为depth,不存在更短的路径;nearest为false时,代表起始顶点到结果顶点有一条长度为depth的路径(未必最短且可以有环),选填项,默认为true
  • count_only:Boolean值,true表示只统计结果的数目,不返回具体结果;false表示返回具体的结果,默认为false
  • with_path:true表示返回起始点到每个邻居的最短路径,false表示不返回起始点到每个邻居的最短路径,选填项,默认为false
  • with_vertex,选填项,默认为false:
    • true表示返回结果包含完整的顶点信息(路径中的全部顶点)
      • with_path为true时,返回所有路径中的顶点的完整信息
      • with_path为false时,返回所有邻居的完整信息
    • false时表示只返回顶点id
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
  • limit:返回的顶点的最大数目,选填项,默认为10000000
3.2.2.2 使用方法
Method & Url
  1. POST http://localhost:8080/graphs/{graph}/traversers/kout
Request Body
  1. {
  2. "source": "1:marko",
  3. "step": {
  4. "direction": "BOTH",
  5. "labels": ["knows", "created"],
  6. "properties": {
  7. "weight": "P.gt(0.1)"
  8. },
  9. "max_degree": 10000,
  10. "skip_degree": 100000
  11. },
  12. "max_depth": 1,
  13. "nearest": true,
  14. "limit": 10000,
  15. "with_vertex": true,
  16. "with_path": true
  17. }
Response Status
  1. 200
Response Body
  1. {
  2. "size": 3,
  3. "kout": [
  4. "1:josh",
  5. "1:vadas",
  6. "2:lop"
  7. ],
  8. "paths": [
  9. {
  10. "objects": [
  11. "1:marko",
  12. "1:josh"
  13. ]
  14. },
  15. {
  16. "objects": [
  17. "1:marko",
  18. "1:vadas"
  19. ]
  20. },
  21. {
  22. "objects": [
  23. "1:marko",
  24. "2:lop"
  25. ]
  26. }
  27. ],
  28. "vertices": [
  29. {
  30. "id": "1:marko",
  31. "label": "person",
  32. "type": "vertex",
  33. "properties": {
  34. "name": "marko",
  35. "age": 29,
  36. "city": "Beijing"
  37. }
  38. },
  39. {
  40. "id": "1:josh",
  41. "label": "person",
  42. "type": "vertex",
  43. "properties": {
  44. "name": "josh",
  45. "age": 32,
  46. "city": "Beijing"
  47. }
  48. },
  49. {
  50. "id": "1:vadas",
  51. "label": "person",
  52. "type": "vertex",
  53. "properties": {
  54. "name": "vadas",
  55. "age": 27,
  56. "city": "Hongkong"
  57. }
  58. },
  59. {
  60. "id": "2:lop",
  61. "label": "software",
  62. "type": "vertex",
  63. "properties": {
  64. "name": "lop",
  65. "lang": "java",
  66. "price": 328
  67. }
  68. }
  69. ]
  70. }
3.2.2.3 适用场景

参见3.2.1.3

3.2.3 K-neighbor(GET,基础版)

3.2.3.1 功能介绍

根据起始顶点、方向、边的类型(可选)和深度depth,查找包括起始顶点在内、depth步之内可达的所有顶点

相当于:起始顶点、K-out(1)、K-out(2)、… 、K-out(max_depth)的并集

Params
  • source: 起始顶点id,必填项
  • direction:起始顶点向外发散的方向(OUT,IN,BOTH),选填项,默认是BOTH
  • max_depth:步数,必填项
  • label:边的类型,选填项,默认代表所有edge label
  • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,选填项,默认为10000
  • limit:返回的顶点的最大数目,也即遍历过程中最大的访问的顶点数目,选填项,默认为10000000
3.2.3.2 使用方法
Method & Url
  1. GET http://localhost:8080/graphs/{graph}/traversers/kneighbor?source=“1:marko”&max_depth=2
Response Status
  1. 200
Response Body
  1. {
  2. "vertices":[
  3. "2:ripple",
  4. "1:marko",
  5. "1:josh",
  6. "1:vadas",
  7. "1:peter",
  8. "2:lop"
  9. ]
  10. }
3.2.3.3 适用场景

查找N步以内可达的所有顶点,例如:

  • 家族关系中,查找一个人五服以内所有子孙,person A通过连续的5条“亲子”边到达的顶点集合。
  • 社交关系中发现好友圈子,例如目标用户通过1条、2条、3条“朋友”边可到达的用户可以组成目标用户的朋友圈子

3.2.4 K-neighbor API(POST,高级版)

3.2.4.1 功能介绍

根据起始顶点、步骤(包括方向、边类型和过滤属性)和深度depth,查找从起始顶点出发depth步内可达的所有顶点。

与K-neighbor基础版的不同在于:

  • 支持只统计邻居数量
  • 支持边属性过滤
  • 支持返回到达邻居的最短路径
Params
  • source:起始顶点id,必填项
  • 从起始点出发的Step,必填项,结构如下:
    • direction:表示边的方向(OUT,IN,BOTH),默认是BOTH
    • labels:边的类型列表
    • properties:通过属性的值过滤边
    • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,默认为 10000 (注: 0.12版之前 step 内仅支持 degree 作为参数名, 0.12开始统一使用 max_degree, 并向下兼容 degree 写法)
    • skip_degree:用于设置查询过程中舍弃超级顶点的最小边数,即当某个顶点的邻接边数目大于 skip_degree 时,完全舍弃该顶点。选填项,如果开启时,需满足 skip_degree >= max_degree 约束,默认为0 (不启用),表示不跳过任何点 (注意: 开启此配置后,遍历时会尝试访问一个顶点的 skip_degree 条边,而不仅仅是 max_degree 条边,这样有额外的遍历开销,对查询性能影响可能有较大影响,请确认理解后再开启)
  • max_depth:步数,必填项
  • count_only:Boolean值,true表示只统计结果的数目,不返回具体结果;false表示返回具体的结果,默认为false
  • with_path:true表示返回起始点到每个邻居的最短路径,false表示不返回起始点到每个邻居的最短路径,选填项,默认为false
  • with_vertex,选填项,默认为false:
    • true表示返回结果包含完整的顶点信息(路径中的全部顶点)
      • with_path为true时,返回所有路径中的顶点的完整信息
      • with_path为false时,返回所有邻居的完整信息
    • false时表示只返回顶点id
  • limit:返回的顶点的最大数目,选填项,默认为10000000
3.2.4.2 使用方法
Method & Url
  1. POST http://localhost:8080/graphs/{graph}/traversers/kneighbor
Request Body
  1. {
  2. "source": "1:marko",
  3. "step": {
  4. "direction": "BOTH",
  5. "labels": ["knows", "created"],
  6. "properties": {
  7. "weight": "P.gt(0.1)"
  8. },
  9. "max_degree": 10000,
  10. "skip_degree": 100000
  11. },
  12. "max_depth": 3,
  13. "limit": 10000,
  14. "with_vertex": true,
  15. "with_path": true
  16. }
Response Status
  1. 200
Response Body
  1. {
  2. "size": 6,
  3. "kneighbor": [
  4. "2:ripple",
  5. "1:marko",
  6. "1:josh",
  7. "1:vadas",
  8. "1:peter",
  9. "2:lop"
  10. ],
  11. "paths": [
  12. {
  13. "objects": [
  14. "1:marko",
  15. "1:josh",
  16. "2:ripple"
  17. ]
  18. },
  19. {
  20. "objects": [
  21. "1:marko"
  22. ]
  23. },
  24. {
  25. "objects": [
  26. "1:marko",
  27. "1:josh"
  28. ]
  29. },
  30. {
  31. "objects": [
  32. "1:marko",
  33. "1:vadas"
  34. ]
  35. },
  36. {
  37. "objects": [
  38. "1:marko",
  39. "2:lop",
  40. "1:peter"
  41. ]
  42. },
  43. {
  44. "objects": [
  45. "1:marko",
  46. "2:lop"
  47. ]
  48. }
  49. ],
  50. "vertices": [
  51. {
  52. "id": "2:ripple",
  53. "label": "software",
  54. "type": "vertex",
  55. "properties": {
  56. "name": "ripple",
  57. "lang": "java",
  58. "price": 199
  59. }
  60. },
  61. {
  62. "id": "1:marko",
  63. "label": "person",
  64. "type": "vertex",
  65. "properties": {
  66. "name": "marko",
  67. "age": 29,
  68. "city": "Beijing"
  69. }
  70. },
  71. {
  72. "id": "1:josh",
  73. "label": "person",
  74. "type": "vertex",
  75. "properties": {
  76. "name": "josh",
  77. "age": 32,
  78. "city": "Beijing"
  79. }
  80. },
  81. {
  82. "id": "1:vadas",
  83. "label": "person",
  84. "type": "vertex",
  85. "properties": {
  86. "name": "vadas",
  87. "age": 27,
  88. "city": "Hongkong"
  89. }
  90. },
  91. {
  92. "id": "1:peter",
  93. "label": "person",
  94. "type": "vertex",
  95. "properties": {
  96. "name": "peter",
  97. "age": 35,
  98. "city": "Shanghai"
  99. }
  100. },
  101. {
  102. "id": "2:lop",
  103. "label": "software",
  104. "type": "vertex",
  105. "properties": {
  106. "name": "lop",
  107. "lang": "java",
  108. "price": 328
  109. }
  110. }
  111. ]
  112. }
3.2.4.3 适用场景

参见3.2.3.3

3.2.5 Same Neighbors

3.2.5.1 功能介绍

查询两个点的共同邻居

Params
  • vertex:一个顶点id,必填项
  • other:另一个顶点id,必填项
  • direction:顶点向外发散的方向(OUT,IN,BOTH),选填项,默认是BOTH
  • label:边的类型,选填项,默认代表所有edge label
  • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,选填项,默认为10000
  • limit:返回的共同邻居的最大数目,选填项,默认为10000000
3.2.5.2 使用方法
Method & Url
  1. GET http://localhost:8080/graphs/{graph}/traversers/sameneighbors?vertex=“1:marko”&other="1:josh"
Response Status
  1. 200
Response Body
  1. {
  2. "same_neighbors":[
  3. "2:lop"
  4. ]
  5. }
3.2.5.3 适用场景

查找两个顶点的共同邻居:

  • 社交关系中发现两个用户的共同粉丝或者共同关注用户

3.2.6 Jaccard Similarity(GET)

3.2.6.1 功能介绍

计算两个顶点的jaccard similarity(两个顶点邻居的交集比上两个顶点邻居的并集)

Params
  • vertex:一个顶点id,必填项
  • other:另一个顶点id,必填项
  • direction:顶点向外发散的方向(OUT,IN,BOTH),选填项,默认是BOTH
  • label:边的类型,选填项,默认代表所有edge label
  • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,选填项,默认为10000
3.2.6.2 使用方法
Method & Url
  1. GET http://localhost:8080/graphs/{graph}/traversers/jaccardsimilarity?vertex="1:marko"&other="1:josh"
Response Status
  1. 200
Response Body
  1. {
  2. "jaccard_similarity": 0.2
  3. }
3.2.6.3 适用场景

用于评估两个点的相似性或者紧密度

3.2.7 Jaccard Similarity(POST)

3.2.7.1 功能介绍

计算与指定顶点的jaccard similarity最大的N个点

jaccard similarity的计算方式为:两个顶点邻居的交集比上两个顶点邻居的并集

Params
  • vertex:一个顶点id,必填项
  • 从起始点出发的Step,必填项,结构如下:
    • direction:表示边的方向(OUT,IN,BOTH),默认是BOTH
    • labels:边的类型列表
    • properties:通过属性的值过滤边
    • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,默认为 10000 (注: 0.12版之前 step 内仅支持 degree 作为参数名, 0.12开始统一使用 max_degree, 并向下兼容 degree 写法)
    • skip_degree:用于设置查询过程中舍弃超级顶点的最小边数,即当某个顶点的邻接边数目大于 skip_degree 时,完全舍弃该顶点。选填项,如果开启时,需满足 skip_degree >= max_degree 约束,默认为0 (不启用),表示不跳过任何点 (注意: 开启此配置后,遍历时会尝试访问一个顶点的 skip_degree 条边,而不仅仅是 max_degree 条边,这样有额外的遍历开销,对查询性能影响可能有较大影响,请确认理解后再开启)
  • top:返回一个起点的jaccard similarity中最大的top个,选填项,默认为100
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
3.2.7.2 使用方法
Method & Url
  1. POST http://localhost:8080/graphs/{graph}/traversers/jaccardsimilarity
Request Body
  1. {
  2. "vertex": "1:marko",
  3. "step": {
  4. "direction": "BOTH",
  5. "labels": [],
  6. "max_degree": 10000,
  7. "skip_degree": 100000
  8. },
  9. "top": 3
  10. }
Response Status
  1. 200
Response Body
  1. {
  2. "2:ripple": 0.3333333333333333,
  3. "1:peter": 0.3333333333333333,
  4. "1:josh": 0.2
  5. }
3.2.7.3 适用场景

用于在图中找出与指定顶点相似性最高的顶点

3.2.8 Shortest Path

3.2.8.1 功能介绍

根据起始顶点、目的顶点、方向、边的类型(可选)和最大深度,查找一条最短路径

Params
  • source:起始顶点id,必填项
  • target:目的顶点id,必填项
  • direction:起始顶点向外发散的方向(OUT,IN,BOTH),选填项,默认是BOTH
  • max_depth:最大步数,必填项
  • label:边的类型,选填项,默认代表所有edge label
  • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,选填项,默认为10000
  • skip_degree:用于设置查询过程中舍弃超级顶点的最小边数,即当某个顶点的邻接边数目大于 skip_degree 时,完全舍弃该顶点。选填项,如果开启时,需满足 skip_degree >= max_degree 约束,默认为0 (不启用),表示不跳过任何点 (注意: 开启此配置后,遍历时会尝试访问一个顶点的 skip_degree 条边,而不仅仅是 max_degree 条边,这样有额外的遍历开销,对查询性能影响可能有较大影响,请确认理解后再开启)
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
3.2.8.2 使用方法
Method & Url
  1. GET http://localhost:8080/graphs/{graph}/traversers/shortestpath?source="1:marko"&target="2:ripple"&max_depth=3
Response Status
  1. 200
Response Body
  1. {
  2. "path":[
  3. "1:marko",
  4. "1:josh",
  5. "2:ripple"
  6. ]
  7. }
3.2.8.3 适用场景

查找两个顶点间的最短路径,例如:

  • 社交关系网中,查找两个用户有关系的最短路径,即最近的朋友关系链
  • 设备关联网络中,查找两个设备最短的关联关系

3.2.9 All Shortest Paths

3.2.9.1 功能介绍

根据起始顶点、目的顶点、方向、边的类型(可选)和最大深度,查找两点间所有的最短路径

Params
  • source:起始顶点id,必填项
  • target:目的顶点id,必填项
  • direction:起始顶点向外发散的方向(OUT,IN,BOTH),选填项,默认是BOTH
  • max_depth:最大步数,必填项
  • label:边的类型,选填项,默认代表所有edge label
  • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,选填项,默认为10000
  • skip_degree:用于设置查询过程中舍弃超级顶点的最小边数,即当某个顶点的邻接边数目大于 skip_degree 时,完全舍弃该顶点。选填项,如果开启时,需满足 skip_degree >= max_degree 约束,默认为0 (不启用),表示不跳过任何点 (注意: 开启此配置后,遍历时会尝试访问一个顶点的 skip_degree 条边,而不仅仅是 max_degree 条边,这样有额外的遍历开销,对查询性能影响可能有较大影响,请确认理解后再开启)
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
3.2.9.2 使用方法
Method & Url
  1. GET http://localhost:8080/graphs/{graph}/traversers/allshortestpaths?source="A"&target="Z"&max_depth=10
Response Status
  1. 200
Response Body
  1. {
  2. "paths":[
  3. {
  4. "objects": [
  5. "A",
  6. "B",
  7. "C",
  8. "Z"
  9. ]
  10. },
  11. {
  12. "objects": [
  13. "A",
  14. "M",
  15. "N",
  16. "Z"
  17. ]
  18. }
  19. ]
  20. }
3.2.9.3 适用场景

查找两个顶点间的所有最短路径,例如:

  • 社交关系网中,查找两个用户有关系的全部最短路径,即最近的朋友关系链
  • 设备关联网络中,查找两个设备全部的最短关联关系

3.2.10 Weighted Shortest Path

3.2.10.1 功能介绍

根据起始顶点、目的顶点、方向、边的类型(可选)和最大深度,查找一条带权最短路径

Params
  • source:起始顶点id,必填项
  • target:目的顶点id,必填项
  • direction:起始顶点向外发散的方向(OUT,IN,BOTH),选填项,默认是BOTH
  • label:边的类型,选填项,默认代表所有edge label
  • weight:边的权重属性,必填项,必须是数字类型的属性
  • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,选填项,默认为10000
  • skip_degree:用于设置查询过程中舍弃超级顶点的最小边数,即当某个顶点的邻接边数目大于 skip_degree 时,完全舍弃该顶点。选填项,如果开启时,需满足 skip_degree >= max_degree 约束,默认为0 (不启用),表示不跳过任何点 (注意: 开启此配置后,遍历时会尝试访问一个顶点的 skip_degree 条边,而不仅仅是 max_degree 条边,这样有额外的遍历开销,对查询性能影响可能有较大影响,请确认理解后再开启)
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
  • with_vertex:true表示返回结果包含完整的顶点信息(路径中的全部顶点),false时表示只返回顶点id,选填项,默认为false
3.2.10.2 使用方法
Method & Url
  1. GET http://localhost:8080/graphs/{graph}/traversers/weightedshortestpath?source="1:marko"&target="2:ripple"&weight="weight"&with_vertex=true
Response Status
  1. 200
Response Body
  1. {
  2. "path": {
  3. "weight": 2.0,
  4. "vertices": [
  5. "1:marko",
  6. "1:josh",
  7. "2:ripple"
  8. ]
  9. },
  10. "vertices": [
  11. {
  12. "id": "1:marko",
  13. "label": "person",
  14. "type": "vertex",
  15. "properties": {
  16. "name": "marko",
  17. "age": 29,
  18. "city": "Beijing"
  19. }
  20. },
  21. {
  22. "id": "1:josh",
  23. "label": "person",
  24. "type": "vertex",
  25. "properties": {
  26. "name": "josh",
  27. "age": 32,
  28. "city": "Beijing"
  29. }
  30. },
  31. {
  32. "id": "2:ripple",
  33. "label": "software",
  34. "type": "vertex",
  35. "properties": {
  36. "name": "ripple",
  37. "lang": "java",
  38. "price": 199
  39. }
  40. }
  41. ]
  42. }
3.2.10.3 适用场景

查找两个顶点间的带权最短路径,例如:

  • 交通线路中查找从A城市到B城市花钱最少的交通方式

3.2.11 Single Source Shortest Path

3.2.11.1 功能介绍

从一个顶点出发,查找该点到图中其他顶点的最短路径(可选是否带权重)

Params
  • source:起始顶点id,必填项
  • direction:起始顶点向外发散的方向(OUT,IN,BOTH),选填项,默认是BOTH
  • label:边的类型,选填项,默认代表所有edge label
  • weight:边的权重属性,选填项,必须是数字类型的属性,如果不填或者虽然填了但是边没有该属性,则权重为1.0
  • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,选填项,默认为10000
  • skip_degree:用于设置查询过程中舍弃超级顶点的最小边数,即当某个顶点的邻接边数目大于 skip_degree 时,完全舍弃该顶点。选填项,如果开启时,需满足 skip_degree >= max_degree 约束,默认为0 (不启用),表示不跳过任何点 (注意: 开启此配置后,遍历时会尝试访问一个顶点的 skip_degree 条边,而不仅仅是 max_degree 条边,这样有额外的遍历开销,对查询性能影响可能有较大影响,请确认理解后再开启)
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
  • limit:查询到的目标顶点个数,也是返回的最短路径的条数,选填项,默认为10
  • with_vertex:true表示返回结果包含完整的顶点信息(路径中的全部顶点),false时表示只返回顶点id,选填项,默认为false
3.2.11.2 使用方法
Method & Url
  1. GET http://localhost:8080/graphs/{graph}/traversers/singlesourceshortestpath?source="1:marko"&with_vertex=true
Response Status
  1. 200
Response Body
  1. {
  2. "paths": {
  3. "2:ripple": {
  4. "weight": 2.0,
  5. "vertices": [
  6. "1:marko",
  7. "1:josh",
  8. "2:ripple"
  9. ]
  10. },
  11. "1:josh": {
  12. "weight": 1.0,
  13. "vertices": [
  14. "1:marko",
  15. "1:josh"
  16. ]
  17. },
  18. "1:vadas": {
  19. "weight": 1.0,
  20. "vertices": [
  21. "1:marko",
  22. "1:vadas"
  23. ]
  24. },
  25. "1:peter": {
  26. "weight": 2.0,
  27. "vertices": [
  28. "1:marko",
  29. "2:lop",
  30. "1:peter"
  31. ]
  32. },
  33. "2:lop": {
  34. "weight": 1.0,
  35. "vertices": [
  36. "1:marko",
  37. "2:lop"
  38. ]
  39. }
  40. },
  41. "vertices": [
  42. {
  43. "id": "2:ripple",
  44. "label": "software",
  45. "type": "vertex",
  46. "properties": {
  47. "name": "ripple",
  48. "lang": "java",
  49. "price": 199
  50. }
  51. },
  52. {
  53. "id": "1:marko",
  54. "label": "person",
  55. "type": "vertex",
  56. "properties": {
  57. "name": "marko",
  58. "age": 29,
  59. "city": "Beijing"
  60. }
  61. },
  62. {
  63. "id": "1:josh",
  64. "label": "person",
  65. "type": "vertex",
  66. "properties": {
  67. "name": "josh",
  68. "age": 32,
  69. "city": "Beijing"
  70. }
  71. },
  72. {
  73. "id": "1:vadas",
  74. "label": "person",
  75. "type": "vertex",
  76. "properties": {
  77. "name": "vadas",
  78. "age": 27,
  79. "city": "Hongkong"
  80. }
  81. },
  82. {
  83. "id": "1:peter",
  84. "label": "person",
  85. "type": "vertex",
  86. "properties": {
  87. "name": "peter",
  88. "age": 35,
  89. "city": "Shanghai"
  90. }
  91. },
  92. {
  93. "id": "2:lop",
  94. "label": "software",
  95. "type": "vertex",
  96. "properties": {
  97. "name": "lop",
  98. "lang": "java",
  99. "price": 328
  100. }
  101. }
  102. ]
  103. }
3.2.11.3 适用场景

查找从一个点出发到其他顶点的带权最短路径,比如:

  • 查找从北京出发到全国其他所有城市的耗时最短的乘车方案

3.2.12 Multi Node Shortest Path

3.2.12.1 功能介绍

查找指定顶点集两两之间的最短路径

Params
  • vertices:定义起始顶点,必填项,指定方式包括:
    • ids:通过顶点id列表提供起始顶点
    • label和properties:如果没有指定ids,则使用label和properties的联合条件查询起始顶点
      • label:顶点的类型
      • properties:通过属性的值查询起始顶点

        注意:properties中的属性值可以是列表,表示只要key对应的value在列表中就可以

  • step:表示从起始顶点到终止顶点走过的路径,必填项,Step的结构如下:
    • direction:表示边的方向(OUT,IN,BOTH),默认是BOTH
    • labels:边的类型列表
    • properties:通过属性的值过滤边
    • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,默认为 10000 (注: 0.12版之前 step 内仅支持 degree 作为参数名, 0.12开始统一使用 max_degree, 并向下兼容 degree 写法)
    • skip_degree:用于设置查询过程中舍弃超级顶点的最小边数,即当某个顶点的邻接边数目大于 skip_degree 时,完全舍弃该顶点。选填项,如果开启时,需满足 skip_degree >= max_degree 约束,默认为0 (不启用),表示不跳过任何点 (注意: 开启此配置后,遍历时会尝试访问一个顶点的 skip_degree 条边,而不仅仅是 max_degree 条边,这样有额外的遍历开销,对查询性能影响可能有较大影响,请确认理解后再开启)
  • max_depth:步数,必填项
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
  • with_vertex:true表示返回结果包含完整的顶点信息(路径中的全部顶点),false时表示只返回顶点id,选填项,默认为false
3.2.12.2 使用方法
Method & Url
  1. POST http://localhost:8080/graphs/{graph}/traversers/multinodeshortestpath
Request Body
  1. {
  2. "vertices": {
  3. "ids": ["382:marko", "382:josh", "382:vadas", "382:peter", "383:lop", "383:ripple"]
  4. },
  5. "step": {
  6. "direction": "BOTH",
  7. "properties": {
  8. }
  9. },
  10. "max_depth": 10,
  11. "capacity": 100000000,
  12. "with_vertex": true
  13. }
Response Status
  1. 200
Response Body
  1. {
  2. "paths": [
  3. {
  4. "objects": [
  5. "382:peter",
  6. "383:lop"
  7. ]
  8. },
  9. {
  10. "objects": [
  11. "382:peter",
  12. "383:lop",
  13. "382:marko"
  14. ]
  15. },
  16. {
  17. "objects": [
  18. "382:peter",
  19. "383:lop",
  20. "382:josh"
  21. ]
  22. },
  23. {
  24. "objects": [
  25. "382:peter",
  26. "383:lop",
  27. "382:marko",
  28. "382:vadas"
  29. ]
  30. },
  31. {
  32. "objects": [
  33. "383:lop",
  34. "382:marko"
  35. ]
  36. },
  37. {
  38. "objects": [
  39. "383:lop",
  40. "382:josh"
  41. ]
  42. },
  43. {
  44. "objects": [
  45. "383:lop",
  46. "382:marko",
  47. "382:vadas"
  48. ]
  49. },
  50. {
  51. "objects": [
  52. "382:peter",
  53. "383:lop",
  54. "382:josh",
  55. "383:ripple"
  56. ]
  57. },
  58. {
  59. "objects": [
  60. "382:marko",
  61. "382:josh"
  62. ]
  63. },
  64. {
  65. "objects": [
  66. "383:lop",
  67. "382:josh",
  68. "383:ripple"
  69. ]
  70. },
  71. {
  72. "objects": [
  73. "382:marko",
  74. "382:vadas"
  75. ]
  76. },
  77. {
  78. "objects": [
  79. "382:marko",
  80. "382:josh",
  81. "383:ripple"
  82. ]
  83. },
  84. {
  85. "objects": [
  86. "382:josh",
  87. "383:ripple"
  88. ]
  89. },
  90. {
  91. "objects": [
  92. "382:josh",
  93. "382:marko",
  94. "382:vadas"
  95. ]
  96. },
  97. {
  98. "objects": [
  99. "382:vadas",
  100. "382:marko",
  101. "382:josh",
  102. "383:ripple"
  103. ]
  104. }
  105. ],
  106. "vertices": [
  107. {
  108. "id": "382:peter",
  109. "label": "person",
  110. "type": "vertex",
  111. "properties": {
  112. "name": "peter",
  113. "age": 29,
  114. "city": "Shanghai"
  115. }
  116. },
  117. {
  118. "id": "383:lop",
  119. "label": "software",
  120. "type": "vertex",
  121. "properties": {
  122. "name": "lop",
  123. "lang": "java",
  124. "price": 328
  125. }
  126. },
  127. {
  128. "id": "382:marko",
  129. "label": "person",
  130. "type": "vertex",
  131. "properties": {
  132. "name": "marko",
  133. "age": 29,
  134. "city": "Beijing"
  135. }
  136. },
  137. {
  138. "id": "382:josh",
  139. "label": "person",
  140. "type": "vertex",
  141. "properties": {
  142. "name": "josh",
  143. "age": 32,
  144. "city": "Beijing"
  145. }
  146. },
  147. {
  148. "id": "382:vadas",
  149. "label": "person",
  150. "type": "vertex",
  151. "properties": {
  152. "name": "vadas",
  153. "age": 27,
  154. "city": "Hongkong"
  155. }
  156. },
  157. {
  158. "id": "383:ripple",
  159. "label": "software",
  160. "type": "vertex",
  161. "properties": {
  162. "name": "ripple",
  163. "lang": "java",
  164. "price": 199
  165. }
  166. }
  167. ]
  168. }
3.2.12.3 适用场景

查找多个点之间的最短路径,比如:

  • 查找多个公司和法人之间的最短路径

3.2.13 Paths (GET,基础版)

3.2.13.1 功能介绍

根据起始顶点、目的顶点、方向、边的类型(可选)和最大深度等条件查找所有路径

Params
  • source:起始顶点id,必填项
  • target:目的顶点id,必填项
  • direction:起始顶点向外发散的方向(OUT,IN,BOTH),选填项,默认是BOTH
  • label:边的类型,选填项,默认代表所有edge label
  • max_depth:步数,必填项
  • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,选填项,默认为10000
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
  • limit:返回的路径的最大数目,选填项,默认为10
3.2.13.2 使用方法
Method & Url
  1. GET http://localhost:8080/graphs/{graph}/traversers/paths?source="1:marko"&target="1:josh"&max_depth=5
Response Status
  1. 200
Response Body
  1. {
  2. "paths":[
  3. {
  4. "objects":[
  5. "1:marko",
  6. "1:josh"
  7. ]
  8. },
  9. {
  10. "objects":[
  11. "1:marko",
  12. "2:lop",
  13. "1:josh"
  14. ]
  15. }
  16. ]
  17. }
3.2.13.3 适用场景

查找两个顶点间的所有路径,例如:

  • 社交网络中,查找两个用户所有可能的关系路径
  • 设备关联网络中,查找两个设备之间所有的关联路径

3.2.14 Paths (POST,高级版)

3.2.14.1 功能介绍

根据起始顶点、目的顶点、步骤(step)和最大深度等条件查找所有路径

Params
  • sources:定义起始顶点,必填项,指定方式包括:
    • ids:通过顶点id列表提供起始顶点
    • label和properties:如果没有指定ids,则使用label和properties的联合条件查询起始顶点
      • label:顶点的类型
      • properties:通过属性的值查询起始顶点

        注意:properties中的属性值可以是列表,表示只要key对应的value在列表中就可以

  • targets:定义终止顶点,必填项,指定方式包括:
    • ids:通过顶点id列表提供终止顶点
    • label和properties:如果没有指定ids,则使用label和properties的联合条件查询终止顶点
      • label:顶点的类型
      • properties:通过属性的值查询终止顶点

        注意:properties中的属性值可以是列表,表示只要key对应的value在列表中就可以

  • step:表示从起始顶点到终止顶点走过的路径,必填项,Step的结构如下:
    • direction:表示边的方向(OUT,IN,BOTH),默认是BOTH
    • labels:边的类型列表
    • properties:通过属性的值过滤边
    • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,默认为 10000 (注: 0.12版之前 step 内仅支持 degree 作为参数名, 0.12开始统一使用 max_degree, 并向下兼容 degree 写法)
    • skip_degree:用于设置查询过程中舍弃超级顶点的最小边数,即当某个顶点的邻接边数目大于 skip_degree 时,完全舍弃该顶点。选填项,如果开启时,需满足 skip_degree >= max_degree 约束,默认为0 (不启用),表示不跳过任何点 (注意: 开启此配置后,遍历时会尝试访问一个顶点的 skip_degree 条边,而不仅仅是 max_degree 条边,这样有额外的遍历开销,对查询性能影响可能有较大影响,请确认理解后再开启)
  • max_depth:步数,必填项
  • nearest:nearest为true时,代表起始顶点到达结果顶点的最短路径长度为depth,不存在更短的路径;nearest为false时,代表起始顶点到结果顶点有一条长度为depth的路径(未必最短且可以有环),选填项,默认为true
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
  • limit:返回的路径的最大数目,选填项,默认为10
  • with_vertex:true表示返回结果包含完整的顶点信息(路径中的全部顶点),false时表示只返回顶点id,选填项,默认为false
3.2.14.2 使用方法
Method & Url
  1. POST http://localhost:8080/graphs/{graph}/traversers/paths
Request Body
  1. {
  2. "sources": {
  3. "ids": ["1:marko"]
  4. },
  5. "targets": {
  6. "ids": ["1:peter"]
  7. },
  8. "step": {
  9. "direction": "BOTH",
  10. "properties": {
  11. "weight": "P.gt(0.01)"
  12. }
  13. },
  14. "max_depth": 10,
  15. "capacity": 100000000,
  16. "limit": 10000000,
  17. "with_vertex": false
  18. }
Response Status
  1. 200
Response Body
  1. {
  2. "paths": [
  3. {
  4. "objects": [
  5. "1:marko",
  6. "1:josh",
  7. "2:lop",
  8. "1:peter"
  9. ]
  10. },
  11. {
  12. "objects": [
  13. "1:marko",
  14. "2:lop",
  15. "1:peter"
  16. ]
  17. }
  18. ]
  19. }
3.2.14.3 适用场景

查找两个顶点间的所有路径,例如:

  • 社交网络中,查找两个用户所有可能的关系路径
  • 设备关联网络中,查找两个设备之间所有的关联路径

3.2.15 Customized Paths

3.2.15.1 功能介绍

根据一批起始顶点、边规则(包括方向、边的类型和属性过滤)和最大深度等条件查找符合条件的所有的路径

Params
  • sources:定义起始顶点,必填项,指定方式包括:
    • ids:通过顶点id列表提供起始顶点
    • label和properties:如果没有指定ids,则使用label和properties的联合条件查询起始顶点
      • label:顶点的类型
      • properties:通过属性的值查询起始顶点

        注意:properties中的属性值可以是列表,表示只要key对应的value在列表中就可以

  • steps:表示从起始顶点走过的路径规则,是一组Step的列表。必填项。每个Step的结构如下:
    • direction:表示边的方向(OUT,IN,BOTH),默认是BOTH
    • labels:边的类型列表
    • properties:通过属性的值过滤边
    • weight_by:根据指定的属性计算边的权重,sort_by不为NONE时有效,与default_weight互斥
    • default_weight:当边没有属性作为权重计算值时,采取的默认权重,sort_by不为NONE时有效,与weight_by互斥
    • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,默认为 10000 (注: 0.12版之前 step 内仅支持 degree 作为参数名, 0.12开始统一使用 max_degree, 并向下兼容 degree 写法)
    • sample:当需要对某个step的符合条件的边进行采样时设置,-1表示不采样,默认为采样100
  • sort_by:根据路径的权重排序,选填项,默认为NONE:
    • NONE表示不排序,默认值
    • INCR表示按照路径权重的升序排序
    • DECR表示按照路径权重的降序排序
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
  • limit:返回的路径的最大数目,选填项,默认为10
  • with_vertex:true表示返回结果包含完整的顶点信息(路径中的全部顶点),false时表示只返回顶点id,选填项,默认为false
3.2.15.2 使用方法
Method & Url
  1. POST http://localhost:8080/graphs/{graph}/traversers/customizedpaths
Request Body
  1. {
  2. "sources":{
  3. "ids":[
  4. ],
  5. "label":"person",
  6. "properties":{
  7. "name":"marko"
  8. }
  9. },
  10. "steps":[
  11. {
  12. "direction":"OUT",
  13. "labels":[
  14. "knows"
  15. ],
  16. "weight_by":"weight",
  17. "max_degree":-1
  18. },
  19. {
  20. "direction":"OUT",
  21. "labels":[
  22. "created"
  23. ],
  24. "default_weight":8,
  25. "max_degree":-1,
  26. "sample":1
  27. }
  28. ],
  29. "sort_by":"INCR",
  30. "with_vertex":true,
  31. "capacity":-1,
  32. "limit":-1
  33. }
Response Status
  1. 200
Response Body
  1. {
  2. "paths":[
  3. {
  4. "objects":[
  5. "1:marko",
  6. "1:josh",
  7. "2:lop"
  8. ],
  9. "weights":[
  10. 1,
  11. 8
  12. ]
  13. }
  14. ],
  15. "vertices":[
  16. {
  17. "id":"1:marko",
  18. "label":"person",
  19. "type":"vertex",
  20. "properties":{
  21. "city":[
  22. {
  23. "id":"1:marko>city",
  24. "value":"Beijing"
  25. }
  26. ],
  27. "name":[
  28. {
  29. "id":"1:marko>name",
  30. "value":"marko"
  31. }
  32. ],
  33. "age":[
  34. {
  35. "id":"1:marko>age",
  36. "value":29
  37. }
  38. ]
  39. }
  40. },
  41. {
  42. "id":"1:josh",
  43. "label":"person",
  44. "type":"vertex",
  45. "properties":{
  46. "city":[
  47. {
  48. "id":"1:josh>city",
  49. "value":"Beijing"
  50. }
  51. ],
  52. "name":[
  53. {
  54. "id":"1:josh>name",
  55. "value":"josh"
  56. }
  57. ],
  58. "age":[
  59. {
  60. "id":"1:josh>age",
  61. "value":32
  62. }
  63. ]
  64. }
  65. },
  66. {
  67. "id":"2:lop",
  68. "label":"software",
  69. "type":"vertex",
  70. "properties":{
  71. "price":[
  72. {
  73. "id":"2:lop>price",
  74. "value":328
  75. }
  76. ],
  77. "name":[
  78. {
  79. "id":"2:lop>name",
  80. "value":"lop"
  81. }
  82. ],
  83. "lang":[
  84. {
  85. "id":"2:lop>lang",
  86. "value":"java"
  87. }
  88. ]
  89. }
  90. }
  91. ]
  92. }
3.2.15.3 适用场景

适合查找各种复杂的路径集合,例如:

  • 社交网络中,查找看过张艺谋所导演的电影的用户关注的大V的路径(张艺谋—->电影——>用户—->大V)
  • 风控网络中,查找多个高风险用户的直系亲属的朋友的路径(高风险用户—->直系亲属—->朋友)

3.2.16 Template Paths

3.2.16.1 功能介绍

根据一批起始顶点、边规则(包括方向、边的类型和属性过滤)和最大深度等条件查找符合条件的所有的路径

Params
  • sources:定义起始顶点,必填项,指定方式包括:
    • ids:通过顶点id列表提供起始顶点
    • label和properties:如果没有指定ids,则使用label和properties的联合条件查询起始顶点
      • label:顶点的类型
      • properties:通过属性的值查询起始顶点

        注意:properties中的属性值可以是列表,表示只要key对应的value在列表中就可以

  • targets:定义终止顶点,必填项,指定方式包括:
    • ids:通过顶点id列表提供终止顶点
    • label和properties:如果没有指定ids,则使用label和properties的联合条件查询终止顶点
      • label:顶点的类型
      • properties:通过属性的值查询终止顶点

        注意:properties中的属性值可以是列表,表示只要key对应的value在列表中就可以

  • steps:表示从起始顶点走过的路径规则,是一组Step的列表。必填项。每个Step的结构如下:
    • direction:表示边的方向(OUT,IN,BOTH),默认是BOTH
    • labels:边的类型列表
    • properties:通过属性的值过滤边
    • max_times:当前step可以重复的次数,当为N时,表示从起始顶点可以经过当前step 1-N 次
    • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,默认为 10000 (注: 0.12版之前 step 内仅支持 degree 作为参数名, 0.12开始统一使用 max_degree, 并向下兼容 degree 写法)
    • skip_degree:用于设置查询过程中舍弃超级顶点的最小边数,即当某个顶点的邻接边数目大于 skip_degree 时,完全舍弃该顶点。选填项,如果开启时,需满足 skip_degree >= max_degree 约束,默认为0 (不启用),表示不跳过任何点 (注意: 开启此配置后,遍历时会尝试访问一个顶点的 skip_degree 条边,而不仅仅是 max_degree 条边,这样有额外的遍历开销,对查询性能影响可能有较大影响,请确认理解后再开启)
  • with_ring:Boolean值,true表示包含环路;false表示不包含环路,默认为false
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
  • limit:返回的路径的最大数目,选填项,默认为10
  • with_vertex:true表示返回结果包含完整的顶点信息(路径中的全部顶点),false时表示只返回顶点id,选填项,默认为false
3.2.16.2 使用方法
Method & Url
  1. POST http://localhost:8080/graphs/{graph}/traversers/templatepaths
Request Body
  1. {
  2. "sources": {
  3. "ids": [],
  4. "label": "person",
  5. "properties": {
  6. "name": "vadas"
  7. }
  8. },
  9. "targets": {
  10. "ids": [],
  11. "label": "software",
  12. "properties": {
  13. "name": "ripple"
  14. }
  15. },
  16. "steps": [
  17. {
  18. "direction": "IN",
  19. "labels": ["knows"],
  20. "properties": {
  21. },
  22. "max_degree": 10000,
  23. "skip_degree": 100000
  24. },
  25. {
  26. "direction": "OUT",
  27. "labels": ["created"],
  28. "properties": {
  29. },
  30. "max_degree": 10000,
  31. "skip_degree": 100000
  32. },
  33. {
  34. "direction": "IN",
  35. "labels": ["created"],
  36. "properties": {
  37. },
  38. "max_degree": 10000,
  39. "skip_degree": 100000
  40. },
  41. {
  42. "direction": "OUT",
  43. "labels": ["created"],
  44. "properties": {
  45. },
  46. "max_degree": 10000,
  47. "skip_degree": 100000
  48. }
  49. ],
  50. "capacity": 10000,
  51. "limit": 10,
  52. "with_vertex": true
  53. }
Response Status
  1. 200
Response Body
  1. {
  2. "paths": [
  3. {
  4. "objects": [
  5. "1:vadas",
  6. "1:marko",
  7. "2:lop",
  8. "1:josh",
  9. "2:ripple"
  10. ]
  11. }
  12. ],
  13. "vertices": [
  14. {
  15. "id": "2:ripple",
  16. "label": "software",
  17. "type": "vertex",
  18. "properties": {
  19. "name": "ripple",
  20. "lang": "java",
  21. "price": 199
  22. }
  23. },
  24. {
  25. "id": "1:marko",
  26. "label": "person",
  27. "type": "vertex",
  28. "properties": {
  29. "name": "marko",
  30. "age": 29,
  31. "city": "Beijing"
  32. }
  33. },
  34. {
  35. "id": "1:josh",
  36. "label": "person",
  37. "type": "vertex",
  38. "properties": {
  39. "name": "josh",
  40. "age": 32,
  41. "city": "Beijing"
  42. }
  43. },
  44. {
  45. "id": "1:vadas",
  46. "label": "person",
  47. "type": "vertex",
  48. "properties": {
  49. "name": "vadas",
  50. "age": 27,
  51. "city": "Hongkong"
  52. }
  53. },
  54. {
  55. "id": "2:lop",
  56. "label": "software",
  57. "type": "vertex",
  58. "properties": {
  59. "name": "lop",
  60. "lang": "java",
  61. "price": 328
  62. }
  63. }
  64. ]
  65. }
3.2.16.3 适用场景

适合查找各种复杂的模板路径,比如personA -(朋友)-> personB -(同学)-> personC,其中”朋友”和”同学”边可以分别是最多3层和4层的情况

3.2.17 Crosspoints

3.2.17.1 功能介绍

根据起始顶点、目的顶点、方向、边的类型(可选)和最大深度等条件查找相交点

Params
  • source:起始顶点id,必填项
  • target:目的顶点id,必填项
  • direction:起始顶点到目的顶点的方向, 目的点到起始点是反方向,BOTH时不考虑方向(OUT,IN,BOTH),选填项,默认是BOTH
  • label:边的类型,选填项,默认代表所有edge label
  • max_depth:步数,必填项
  • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,选填项,默认为10000
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
  • limit:返回的交点的最大数目,选填项,默认为10
3.2.17.2 使用方法
Method & Url
  1. GET http://localhost:8080/graphs/{graph}/traversers/crosspoints?source="2:lop"&target="2:ripple"&max_depth=5&direction=IN
Response Status
  1. 200
Response Body
  1. {
  2. "crosspoints":[
  3. {
  4. "crosspoint":"1:josh",
  5. "objects":[
  6. "2:lop",
  7. "1:josh",
  8. "2:ripple"
  9. ]
  10. }
  11. ]
  12. }
3.2.17.3 适用场景

查找两个顶点的交点及其路径,例如:

  • 社交网络中,查找两个用户共同关注的话题或者大V
  • 家族关系中,查找共同的祖先

3.2.18 Customized Crosspoints

3.2.18.1 功能介绍

根据一批起始顶点、多种边规则(包括方向、边的类型和属性过滤)和最大深度等条件查找符合条件的所有的路径终点的交集

Params
  • sources:定义起始顶点,必填项,指定方式包括:

    • ids:通过顶点id列表提供起始顶点
    • label和properties:如果没有指定ids,则使用label和properties的联合条件查询起始顶点
      • label:顶点的类型
      • properties:通过属性的值查询起始顶点

        注意:properties中的属性值可以是列表,表示只要key对应的value在列表中就可以

  • path_patterns:表示从起始顶点走过的路径规则,是一组规则的列表。必填项。每个规则是一个PathPattern

    • 每个PathPattern是一组Step列表,每个Step结构如下:
      • direction:表示边的方向(OUT,IN,BOTH),默认是BOTH
      • labels:边的类型列表
      • properties:通过属性的值过滤边
      • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,默认为 10000 (注: 0.12版之前 step 内仅支持 degree 作为参数名, 0.12开始统一使用 max_degree, 并向下兼容 degree 写法)
      • skip_degree:用于设置查询过程中舍弃超级顶点的最小边数,即当某个顶点的邻接边数目大于 skip_degree 时,完全舍弃该顶点。选填项,如果开启时,需满足 skip_degree >= max_degree 约束,默认为0 (不启用),表示不跳过任何点 (注意: 开启此配置后,遍历时会尝试访问一个顶点的 skip_degree 条边,而不仅仅是 max_degree 条边,这样有额外的遍历开销,对查询性能影响可能有较大影响,请确认理解后再开启)
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
  • limit:返回的路径的最大数目,选填项,默认为10
  • with_path:true表示返回交点所在的路径,false表示不返回交点所在的路径,选填项,默认为false
  • with_vertex,选填项,默认为false:
    • true表示返回结果包含完整的顶点信息(路径中的全部顶点)
      • with_path为true时,返回所有路径中的顶点的完整信息
      • with_path为false时,返回所有交点的完整信息
    • false时表示只返回顶点id
3.2.18.2 使用方法
Method & Url
  1. POST http://localhost:8080/graphs/{graph}/traversers/customizedcrosspoints
Request Body
  1. {
  2. "sources":{
  3. "ids":[
  4. "2:lop",
  5. "2:ripple"
  6. ]
  7. },
  8. "path_patterns":[
  9. {
  10. "steps":[
  11. {
  12. "direction":"IN",
  13. "labels":[
  14. "created"
  15. ],
  16. "max_degree":-1
  17. }
  18. ]
  19. }
  20. ],
  21. "with_path":true,
  22. "with_vertex":true,
  23. "capacity":-1,
  24. "limit":-1
  25. }
Response Status
  1. 200
Response Body
  1. {
  2. "crosspoints":[
  3. "1:josh"
  4. ],
  5. "paths":[
  6. {
  7. "objects":[
  8. "2:ripple",
  9. "1:josh"
  10. ]
  11. },
  12. {
  13. "objects":[
  14. "2:lop",
  15. "1:josh"
  16. ]
  17. }
  18. ],
  19. "vertices":[
  20. {
  21. "id":"2:ripple",
  22. "label":"software",
  23. "type":"vertex",
  24. "properties":{
  25. "price":[
  26. {
  27. "id":"2:ripple>price",
  28. "value":199
  29. }
  30. ],
  31. "name":[
  32. {
  33. "id":"2:ripple>name",
  34. "value":"ripple"
  35. }
  36. ],
  37. "lang":[
  38. {
  39. "id":"2:ripple>lang",
  40. "value":"java"
  41. }
  42. ]
  43. }
  44. },
  45. {
  46. "id":"1:josh",
  47. "label":"person",
  48. "type":"vertex",
  49. "properties":{
  50. "city":[
  51. {
  52. "id":"1:josh>city",
  53. "value":"Beijing"
  54. }
  55. ],
  56. "name":[
  57. {
  58. "id":"1:josh>name",
  59. "value":"josh"
  60. }
  61. ],
  62. "age":[
  63. {
  64. "id":"1:josh>age",
  65. "value":32
  66. }
  67. ]
  68. }
  69. },
  70. {
  71. "id":"2:lop",
  72. "label":"software",
  73. "type":"vertex",
  74. "properties":{
  75. "price":[
  76. {
  77. "id":"2:lop>price",
  78. "value":328
  79. }
  80. ],
  81. "name":[
  82. {
  83. "id":"2:lop>name",
  84. "value":"lop"
  85. }
  86. ],
  87. "lang":[
  88. {
  89. "id":"2:lop>lang",
  90. "value":"java"
  91. }
  92. ]
  93. }
  94. }
  95. ]
  96. }
3.2.18.3 适用场景

查询一组顶点通过多种路径在终点有交集的情况。例如:

  • 在商品图谱中,多款手机、学习机、游戏机通过不同的低级别的类目路径,最终都属于一级类目的电子设备

3.2.19 Rings

3.2.19.1 功能介绍

根据起始顶点、方向、边的类型(可选)和最大深度等条件查找可达的环路

例如:1 -> 25 -> 775 -> 14690 -> 25, 其中环路为 25 -> 775 -> 14690 -> 25

Params
  • source:起始顶点id,必填项
  • direction:起始顶点发出的边的方向(OUT,IN,BOTH),选填项,默认是BOTH
  • label:边的类型,选填项,默认代表所有edge label
  • max_depth:步数,必填项
  • source_in_ring:环路是否包含起点,选填项,默认为true
  • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,选填项,默认为10000
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
  • limit:返回的可达环路的最大数目,选填项,默认为10
3.2.19.2 使用方法
Method & Url
  1. GET http://localhost:8080/graphs/{graph}/traversers/rings?source="1:marko"&max_depth=2
Response Status
  1. 200
Response Body
  1. {
  2. "rings":[
  3. {
  4. "objects":[
  5. "1:marko",
  6. "1:josh",
  7. "1:marko"
  8. ]
  9. },
  10. {
  11. "objects":[
  12. "1:marko",
  13. "1:vadas",
  14. "1:marko"
  15. ]
  16. },
  17. {
  18. "objects":[
  19. "1:marko",
  20. "2:lop",
  21. "1:marko"
  22. ]
  23. }
  24. ]
  25. }
3.2.19.3 适用场景

查询起始顶点可达的环路,例如:

  • 风控项目中,查询一个用户可达的循环担保的人或者设备
  • 设备关联网络中,发现一个设备周围的循环引用的设备

3.2.20 Rays

3.2.20.1 功能介绍

根据起始顶点、方向、边的类型(可选)和最大深度等条件查找发散到边界顶点的路径

例如:1 -> 25 -> 775 -> 14690 -> 2289 -> 18379, 其中 18379 为边界顶点,即没有从 18379 发出的边

Params
  • source:起始顶点id,必填项
  • direction:起始顶点发出的边的方向(OUT,IN,BOTH),选填项,默认是BOTH
  • label:边的类型,选填项,默认代表所有edge label
  • max_depth:步数,必填项
  • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,选填项,默认为10000
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
  • limit:返回的非环路的最大数目,选填项,默认为10
3.2.20.2 使用方法
Method & Url
  1. GET http://localhost:8080/graphs/{graph}/traversers/rays?source="1:marko"&max_depth=2&direction=OUT
Response Status
  1. 200
Response Body
  1. {
  2. "rays":[
  3. {
  4. "objects":[
  5. "1:marko",
  6. "1:vadas"
  7. ]
  8. },
  9. {
  10. "objects":[
  11. "1:marko",
  12. "2:lop"
  13. ]
  14. },
  15. {
  16. "objects":[
  17. "1:marko",
  18. "1:josh",
  19. "2:ripple"
  20. ]
  21. },
  22. {
  23. "objects":[
  24. "1:marko",
  25. "1:josh",
  26. "2:lop"
  27. ]
  28. }
  29. ]
  30. }
3.2.20.3 适用场景

查找起始顶点到某种关系的边界顶点的路径,例如:

  • 家族关系中,查找一个人到所有还没有孩子的子孙的路径
  • 设备关联网络中,找到某个设备到终端设备的路径

3.2.21 Fusiform Similarity

3.2.21.1 功能介绍

按照条件查询一批顶点对应的”梭形相似点”。当两个顶点跟很多共同的顶点之间有某种关系的时候,我们认为这两个点为”梭形相似点”。举个例子说明”梭形相似点”:”读者A”读了100本书,可以定义读过这100本书中的80本以上的读者,是”读者A”的”梭形相似点”

Params
  • sources:定义起始顶点,必填项,指定方式包括:

    • ids:通过顶点id列表提供起始顶点
    • label和properties:如果没有指定ids,则使用label和properties的联合条件查询起始顶点
      • label:顶点的类型
      • properties:通过属性的值查询起始顶点

        注意:properties中的属性值可以是列表,表示只要key对应的value在列表中就可以

  • label:边的类型,选填项,默认代表所有edge label

  • direction:起始顶点向外发散的方向(OUT,IN,BOTH),选填项,默认是BOTH
  • min_neighbors:最少邻居数目,邻居数目少于这个阈值时,认为起点不具备”梭形相似点”。比如想要找一个”读者A”读过的书的”梭形相似点”,那么min_neighbors为100时,表示”读者A”至少要读过100本书才可以有”梭形相似点”,必填项
  • alpha:相似度,代表:起点与”梭形相似点”的共同邻居数目占起点的全部邻居数目的比例,必填项
  • min_similars:”梭形相似点”的最少个数,只有当起点的”梭形相似点”数目大于或等于该值时,才会返回起点及其”梭形相似点”,选填项,默认值为1
  • top:返回一个起点的”梭形相似点”中相似度最高的top个,必填项,0表示全部
  • group_property:与min_groups一起使用,当起点跟其所有的”梭形相似点”某个属性的值有至少min_groups个不同值时,才会返回该起点及其”梭形相似点”。比如为”读者A”推荐”异地”书友时,需要设置group_property为读者的”城市”属性,min_group至少为2,选填项,不填代表不需要根据属性过滤
  • min_groups:与group_property一起使用,只有group_property设置时才有意义
  • max_degree:查询过程中,单个顶点遍历的最大邻接边数目,选填项,默认为10000
  • capacity:遍历过程中最大的访问的顶点数目,选填项,默认为10000000
  • limit:返回的结果数目上限(一个起点及其”梭形相似点”算一个结果),选填项,默认为10
  • with_intermediary:是否返回起点及其”梭形相似点”共同关联的中间点,默认为false
  • with_vertex,选填项,默认为false:
    • true表示返回结果包含完整的顶点信息
    • false时表示只返回顶点id
3.2.21.2 使用方法
Method & Url
  1. POST http://localhost:8080/graphs/hugegraph/traversers/fusiformsimilarity
Request Body
  1. {
  2. "sources":{
  3. "ids":[],
  4. "label": "person",
  5. "properties": {
  6. "name":"p1"
  7. }
  8. },
  9. "label":"read",
  10. "direction":"OUT",
  11. "min_neighbors":8,
  12. "alpha":0.75,
  13. "min_similars":1,
  14. "top":0,
  15. "group_property":"city",
  16. "min_group":2,
  17. "max_degree": 10000,
  18. "capacity": -1,
  19. "limit": -1,
  20. "with_intermediary": false,
  21. "with_vertex":true
  22. }
Response Status
  1. 200
Response Body
  1. {
  2. "similars": {
  3. "3:p1": [
  4. {
  5. "id": "3:p2",
  6. "score": 0.8888888888888888,
  7. "intermediaries": [
  8. ]
  9. },
  10. {
  11. "id": "3:p3",
  12. "score": 0.7777777777777778,
  13. "intermediaries": [
  14. ]
  15. }
  16. ]
  17. },
  18. "vertices": [
  19. {
  20. "id": "3:p1",
  21. "label": "person",
  22. "type": "vertex",
  23. "properties": {
  24. "name": "p1",
  25. "city": "Beijing"
  26. }
  27. },
  28. {
  29. "id": "3:p2",
  30. "label": "person",
  31. "type": "vertex",
  32. "properties": {
  33. "name": "p2",
  34. "city": "Shanghai"
  35. }
  36. },
  37. {
  38. "id": "3:p3",
  39. "label": "person",
  40. "type": "vertex",
  41. "properties": {
  42. "name": "p3",
  43. "city": "Beijing"
  44. }
  45. }
  46. ]
  47. }
3.2.21.3 适用场景

查询一组顶点相似度很高的顶点。例如:

  • 跟一个读者有类似书单的读者
  • 跟一个玩家玩类似游戏的玩家

3.2.22 Vertices

3.2.22.1 根据顶点的id列表,批量查询顶点
Params
  • ids:要查询的顶点id列表
Method & Url
  1. GET http://localhost:8080/graphs/hugegraph/traversers/vertices?ids="1:marko"&ids="2:lop"
Response Status
  1. 200
Response Body
  1. {
  2. "vertices":[
  3. {
  4. "id":"1:marko",
  5. "label":"person",
  6. "type":"vertex",
  7. "properties":{
  8. "city":[
  9. {
  10. "id":"1:marko>city",
  11. "value":"Beijing"
  12. }
  13. ],
  14. "name":[
  15. {
  16. "id":"1:marko>name",
  17. "value":"marko"
  18. }
  19. ],
  20. "age":[
  21. {
  22. "id":"1:marko>age",
  23. "value":29
  24. }
  25. ]
  26. }
  27. },
  28. {
  29. "id":"2:lop",
  30. "label":"software",
  31. "type":"vertex",
  32. "properties":{
  33. "price":[
  34. {
  35. "id":"2:lop>price",
  36. "value":328
  37. }
  38. ],
  39. "name":[
  40. {
  41. "id":"2:lop>name",
  42. "value":"lop"
  43. }
  44. ],
  45. "lang":[
  46. {
  47. "id":"2:lop>lang",
  48. "value":"java"
  49. }
  50. ]
  51. }
  52. }
  53. ]
  54. }
3.2.22.2 获取顶点 Shard 信息

通过指定的分片大小split_size,获取顶点分片信息(可以与 3.2.21.3 中的 Scan 配合使用来获取顶点)。

Params
  • split_size:分片大小,必填项
Method & Url
  1. GET http://localhost:8080/graphs/hugegraph/traversers/vertices/shards?split_size=67108864
Response Status
  1. 200
Response Body
  1. {
  2. "shards":[
  3. {
  4. "start": "0",
  5. "end": "2165893",
  6. "length": 0
  7. },
  8. {
  9. "start": "2165893",
  10. "end": "4331786",
  11. "length": 0
  12. },
  13. {
  14. "start": "4331786",
  15. "end": "6497679",
  16. "length": 0
  17. },
  18. {
  19. "start": "6497679",
  20. "end": "8663572",
  21. "length": 0
  22. },
  23. ......
  24. ]
  25. }
3.2.22.3 根据Shard信息批量获取顶点

通过指定的分片信息批量查询顶点(Shard信息的获取参见 3.2.21.2 Shard)。

Params
  • start:分片起始位置,必填项
  • end:分片结束位置,必填项
  • page:分页位置,选填项,默认为null,不分页;当page为“”时表示分页的第一页,从start指示的位置开始
  • page_limit:分页获取顶点时,一页中顶点数目的上限,选填项,默认为100000
Method & Url
  1. GET http://localhost:8080/graphs/hugegraph/traversers/vertices/scan?start=0&end=4294967295
Response Status
  1. 200
Response Body
  1. {
  2. "vertices":[
  3. {
  4. "id":"2:ripple",
  5. "label":"software",
  6. "type":"vertex",
  7. "properties":{
  8. "price":[
  9. {
  10. "id":"2:ripple>price",
  11. "value":199
  12. }
  13. ],
  14. "name":[
  15. {
  16. "id":"2:ripple>name",
  17. "value":"ripple"
  18. }
  19. ],
  20. "lang":[
  21. {
  22. "id":"2:ripple>lang",
  23. "value":"java"
  24. }
  25. ]
  26. }
  27. },
  28. {
  29. "id":"1:vadas",
  30. "label":"person",
  31. "type":"vertex",
  32. "properties":{
  33. "city":[
  34. {
  35. "id":"1:vadas>city",
  36. "value":"Hongkong"
  37. }
  38. ],
  39. "name":[
  40. {
  41. "id":"1:vadas>name",
  42. "value":"vadas"
  43. }
  44. ],
  45. "age":[
  46. {
  47. "id":"1:vadas>age",
  48. "value":27
  49. }
  50. ]
  51. }
  52. },
  53. {
  54. "id":"1:peter",
  55. "label":"person",
  56. "type":"vertex",
  57. "properties":{
  58. "city":[
  59. {
  60. "id":"1:peter>city",
  61. "value":"Shanghai"
  62. }
  63. ],
  64. "name":[
  65. {
  66. "id":"1:peter>name",
  67. "value":"peter"
  68. }
  69. ],
  70. "age":[
  71. {
  72. "id":"1:peter>age",
  73. "value":35
  74. }
  75. ]
  76. }
  77. },
  78. {
  79. "id":"1:josh",
  80. "label":"person",
  81. "type":"vertex",
  82. "properties":{
  83. "city":[
  84. {
  85. "id":"1:josh>city",
  86. "value":"Beijing"
  87. }
  88. ],
  89. "name":[
  90. {
  91. "id":"1:josh>name",
  92. "value":"josh"
  93. }
  94. ],
  95. "age":[
  96. {
  97. "id":"1:josh>age",
  98. "value":32
  99. }
  100. ]
  101. }
  102. },
  103. {
  104. "id":"1:marko",
  105. "label":"person",
  106. "type":"vertex",
  107. "properties":{
  108. "city":[
  109. {
  110. "id":"1:marko>city",
  111. "value":"Beijing"
  112. }
  113. ],
  114. "name":[
  115. {
  116. "id":"1:marko>name",
  117. "value":"marko"
  118. }
  119. ],
  120. "age":[
  121. {
  122. "id":"1:marko>age",
  123. "value":29
  124. }
  125. ]
  126. }
  127. },
  128. {
  129. "id":"2:lop",
  130. "label":"software",
  131. "type":"vertex",
  132. "properties":{
  133. "price":[
  134. {
  135. "id":"2:lop>price",
  136. "value":328
  137. }
  138. ],
  139. "name":[
  140. {
  141. "id":"2:lop>name",
  142. "value":"lop"
  143. }
  144. ],
  145. "lang":[
  146. {
  147. "id":"2:lop>lang",
  148. "value":"java"
  149. }
  150. ]
  151. }
  152. }
  153. ]
  154. }
3.2.22.4 适用场景
  • 按id列表查询顶点,可用于批量查询顶点,比如在path查询到多条路径之后,可以进一步查询某条路径的所有顶点属性。
  • 获取分片和按分片查询顶点,可以用来遍历全部顶点

3.2.23 Edges

3.2.23.1 根据边的id列表,批量查询边
Params
  • ids:要查询的边id列表
Method & Url
  1. GET http://localhost:8080/graphs/hugegraph/traversers/edges?ids="S1:josh>1>>S2:lop"&ids="S1:josh>1>>S2:ripple"
Response Status
  1. 200
Response Body
  1. {
  2. "edges": [
  3. {
  4. "id": "S1:josh>1>>S2:lop",
  5. "label": "created",
  6. "type": "edge",
  7. "inVLabel": "software",
  8. "outVLabel": "person",
  9. "inV": "2:lop",
  10. "outV": "1:josh",
  11. "properties": {
  12. "date": "20091111",
  13. "weight": 0.4
  14. }
  15. },
  16. {
  17. "id": "S1:josh>1>>S2:ripple",
  18. "label": "created",
  19. "type": "edge",
  20. "inVLabel": "software",
  21. "outVLabel": "person",
  22. "inV": "2:ripple",
  23. "outV": "1:josh",
  24. "properties": {
  25. "date": "20171210",
  26. "weight": 1
  27. }
  28. }
  29. ]
  30. }
3.2.23.2 获取边 Shard 信息

通过指定的分片大小split_size,获取边分片信息(可以与 3.2.22.3 中的 Scan 配合使用来获取边)。

Params
  • split_size:分片大小,必填项
Method & Url
  1. GET http://localhost:8080/graphs/hugegraph/traversers/edges/shards?split_size=4294967295
Response Status
  1. 200
Response Body
  1. {
  2. "shards":[
  3. {
  4. "start": "0",
  5. "end": "1073741823",
  6. "length": 0
  7. },
  8. {
  9. "start": "1073741823",
  10. "end": "2147483646",
  11. "length": 0
  12. },
  13. {
  14. "start": "2147483646",
  15. "end": "3221225469",
  16. "length": 0
  17. },
  18. {
  19. "start": "3221225469",
  20. "end": "4294967292",
  21. "length": 0
  22. },
  23. {
  24. "start": "4294967292",
  25. "end": "4294967295",
  26. "length": 0
  27. }
  28. ]
  29. }
3.2.23.3 根据 Shard 信息批量获取边

通过指定的分片信息批量查询边(Shard信息的获取参见 3.2.22.2)。

Params
  • start:分片起始位置,必填项
  • end:分片结束位置,必填项
  • page:分页位置,选填项,默认为null,不分页;当page为“”时表示分页的第一页,从start指示的位置开始
  • page_limit:分页获取边时,一页中边数目的上限,选填项,默认为100000
Method & Url
  1. GET http://localhost:8080/graphs/hugegraph/traversers/edges/scan?start=0&end=3221225469
Response Status
  1. 200
Response Body
  1. {
  2. "edges":[
  3. {
  4. "id":"S1:peter>2>>S2:lop",
  5. "label":"created",
  6. "type":"edge",
  7. "inVLabel":"software",
  8. "outVLabel":"person",
  9. "inV":"2:lop",
  10. "outV":"1:peter",
  11. "properties":{
  12. "weight":0.2,
  13. "date":"20170324"
  14. }
  15. },
  16. {
  17. "id":"S1:josh>2>>S2:lop",
  18. "label":"created",
  19. "type":"edge",
  20. "inVLabel":"software",
  21. "outVLabel":"person",
  22. "inV":"2:lop",
  23. "outV":"1:josh",
  24. "properties":{
  25. "weight":0.4,
  26. "date":"20091111"
  27. }
  28. },
  29. {
  30. "id":"S1:josh>2>>S2:ripple",
  31. "label":"created",
  32. "type":"edge",
  33. "inVLabel":"software",
  34. "outVLabel":"person",
  35. "inV":"2:ripple",
  36. "outV":"1:josh",
  37. "properties":{
  38. "weight":1,
  39. "date":"20171210"
  40. }
  41. },
  42. {
  43. "id":"S1:marko>1>20130220>S1:josh",
  44. "label":"knows",
  45. "type":"edge",
  46. "inVLabel":"person",
  47. "outVLabel":"person",
  48. "inV":"1:josh",
  49. "outV":"1:marko",
  50. "properties":{
  51. "weight":1,
  52. "date":"20130220"
  53. }
  54. },
  55. {
  56. "id":"S1:marko>1>20160110>S1:vadas",
  57. "label":"knows",
  58. "type":"edge",
  59. "inVLabel":"person",
  60. "outVLabel":"person",
  61. "inV":"1:vadas",
  62. "outV":"1:marko",
  63. "properties":{
  64. "weight":0.5,
  65. "date":"20160110"
  66. }
  67. },
  68. {
  69. "id":"S1:marko>2>>S2:lop",
  70. "label":"created",
  71. "type":"edge",
  72. "inVLabel":"software",
  73. "outVLabel":"person",
  74. "inV":"2:lop",
  75. "outV":"1:marko",
  76. "properties":{
  77. "weight":0.4,
  78. "date":"20171210"
  79. }
  80. }
  81. ]
  82. }
3.2.23.4 适用场景
  • 按id列表查询边,可用于批量查询边
  • 获取分片和按分片查询边,可以用来遍历全部边