带有标记输出的深度图遍历

如何解决带有标记输出的深度图遍历

我正在尝试编写一个函数来生成 Gremlin 查询。该函数的输入是一个字符串数组，其中包含我们想要从图中返回的关系名称。该图表包含有关电视和电影的信息。所以一个示例输入是： [[seasons,episodes,talent],[studios,movies,images]] 字符串指的是边名称。

我需要返回一个 JSON 对象，其中包含由边名称标记的顶点的 ID，但我发现 Germlin 查询非常困难。

到目前为止，我已经设法编写了这个查询：

g.V('network_1').out().where(__.inE().
    hasLabel('seasons')).
  group().
    by(__.inE().label()).
    by(__.group().by(T.id).
        by(__.out().where(__.inE().
            hasLabel('episodes')).
          group().
            by(__.inE().label()).
            by(__.group().by(T.id).
                by(__.out().where(__.inE().
                    hasLabel('talent')).
                  group().
                    by(__.inE().label()).by(T.id))))).
  next()

给出这个输出：

{
  "seasons": {
    "season_2": {
      "episodes": {
        "episode_4": {
          "talent": [
            "talent_8","talent_6","talent_7"
          ]
        }
      }
    },"season_1": {
      "episodes": {
        "episode_2": {
          "talent": [
            "talent_2","talent_3"
          ]
        },"episode_3": {
          "talent": [
            "talent_4","talent_5"
          ]
        },"episode_1": {
          "talent": [
            "talent_1"
          ]
        }
      }
    }
  }
}

该输出正是我正在寻找的那种东西，但问题是：

该查询似乎过于复杂
要查询的边数组可以是任意大小。在我的示例中，它是 3，但它可以是任何东西。
在示例中，有 2 个边数组要查询，理想情况下我可以将它们组合成一个查询

我是用 Python 写的，如果有任何帮助或指点，我将不胜感激。

示例内容：

g.addV('show').property('id','show_1').as('show_1').
  addV('season').property('id','season_1').as('season_1').
  addV('season').property('id','season_2').as('season_2').
  addV('episode').property('id','episode_1').as('episode_1').
  addV('episode').property('id','episode_2').as('episode_2').
  addV('episode').property('id','episode_3').as('episode_3').
  addV('episode').property('id','episode_4').as('episode_4').
  addV('talent').property('id','talent_1').as('talent_1').
  addV('talent').property('id','talent_2').as('talent_2').
  addV('talent').property('id','talent_3').as('talent_3').
  addV('talent').property('id','talent_4').as('talent_4').
  addV('talent').property('id','talent_5').as('talent_5').
  addV('talent').property('id','talent_6').as('talent_6').
  addV('talent').property('id','talent_7').as('talent_7').
  addV('talent').property('id','talent_8').as('talent_8').
  addE('seasons').from('show_1').to('season_1').
  addE('seasons').from('show_1').to('season_2').
  addE('episodes').from('season_1').to('episode_1').
  addE('episodes').from('season_1').to('episode_2').
  addE('episodes').from('season_1').to('episode_3').
  addE('episodes').from('season_2').to('episode_4').
  addE('talent').from('episode_1').to('talent_1').
  addE('talent').from('episode_2').to('talent_2').
  addE('talent').from('episode_2').to('talent_3').
  addE('talent').from('episode_3').to('talent_4').
  addE('talent').from('episode_3').to('talent_5').
  addE('talent').from('episode_4').to('talent_6').
  addE('talent').from('episode_4').to('talent_7').
  addE('talent').from('episode_4').to('talent_8').iterate()

解决方法

对于 Gremlin 的 JVM 语言变体，我认为 tree() 对您很有帮助：

gremlin> g.V().out('seasons').
......1>   out('episodes').
......2>   out('talent').
......3>   tree().
......4>     by('id').next()
==>show_1={season_2={episode_4={talent_6={},talent_8={},talent_7={}}},season_1={episode_2={talent_3={},talent_2={}},episode_3={talent_5={},talent_4={}},episode_1={talent_1={}}}}

