Gremlin 如何获得janusgraph的组合脚本结果？

图表如下：

gremlin> a = graph.addVertex("name", "alice")
gremlin> b = graph.addVertex("name", "bobby")
gremlin> c = graph.addVertex("name", "cindy")
gremlin> d = graph.addVertex("name", "david")
gremlin> e = graph.addVertex("name", "eliza")
gremlin> a.addEdge("rates",b,"tag","ruby","value",9)
gremlin> b.addEdge("rates",c,"tag","ruby","value",8)
gremlin> c.addEdge("rates",d,"tag","ruby","value",7)
gremlin> d.addEdge("rates",e,"tag","ruby","value",6)
gremlin> e.addEdge("rates",a,"tag","java","value",10)

我有以下3个脚本：

脚本#1

gremlin> g.V().has('name','alice').
           repeat(out()).
             until(has('name','alice')).
           cyclicPath().
           path().by('name')`
==>[alice,bobby,cindy,david,eliza,alice]

脚本#2

gremlin> g.V().has('name','alice').
           repeat(outE().inV()).
             until(has('name','alice')).
           cyclicPath().
           group().
             by('name').
             by(path().unfold().has('value').values('value').fold()).
           next()
==>alice=[9, 8, 7, 6, 10]

脚本#3

gremlin> g.V().has('name','alice').
           repeat(outE().inV()).
             until(has('name','alice')).
           cyclicPath().
           group().
             by('name').
             by(path().unfold().has('value').values('value').fold()).
           next().collect { k, v ->
             k + '=' + v.withIndex().collect { Integer it, Integer idx ->
                 return it * (1/(idx + 1))
             }.inject(0.0) { acc,i -> acc + i }
           }
==>alice=18.8333333331

我的问题是，我怎样才能得到下面列出的结果？把这三个字母组合起来就行了

alice=[alice,bobby,cindy,david,eliza,alice]=[9, 8, 7, 6, 10]=18.8333333331

---

Gremlin代码是在Groovy执行器中执行的，因此所有Groovy操作符在这里都是有效的。您可以将结果添加到列表并返回列表，即

def l=[]；Gremlin代码是在Groovy执行器中执行的，因此所有Groovy操作符在这里都是有效的。您可以将结果添加到列表并返回列表，即
def l=[]；l按照David的建议，执行3个查询，然后合并结果可能更容易，或者至少更易于维护。但是，如果要在单个查询中完成所有操作，可以：

g.V().has('name','alice').as('v').
  repeat(outE().as('e').inV().as('v')).
    until(has('name','alice')).
  store('a').
    by('name').
  store('a').
    by(select(all, 'v').unfold().values('name').fold()).
  store('a').
    by(select(all, 'e').unfold().
       store('x').
         by(union(values('value'),
                  select('x').count(local)).fold()).
       cap('x').
       store('a').
         by(unfold().limit(local, 1).fold()).unfold().
       sack(assign).
         by(constant(1d)).
       sack(div).
         by(union(constant(1d),
                  tail(local, 1)).sum()).
       sack(mult).
         by(limit(local, 1)).
       sack().sum()).
  cap('a')

使用示例图：

gremlin> g.V().has('name','alice').as('v').
......1>   repeat(outE().as('e').inV().as('v')).
......2>     until(has('name','alice')).
......3>   store('a').
......4>     by('name').
......5>   store('a').
......6>     by(select(all, 'v').unfold().values('name').fold()).
......7>   store('a').
......8>     by(select(all, 'e').unfold().
......9>        store('x').
.....10>          by(union(values('value'),
.....11>                   select('x').count(local)).fold()).
.....12>        cap('x').
.....13>        store('a').
.....14>          by(unfold().limit(local, 1).fold()).unfold().
.....15>        sack(assign).
.....16>          by(constant(1d)).
.....17>        sack(div).
.....18>          by(union(constant(1d),
.....19>                   tail(local, 1)).sum()).
.....20>        sack(mult).
.....21>          by(limit(local, 1)).
.....22>        sack().sum()).
.....23>   cap('a')
==>[alice,[alice,bobby,cindy,david,eliza,alice],[9,8,7,6,10],18.833333333333332]

在一个查询中完成这一切有一些好处，特别是当您不必一次又一次地遍历同一条路径时，但是同样地，很难维护这样复杂的查询。最好只返回完整路径，然后在客户端生成预期结果。
执行3个查询，然后按照David的建议合并结果，可能更容易或至少更易于维护。但是，如果要在单个查询中完成所有操作，可以：

g.V().has('name','alice').as('v').
  repeat(outE().as('e').inV().as('v')).
    until(has('name','alice')).
  store('a').
    by('name').
  store('a').
    by(select(all, 'v').unfold().values('name').fold()).
  store('a').
    by(select(all, 'e').unfold().
       store('x').
         by(union(values('value'),
                  select('x').count(local)).fold()).
       cap('x').
       store('a').
         by(unfold().limit(local, 1).fold()).unfold().
       sack(assign).
         by(constant(1d)).
       sack(div).
         by(union(constant(1d),
                  tail(local, 1)).sum()).
       sack(mult).
         by(limit(local, 1)).
       sack().sum()).
  cap('a')

使用示例图：

gremlin> g.V().has('name','alice').as('v').
......1>   repeat(outE().as('e').inV().as('v')).
......2>     until(has('name','alice')).
......3>   store('a').
......4>     by('name').
......5>   store('a').
......6>     by(select(all, 'v').unfold().values('name').fold()).
......7>   store('a').
......8>     by(select(all, 'e').unfold().
......9>        store('x').
.....10>          by(union(values('value'),
.....11>                   select('x').count(local)).fold()).
.....12>        cap('x').
.....13>        store('a').
.....14>          by(unfold().limit(local, 1).fold()).unfold().
.....15>        sack(assign).
.....16>          by(constant(1d)).
.....17>        sack(div).
.....18>          by(union(constant(1d),
.....19>                   tail(local, 1)).sum()).
.....20>        sack(mult).
.....21>          by(limit(local, 1)).
.....22>        sack().sum()).
.....23>   cap('a')
==>[alice,[alice,bobby,cindy,david,eliza,alice],[9,8,7,6,10],18.833333333333332]

在一个查询中完成这一切有一些好处，特别是当您不必一次又一次地遍历同一条路径时，但是同样地，很难维护这样复杂的查询。最好返回完整路径，然后在客户端生成预期结果。
我的另一个问题是，我们可以添加边缘吗？像下面这样？爱丽丝=[alice，bobby，cindy，david，eliza，alice]=[e[172-38w-1lh-3bs][4208费率->4312]，e2，e3，e4，e5]=[9，8，7，6，10]=18.8333331我的另一个问题是，我们可以增加优势吗？如下图所示？alice=[alice，bobby，cindy，david，eliza，alice]=[e[172-38w-1lh-3bs][4208 rates->4312]，e2，e3，e4，e5]=[9，8，7，6，10]=18.8333333331注意，我刚刚创建了这个问题：在gremlin中提供了一种更容易表示使用index（）执行
的方法
注意，我刚刚创建了这个问题：这是为了在gremlin中提供一种更容易表示使用index（）执行
的方法。