Merge remote-tracking branch 'upstream/3.2' into 3.3

neo4j · Jun 19, 2017 · 20becc9 · 20becc9
2 parents c846c66 + dca9be8
commit 20becc9
Show file tree

Hide file tree

Showing 2 changed files with 36 additions and 6 deletions.
diff --git a/...main/scala/org/neo4j/cypher/internal/compiler/v3_3/planner/logical/QueryGraphSolver.scala b/...main/scala/org/neo4j/cypher/internal/compiler/v3_3/planner/logical/QueryGraphSolver.scala
@@ -51,18 +51,17 @@ trait PatternExpressionSolving {
 
   def planPatternComprehension(planArguments: Set[IdName], expr: PatternComprehension)
                               (implicit context: LogicalPlanningContext): (LogicalPlan, PatternComprehension) = {
-    val dependencies = expr.dependencies.map(IdName.fromVariable)
-    val qgArguments = planArguments intersect dependencies
-    val qg = expr.asQueryGraph.withArgumentIds(qgArguments).addPredicates(expr.predicate.toIndexedSeq:_*)
+    val asQueryGraph = expr.asQueryGraph
+    val qgArguments = planArguments intersect asQueryGraph.coveredIds
+    val qg = asQueryGraph.withArgumentIds(qgArguments).addPredicates(expr.predicate.toIndexedSeq:_*)
     val plan: LogicalPlan = planQueryGraph(qg, Map.empty)
     (plan, expr)
   }
 
   private def planQueryGraph(qg: QueryGraph, namedMap: Map[PatternElement, Variable])
                             (implicit context: LogicalPlanningContext): LogicalPlan = {
-    val argLeafPlan = Some(context.logicalPlanProducer.planQueryArgumentRow(qg))
-    val namedNodes = namedMap.collect { case (elem: NodePattern, identifier) => identifier }
-    val namedRels = namedMap.collect { case (elem: RelationshipChain, identifier) => identifier }
+    val namedNodes = namedMap.collect { case (_: NodePattern, identifier) => identifier }
+    val namedRels = namedMap.collect { case (_: RelationshipChain, identifier) => identifier }
     val patternPlanningContext = context.forExpressionPlanning(namedNodes, namedRels)
     self.plan(qg)(patternPlanningContext)
   }

diff --git a/.../test/scala/org/neo4j/internal/cypher/acceptance/PatternComprehensionAcceptanceTest.scala b/.../test/scala/org/neo4j/internal/cypher/acceptance/PatternComprehensionAcceptanceTest.scala
@@ -61,6 +61,37 @@ class PatternComprehensionAcceptanceTest extends ExecutionEngineFunSuite with Ne
       List(Map("related" -> List(Map("tagged" -> Vector(Map("owner" -> Map("name" -> "Michael Hunger"))))))))
   }
 
+  test("bug found when binding to already existing variables") {
+
+    innerExecute(
+      """create
+        |(_0:`Decision`  {`id`:"d1"}),
+        |(_1:`FilterValue`  {`value`:500}),
+        |(_2:`FilterCharacteristic`  {`id`:"c1"}),
+        |(_3:`Decision`  {`id`:"d2"}),
+        |(_4:`FilterValue`  {`value`:1000}),
+        |(_5:`Decision`  {`id`:"d3"}),
+        |(_1)-[:`SET_ON`]->(_2),
+        |(_1)-[:`SET_FOR`]->(_0),
+        |(_4)-[:`SET_ON`]->(_2),
+        |(_4)-[:`SET_FOR`]->(_3)""".stripMargin)
+
+    val query =
+      """WITH {c1:[100,50000]} AS rangeFilters
+        |MATCH (childD:Decision)
+        | WHERE ALL(key IN keys(rangeFilters)
+        |   WHERE size([(childD)<-[:SET_FOR]-(filterValue)-[:SET_ON]->(filterCharacteristic) WHERE filterCharacteristic.id = key  AND (rangeFilters[key])[0] <= filterValue.value <= (rangeFilters[key])[1] | 1]
+        | ) > 0)
+        | RETURN childD.id""".stripMargin
+
+    val result = executeWithCostPlannerAndInterpretedRuntimeOnly(query)
+
+    result.toList should equal(
+      List(
+        Map("childD.id" -> "d1"),
+        Map("childD.id" -> "d2")))
+  }
+
   test("pattern comprehension nested in function call") {
     graph.getDependencyResolver.resolveDependency(classOf[Procedures]).registerFunction(classOf[TestFunction])