但据我回忆 tree() 在 JVM 之外，在您的情况下，Python 并没有得到很好的支持。不过你可以试试。

另一种选择，现在更适合 Python，是像您在示例中所做的那样进行一些嵌套分组。你注意到它很复杂，但我认为它只是因为到处都有回溯过滤。我还要补充一点，虽然它可能看起来有效，但我觉得它可能不适用于所有情况下，因为使用 by(__.inE().label()) 进行分组，因为它只查看被分组的每个顶点的第一个边标签.它依赖于数据的结构才能成功，因此如果突然 inE() 返回了您意想不到的东西，它可能会让您在将来遇到错误。我想你可以通过添加像 inE('seasons).label()` 这样的标签来限制这个机会，但这似乎有点不对。

我倾向于支持可以立即理解其意图的 Gremlin。因此，我采用了以下方法（它与您提供的所有键值的输出并不完全匹配，但我认为您会找到与您想要的数据相匹配的数据：

gremlin> g.V().out('seasons').
......1>   out('episodes').
......2>   out('talent').
......3>   path().
......4>     by('id').
......5>   group().
......6>     by(limit(local,1)).
......7>     by(tail(local,3).
......8>        group().
......9>          by(limit(local,1)).
.....10>          by(tail(local,2).
.....11>             group().
.....12>               by(limit(local,1)).
.....13>               by(tail(local).fold())))
==>[show_1:[season_2:[episode_4:[talent_6,talent_7,talent_8]],season_1:[episode_2:[talent_2,talent_3],episode_3:[talent_4,talent_5],episode_1:[talent_1]]]]

我喜欢这种方法，因为导航部分非常简单和直接 - out() 在“季节”上，out() 在“剧集”上，out() 在“人才”上。毫无疑问，正在收集哪些数据。在第 3 行，我们收集路径，然后对其进行嵌套组，以构建我使用 tree()-step 生成的类似树状结构。事实上，这个在输出方面更好一些，因为它不包括空叶子。

为了进一步区分，首先考虑我们正在使用的基本输出：

gremlin> g.V().out('seasons').
......1>   out('episodes').
......2>   out('talent').
......3>   path().
......4>     by('id')
==>[show_1,season_1,episode_1,talent_1]
==>[show_1,episode_2,talent_2]
==>[show_1,talent_3]
==>[show_1,episode_3,talent_4]
==>[show_1,talent_5]
==>[show_1,season_2,episode_4,talent_6]
==>[show_1,talent_7]
==>[show_1,talent_8]

我们希望对这些路径的每一层进行分组，这意味着进行嵌套的 group()。考虑第一层：

gremlin> g.V().out('seasons').
......1>   out('episodes').
......2>   out('talent').
......3>   path().
......4>     by('id').
......5>   group().
......6>     by(limit(local,3).fold())
==>[show_1:[[season_1,talent_1],[season_1,talent_2],talent_4],[season_2,talent_6],talent_7],talent_8]]]

以上将所有“节目”放在一起。请注意我们如何使用 tail(local,3) 从每个路径对象中删除“show_1”，因为我们已经对其进行了分组。接下来我们要对“季节”进行分组，以便：

gremlin> g.V().out('seasons').
......1>   out('episodes').
......2>   out('talent').
......3>   path().
......4>     by('id').
......5>   group().
......6>     by(limit(local,2).fold()))
==>[show_1:[season_2:[[episode_4,[episode_4,season_1:[[episode_1,[episode_2,[episode_3,talent_5]]]]

这里我们知道“seasons”在第一位置，所以我们用limit(local,1)取第一个，因为我们不再需要季节来进一步分组，我们用tail(local,2)将它从路径中剔除。这次是“2”而不是“3”，因为我们要减少的路径缩短到只有season->episode->talent，现在使用“2”我们只去episode->talent。希望这能进一步分解正在发生的事情，您可以根据自己的需要调整此查询。

带有标记输出的深度图遍历

如何解决带有标记输出的深度图遍历

解决方法

相关推荐