Var length path refactoring

testware/integration-tests/src/test/java/org/opencypher/gremlin/queries/VariableLengthPathTest.java

@@ -194,8 +194,18 @@ public void varPathPredicate() throws Exception {
 
         assertThat(results)
             .extracting("n.name", "m.name")
-            .containsExactlyInAnyOrder( tuple("marko", "josh"),
+            .containsExactlyInAnyOrder(tuple("marko", "josh"),
                 tuple("marko", "ripple"),
                 tuple("josh", "ripple"));
     }
+
+    @Test
+    public void multipleVarLengthRelationships() throws Exception {
+        List<Map<String, Object>> results = submitAndGet(
+            "MATCH p = (a {name: 'marko'})-[:knows*0..1]->(b)-[:created*0..1]->(c)\n" +
+                "RETURN p");
+
+        assertThat(results)
+            .hasSize(6);
+    }
 }

translation/src/main/java/org/opencypher/gremlin/translation/GremlinSteps.java

@@ -183,6 +183,8 @@ GremlinSteps<T, P> choose(GremlinSteps<T, P> traversalPredicate,
 
     GremlinSteps<T, P> sideEffect(GremlinSteps<T, P> sideEffectTraversal);
 
+    GremlinSteps<T, P> simplePath();
+
     GremlinSteps<T, P> skip(long skip);
 
     GremlinSteps<T, P> sum();

translation/src/main/java/org/opencypher/gremlin/translation/Tokens.java

@@ -23,6 +23,7 @@ private Tokens() {
     public static final String NULL = "  cypher.null";
     public static final String UNUSED = "  cypher.unused";
     public static final String PATH_EDGE = "  cypher.path.edge.";
+    public static final String PATH_START = "  cypher.path.start.";
 
     public static final String PROJECTION_RELATIONSHIP = "  cypher.relationship";
     public static final String PROJECTION_ELEMENT = "  cypher.element";

translation/src/main/java/org/opencypher/gremlin/translation/bytecode/BytecodeGremlinSteps.java

@@ -442,6 +442,12 @@ public GremlinSteps<Bytecode, P> sideEffect(GremlinSteps<Bytecode, P> sideEffect
         return this;
     }
 
+    @Override
+    public GremlinSteps<Bytecode, P> simplePath() {
+        bytecode.addStep(Symbols.simplePath);
+        return this;
+    }
+
     @Override
     public GremlinSteps<Bytecode, P> skip(long skip) {
         bytecode.addStep(Symbols.skip, skip);

translation/src/main/java/org/opencypher/gremlin/translation/groovy/GroovyGremlinSteps.java

@@ -450,6 +450,12 @@ public GremlinSteps<String, GroovyPredicate> sideEffect(GremlinSteps<String, Gro
         return this;
     }
 
+    @Override
+    public GremlinSteps<String, GroovyPredicate> simplePath() {
+        g.append(chain("simplePath"));
+        return this;
+    }
+
     @Override
     public GremlinSteps<String, GroovyPredicate> skip(long skip) {
         g.append(chain("skip", skip));

translation/src/main/java/org/opencypher/gremlin/translation/traversal/TraversalGremlinSteps.java

@@ -479,6 +479,12 @@ public GremlinSteps<GraphTraversal, P> sideEffect(GremlinSteps<GraphTraversal, P
         return this;
     }
 
+    @Override
+    public GremlinSteps<GraphTraversal, P> simplePath() {
+        g.simplePath();
+        return this;
+    }
+
     @Override
     public GremlinSteps<GraphTraversal, P> skip(long skip) {
         g.skip(skip);

translation/src/main/scala/org/opencypher/gremlin/translation/context/StatementContext.scala

@@ -15,7 +15,6 @@
  */
 package org.opencypher.gremlin.translation.context
 
-import org.opencypher.gremlin.translation.GremlinSteps
 import org.opencypher.gremlin.translation.translator.Translator
 import org.opencypher.v9_0.expressions.Expression
 import org.opencypher.v9_0.util.symbols.CypherType
@@ -65,17 +64,6 @@ sealed class StatementContext[T, P](
     parameters.contains(name)
   }
 
-  private var midTraversals = 0
-
-  def midTraversal(g: GremlinSteps[T, P]): Unit = {
-    midTraversals += 1
-    g.V()
-  }
-
-  def lowerBound(edges: Int): Int = if (edges == 0) 0 else edges * 2 + 1
-
-  def upperBound(edges: Int): Int = lowerBound(edges) + midTraversals
-
   def unsupported(description: String, node: Any): Nothing = {
     throw new UnsupportedOperationException(s"Unsupported $description: $node")
   }

translation/src/main/scala/org/opencypher/gremlin/translation/ir/TranslationWriter.scala

@@ -196,6 +196,8 @@ sealed private[ir] class TranslationGenerator[T, P](translator: Translator[T, P]
           g.select(column)
         case SideEffect(sideEffectTraversal) =>
           g.sideEffect(generateSteps(sideEffectTraversal))
+        case SimplePath =>
+          g.simplePath()
         case Skip(skip) =>
           g.skip(skip)
         case Sum =>

translation/src/main/scala/org/opencypher/gremlin/translation/ir/builder/IRGremlinSteps.scala

@@ -376,6 +376,11 @@ class IRGremlinSteps extends GremlinSteps[Seq[GremlinStep], GremlinPredicate] {
     this
   }
 
+  override def simplePath(): GremlinSteps[Seq[GremlinStep], GremlinPredicate] = {
+    buf += SimplePath
+    this
+  }
+
   override def skip(skip: Long): GremlinSteps[Seq[GremlinStep], GremlinPredicate] = {
     buf += Skip(skip)
     this

translation/src/main/scala/org/opencypher/gremlin/translation/ir/model/GremlinStep.scala

@@ -273,6 +273,8 @@ case class SideEffect(sideEffectTraversal: Seq[GremlinStep]) extends GremlinStep
   }
 }
 
+case object SimplePath extends GremlinStep
+
 case class Skip(skip: Long) extends GremlinStep
 
 case object Sum extends GremlinStep

translation/src/main/scala/org/opencypher/gremlin/translation/walker/CallWalker.scala

@@ -16,7 +16,6 @@
 package org.opencypher.gremlin.translation.walker
 
 import org.opencypher.gremlin.translation.GremlinSteps
-import org.opencypher.gremlin.translation.Tokens.START
 import org.opencypher.gremlin.translation.context.StatementContext
 import org.opencypher.gremlin.translation.walker.NodeUtils._
 import org.opencypher.v9_0.ast._
@@ -39,10 +38,7 @@ object CallWalker {
 private class CallWalker[T, P](context: StatementContext[T, P], g: GremlinSteps[T, P]) {
 
   def walk(node: UnresolvedCall): Unit = {
-    if (context.isFirstStatement) {
-      context.markFirstStatement()
-      g.inject(START)
-    }
+    ensureFirstStatement(g, context)
 
     node match {
       case UnresolvedCall(Namespace(namespaceParts), ProcedureName(name), argumentOption, results) =>
@@ -78,10 +74,7 @@ private class CallWalker[T, P](context: StatementContext[T, P], g: GremlinSteps[
   }
 
   def walkStandalone(node: UnresolvedCall): Unit = {
-    if (context.isFirstStatement) {
-      context.markFirstStatement()
-      g.inject(START)
-    }
+    ensureFirstStatement(g, context)
 
     val procedures = context.dsl.procedures()
     node match {

translation/src/main/scala/org/opencypher/gremlin/translation/walker/MatchWalker.scala

@@ -15,7 +15,7 @@
  */
 package org.opencypher.gremlin.translation.walker
 
-import org.opencypher.gremlin.translation.Tokens.{NULL, START}
+import org.opencypher.gremlin.translation.Tokens.NULL
 import org.opencypher.gremlin.translation._
 import org.opencypher.gremlin.translation.context.StatementContext
 import org.opencypher.gremlin.translation.walker.NodeUtils._
@@ -49,10 +49,7 @@ private class MatchWalker[T, P](context: StatementContext[T, P], g: GremlinSteps
   }
 
   private def walkOptionalMatch(patternParts: Seq[PatternPart], whereOption: Option[Where]): Unit = {
-    if (context.isFirstStatement) {
-      context.markFirstStatement()
-      g.inject(START)
-    }
+    ensureFirstStatement(g, context)
 
     val subG = g.start()
     val contextSubG = context.copy()
@@ -87,12 +84,8 @@ private class MatchWalker[T, P](context: StatementContext[T, P], g: GremlinSteps
   }
 
   private def foldPatternElement(maybeName: Option[String], patternElement: PatternElement): Unit = {
-    if (!context.isFirstStatement) {
-      context.midTraversal(g)
-    } else {
-      g.V()
-      context.markFirstStatement()
-    }
+    context.markFirstStatement()
+    g.V()
 
     PatternWalker.walkMatch(context, g, patternElement, maybeName)
   }

translation/src/main/scala/org/opencypher/gremlin/translation/walker/MergeWalker.scala

@@ -16,9 +16,8 @@
 package org.opencypher.gremlin.translation.walker
 
 import org.opencypher.gremlin.translation.GremlinSteps
-import org.opencypher.gremlin.translation.Tokens.START
 import org.opencypher.gremlin.translation.context.StatementContext
-import org.opencypher.gremlin.translation.walker.NodeUtils.{asUniqueName, getPathTraversalAliases}
+import org.opencypher.gremlin.translation.walker.NodeUtils.{getPathTraversalAliases, _}
 import org.opencypher.v9_0.ast._
 import org.opencypher.v9_0.expressions._
 import org.opencypher.v9_0.util.InputPosition.NONE
@@ -45,11 +44,7 @@ private class MergeWalker[T, P](context: StatementContext[T, P], g: GremlinSteps
       g: GremlinSteps[T, P],
       patternParts: Seq[PatternPart],
       actions: Seq[MergeAction]): GremlinSteps[T, P] = {
-
-    if (context.isFirstStatement) {
-      g.inject(START)
-      context.markFirstStatement()
-    }
+    ensureFirstStatement(g, context)
 
     val matchSubG = g.start()
     MatchWalker.walkPatternParts(context.copy(), matchSubG, patternParts, None)

translation/src/main/scala/org/opencypher/gremlin/translation/walker/NodeUtils.scala

@@ -139,4 +139,11 @@ object NodeUtils {
     expressions.map(ExpressionWalker.walkLocal(context, g, _)).foreach(traversal.by)
     traversal.select(Column.values)
   }
+
+  def ensureFirstStatement[T, P](traversal: GremlinSteps[T, P], context: StatementContext[T, P]): Unit = {
+    if (context.isFirstStatement) {
+      traversal.inject(Tokens.START)
+      context.markFirstStatement()
+    }
+  }
 }

translation/src/main/scala/org/opencypher/gremlin/translation/walker/PatternWalker.scala

@@ -16,10 +16,10 @@
 package org.opencypher.gremlin.translation.walker
 
 import org.apache.tinkerpop.gremlin.process.traversal.Scope
-import org.opencypher.gremlin.translation.GremlinSteps
 import org.opencypher.gremlin.translation.Tokens.PATH_EDGE
 import org.opencypher.gremlin.translation.context.StatementContext
 import org.opencypher.gremlin.translation.walker.NodeUtils._
+import org.opencypher.gremlin.translation.{GremlinSteps, Tokens}
 import org.opencypher.v9_0.expressions.SemanticDirection._
 import org.opencypher.v9_0.expressions.{UnsignedDecimalIntegerLiteral => UDIL, _}
 import org.opencypher.v9_0.util.InputPosition.NONE
@@ -79,7 +79,7 @@ class PatternWalker[T, P](context: StatementContext[T, P], g: GremlinSteps[T, P]
     properties.map(hasProperties(variable, _)).foreach(g.map)
   }
 
-  val traversalStepsHardLimit: Int = context.lowerBound(10)
+  val traversalStepsHardLimit: Int = gremlinPathLength(10)
 
   private def walkRelationship(pathName: Option[String], relationship: RelationshipPattern): Unit = {
     val RelationshipPattern(variableOption, types, length, properties, direction, _) = relationship
@@ -103,7 +103,10 @@ class PatternWalker[T, P](context: StatementContext[T, P], g: GremlinSteps[T, P]
       case OUTGOING => directionT.inV()
     }
 
-    def pathLengthT = g.start().path().count(Scope.local)
+    val pathStart = Tokens.PATH_START + pathName.getOrElse(context.generateName().trim())
+
+    g.as(pathStart)
+    def pathLengthT = g.start().path().from(pathStart).count(Scope.local)
 
     val p = context.dsl.predicates()
     length match {
@@ -120,30 +123,38 @@ class PatternWalker[T, P](context: StatementContext[T, P], g: GremlinSteps[T, P]
         range match {
           case Range(Some(UDIL(lower)), None) =>
             // -[*m..]->
-            val lowerBound = context.lowerBound(lower.toInt)
+            val lowerBound = gremlinPathLength(lower.toInt)
             g.emit()
               .repeat(directionT)
               .until(pathLengthT.is(p.gte(traversalStepsHardLimit)))
               .where(pathLengthT.is(p.gte(lowerBound)))
+              .simplePath()
+              .from(pathStart)
           case Range(None, Some(UDIL(upper))) =>
             // -[*..n]->
-            val upperBound = context.upperBound(upper.toInt)
+            val upperBound = gremlinPathLength(upper.toInt)
             g.repeat(directionT)
               .emit()
               .until(pathLengthT.is(p.gte(upperBound)))
               .where(pathLengthT.is(p.lte(upperBound)))
+              .simplePath()
+              .from(pathStart)
           case Range(Some(UDIL(lower)), Some(UDIL(upper))) if lower == upper =>
             // -[*n]->
             g.times(lower.toInt)
               .repeat(directionT)
+              .simplePath()
+              .from(pathStart)
           case Range(Some(UDIL(lower)), Some(UDIL(upper))) =>
             // -[*m..n]->
-            val lowerBound = context.lowerBound(lower.toInt)
-            val upperBound = context.upperBound(upper.toInt)
+            val lowerBound = gremlinPathLength(lower.toInt)
+            val upperBound = gremlinPathLength(upper.toInt)
             g.emit()
               .repeat(directionT)
               .until(pathLengthT.is(p.gte(upperBound)))
               .where(pathLengthT.is(p.between(lowerBound, upperBound + 1)))
+              .simplePath()
+              .from(pathStart)
         }
       case _ =>
         context.unsupported("path pattern length", length)
@@ -175,4 +186,6 @@ class PatternWalker[T, P](context: StatementContext[T, P], g: GremlinSteps[T, P]
         context.unsupported("property map", propertyMap)
     }
   }
+
+  private def gremlinPathLength(edges: Int): Int = if (edges == 0) 0 else edges * 2 + 1
 }

translation/src/main/scala/org/opencypher/gremlin/translation/walker/ProjectionWalker.scala

@@ -70,10 +70,7 @@ private class ProjectionWalker[T, P](context: StatementContext[T, P], g: Gremlin
       skip: Option[Skip],
       limit: Option[Limit],
       finalize: Boolean): Unit = {
-    if (context.isFirstStatement) {
-      context.markFirstStatement()
-      g.inject(START)
-    }
+    ensureFirstStatement(g, context)
 
     val subTraversals = returnSubTraversals(items, finalize)
 

translation/src/main/scala/org/opencypher/gremlin/translation/walker/StatementWalker.scala

@@ -15,9 +15,9 @@
  */
 package org.opencypher.gremlin.translation.walker
 
-import org.opencypher.gremlin.translation.Tokens.START
 import org.opencypher.gremlin.translation._
 import org.opencypher.gremlin.translation.context.StatementContext
+import org.opencypher.gremlin.translation.walker.NodeUtils._
 import org.opencypher.v9_0.ast._
 
 import scala.collection.mutable
@@ -47,10 +47,7 @@ class StatementWalker[T, P](context: StatementContext[T, P], g: GremlinSteps[T,
   }
 
   def walkUnion(node: Union): Unit = {
-    if (context.isFirstStatement) {
-      context.markFirstStatement()
-      g.inject(START)
-    }
+    ensureFirstStatement(g, context)
 
     val subGs = mutable.ArrayBuffer.empty[GremlinSteps[T, P]]
     for (query <- flattenUnion(Vector(), node)) {

translation/src/main/scala/org/opencypher/gremlin/translation/walker/UnwindWalker.scala

@@ -18,8 +18,8 @@ package org.opencypher.gremlin.translation.walker
 import java.util.Collections
 
 import org.opencypher.gremlin.translation.GremlinSteps
-import org.opencypher.gremlin.translation.Tokens._
 import org.opencypher.gremlin.translation.context.StatementContext
+import org.opencypher.gremlin.translation.walker.NodeUtils._
 import org.opencypher.v9_0.ast._
 import org.opencypher.v9_0.expressions._
 
@@ -42,10 +42,7 @@ private class UnwindWalker[T, P](context: StatementContext[T, P], g: GremlinStep
       case Null() =>
         g.inject(Collections.emptyList).unfold().as(varName)
       case _: Expression =>
-        if (context.isFirstStatement) {
-          context.markFirstStatement()
-          g.inject(START)
-        }
+        ensureFirstStatement(g, context)
         ExpressionWalker.walk(context, g, expression)
         g.unfold().as(varName)
     }

translation/src/test/java/org/opencypher/gremlin/translation/ir/rewrite/InlineMapTraversalTest.java

@@ -55,7 +55,7 @@ public void adjacentMap() {
         ))
             .withFlavor(TranslatorFlavor.empty())
             .rewritingWith(InlineMapTraversal$.MODULE$)
-            .removes(__().select("n").map(__()).map(__().outE().inV()))
-            .adds(__().select("n").outE().inV());
+            .removes(__().select("n").map(__()).as("  cypher.path.start.GENERATED1").map(__().outE().inV()))
+            .adds(__().select("n").as("  cypher.path.start.GENERATED1").outE().inV());
     }
 }