Fan out from set of vertices

[Keith Lohnes]

Say you have a set of vertices in a k-ary tree of an unknown depth, is there a way to fan out from that set of vertices?
e.g.

v1_0 = graph.addVertex(id, 2, "name", "1:0")
v1_1 = graph.addVertex(id, 3, "name", "1:1")
v1_2 = graph.addVertex(id, 4, "name", "1:2")
v2_0 = graph.addVertex(id, 5, "name", "2:0")
v2_1 = graph.addVertex(id, 6, "name", "2:1")
v2_2 = graph.addVertex(id, 7, "name", "2:2")
v2_3 = graph.addVertex(id, 8, "name", "2:3")
v2_4 = graph.addVertex(id, 9, "name", "2:4")
v2_5 = graph.addVertex(id, 10, "name", "2:5")
v2_6 = graph.addVertex(id, 11, "name", "2:6")
v2_7 = graph.addVertex(id, 12, "name", "2:7")
v2_8 = graph.addVertex(id, 13, "name", "2:8")

v0_0.addEdge("parent", v1_0, id, 14, "orderNumber", 0)
v0_0.addEdge("parent", v1_1, id, 15, "orderNumber", 1)
v0_0.addEdge("parent", v1_2, id, 16, "orderNumber", 2)

v1_0.addEdge("parent", v2_0, id, 17, "orderNumber", 0)
v1_0.addEdge("parent", v2_1, id, 18, "orderNumber", 1)
v1_0.addEdge("parent", v2_2, id, 19, "orderNumber", 2)

v1_1.addEdge("parent", v2_3, id, 20, "orderNumber", 0)
v1_1.addEdge("parent", v2_4, id, 21, "orderNumber", 1)
v1_1.addEdge("parent", v2_5, id, 22, "orderNumber", 2)

v1_2.addEdge("parent", v2_6, id, 23, "orderNumber", 0)
v1_2.addEdge("parent", v2_7, id, 24, "orderNumber", 1)
v1_2.addEdge("parent", v2_8, id, 25, "orderNumber", 2)

Repeat isn’t quite what I’d want

gremlin> g.V(5, 6, 7, 8, 9, 10, 11, 12, 13).repeat(__.in()).emit().dedup().values("name") yields

==>1:0
==>0:0
==>1:1
==>1:2

Is there a way to query this that would yield

==>1:0
==>1:1
==>1:2
==>0:0

for a general case, i.e. not doing

gremlin> g.V(5, 6, 7, 8, 9, 10, 11, 12, 13).in().store("foo").in().store("foo").cap("foo").unfold().dedup().values("name")
==>1:0
==>1:1
==>1:2
==>0:0

​

[Daniel Kuppitz]

You can order your result by the depth / path length:

gremlin> g.withSack(1).V(5, 6, 7, 8, 9, 10, 11, 12, 13).

......1>   repeat(__.in().sack(sum).by(constant(1))).

......2>     emit().

......3>   dedup().

......4>   project("a","b").

......5>     by("name").

......6>     by(sack()).

......7>   order().

......8>     by(select("b")).

......9>   select("a")

==>1:0

==>1:1

==>1:2

==>0:0

Also, if the name property is unique, you can use group(), which should be much cheaper in this case:

 

gremlin> g.withSack(1).V(5, 6, 7, 8, 9, 10, 11, 12, 13).

......1>   repeat(__.in().sack(sum).by(constant(1))).

......2>     emit().

......3>   group().

......4>     by("name").

......5>     by(sack()).

......6>   order(local).

......7>     by(values).

......8>   select(keys).

......9>   unfold()

==>1:0

==>1:1

==>1:2

==>0:0

Note that you could also use path().count(local) to get the current depth; this way you wouldn't have to deal with sack()'s, however, enabling path tracking has a significant performance impact. Hence, if there's no other path requirement in the traversal, I would always prefer the sack() variant.

Cheers,

Daniel

--
You received this message because you are subscribed to the Google Groups "Gremlin-users" group.
To unsubscribe from this group and stop receiving emails from it, send an email to gremlin-users+unsubscribe@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/gremlin-users/bd11f92c-8175-45de-afa6-638fbe076676%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.