Multi-step traversal predicates in a SubgraphStrategy cause StackOverflowError

James

unread,

Aug 5, 2016, 2:53:37 AM8/5/16

to Gremlin-users

I'm hoping someone can help me with my understanding.

I've been using a subgraph strategy and it appears to work for a predicate traversal with a single step, e.g. has(...) but not a longer traversal.

So:

gremlin> graph = TinkerFactory.createModern()

==>tinkergraph[vertices:6 edges:6]

gremlin> g = graph.traversal()

==>graphtraversalsource[tinkergraph[vertices:6 edges:6], standard]

gremlin> s = SubgraphStrategy.build().vertexCriterion(hasId(1)).create()

==>SubgraphStrategy

gremlin> g.V().filter(hasId(1))

==>v[1]

gremlin> g.withStrategies(s).V()

==>v[1]

works as expected. But if I change the predicate traversal to something slightly more complex, e.g. in('knows').hasId(1) things start to go haywire.

The single step predicates works as expected in 3.1.1-incubating, 3.1.3 and 3.2.1.

In 3.1.1-incubating the multi-step predicate subgraph strategy seems to end up generating the same traversal as using filter(...) but fails to execute:

$ sh apache-gremlin-console-3.1.1-incubating/bin/gremlin.sh

\,,,/

(o o)

-----oOOo-(3)-oOOo-----

plugin activated: tinkerpop.server

plugin activated: tinkerpop.utilities

plugin activated: tinkerpop.tinkergraph

gremlin> graph = TinkerFactory.createModern()

==>tinkergraph[vertices:6 edges:6]

gremlin> g = graph.traversal()

==>graphtraversalsource[tinkergraph[vertices:6 edges:6], standard]

gremlin> s = SubgraphStrategy.build().vertexCriterion(__.in('knows').hasId(1)).create()

==>SubgraphStrategy

gremlin> g1 = GraphTraversalSource.build().with(s).create(graph)

==>graphtraversalsource[tinkergraph[vertices:6 edges:6], standard]

gremlin> g.V().filter(__.in('knows').hasId(1)).explain()

==>Traversal Explanation

===========================================================================================================================================

Original Traversal [GraphStep([],vertex), TraversalFilterStep([VertexStep(IN,[knows],vertex), HasStep([~id.eq(1)])])]

ConnectiveStrategy [D] [GraphStep([],vertex), TraversalFilterStep([VertexStep(IN,[knows],vertex), HasStep([~id.eq(1)])])]

IdentityRemovalStrategy [O] [GraphStep([],vertex), TraversalFilterStep([VertexStep(IN,[knows],vertex), HasStep([~id.eq(1)])])]

IncidentToAdjacentStrategy [O] [GraphStep([],vertex), TraversalFilterStep([VertexStep(IN,[knows],vertex), HasStep([~id.eq(1)])])]

AdjacentToIncidentStrategy [O] [GraphStep([],vertex), TraversalFilterStep([VertexStep(IN,[knows],vertex), HasStep([~id.eq(1)])])]

FilterRankingStrategy [O] [GraphStep([],vertex), TraversalFilterStep([VertexStep(IN,[knows],vertex), HasStep([~id.eq(1)])])]

MatchPredicateStrategy [O] [GraphStep([],vertex), TraversalFilterStep([VertexStep(IN,[knows],vertex), HasStep([~id.eq(1)])])]

RangeByIsCountStrategy [O] [GraphStep([],vertex), TraversalFilterStep([VertexStep(IN,[knows],vertex), HasStep([~id.eq(1)])])]

TinkerGraphStepStrategy [P] [TinkerGraphStep([],vertex), TraversalFilterStep([VertexStep(IN,[knows],vertex), HasStep([~id.eq(1)])])]

EngineDependentStrategy [F] [TinkerGraphStep([],vertex), TraversalFilterStep([VertexStep(IN,[knows],vertex), HasStep([~id.eq(1)])])]

ProfileStrategy [F] [TinkerGraphStep([],vertex), TraversalFilterStep([VertexStep(IN,[knows],vertex), HasStep([~id.eq(1)])])]

StandardVerificationStrategy [V] [TinkerGraphStep([],vertex), TraversalFilterStep([VertexStep(IN,[knows],vertex), HasStep([~id.eq(1)])])]

ComputerVerificationStrategy [V] [TinkerGraphStep([],vertex), TraversalFilterStep([VertexStep(IN,[knows],vertex), HasStep([~id.eq(1)])])]

Final Traversal [TinkerGraphStep([],vertex), TraversalFilterStep([VertexStep(IN,[knows],vertex), HasStep([~id.eq(1)])])]

gremlin> g.V().filter(__.in('knows').hasId(1))

==>v[2]

==>v[4]

gremlin> g1.V().explain()

==>Traversal Explanation

===========================================================================================================================================

Original Traversal [GraphStep([],vertex)]

ConnectiveStrategy [D] [GraphStep([],vertex)]

SubgraphStrategy [D] [GraphStep([],vertex), TraversalFilterStep([VertexStep(IN,[knows],vertex), HasStep([~id.eq(1)])])]