Merge pull request #816 from s1ck/initquery_createparser

Replace Neo4jGraphFactory with CreateGraphFactory

Author: s1ck

okapi-neo4j-io-testing/build.gradle

@@ -5,5 +5,7 @@ dependencies {
     compile project(':okapi-neo4j-io')
     compile project(':okapi-testing')
 
-    compile group: 'org.neo4j.test', name: 'neo4j-harness', version: ver.neo4j.main
+    compile group: 'org.neo4j.test',   name: 'neo4j-harness',            version: ver.neo4j.main
+    compile group: 'org.neo4j.test',   name: 'neo4j-harness-enterprise', version: ver.neo4j.main
+    compile group: 'org.bouncycastle', name: 'bctls-jdk15on',            version: ver.bctls
 }

okapi-tck/src/main/scala/org/opencypher/okapi/tck/test/TCKFixture.scala

@@ -36,8 +36,7 @@ import org.opencypher.okapi.api.value.CypherValue.{CypherDate => OKAPICypherDate
 import org.opencypher.okapi.impl.exception.NotImplementedException
 import org.opencypher.okapi.ir.impl.typer.exception.TypingException
 import org.opencypher.okapi.tck.test.TCKFixture._
-import org.opencypher.okapi.tck.test.support.creation.neo4j.Neo4JGraphFactory
-import org.opencypher.okapi.testing.propertygraph.CypherTestGraphFactory
+import org.opencypher.okapi.testing.propertygraph.{CreateGraphFactory, CypherTestGraphFactory}
 import org.opencypher.tools.tck.api._
 import org.opencypher.tools.tck.constants.{TCKErrorDetails, TCKErrorPhases, TCKErrorTypes}
 import org.opencypher.tools.tck.values.{CypherValue => TCKCypherValue, _}
@@ -85,7 +84,7 @@ case class TCKGraph[C <: CypherSession](testGraphFactory: CypherTestGraphFactory
   override def execute(query: String, params: Map[String, TCKCypherValue], queryType: QueryType): (Graph, Result) = {
     queryType match {
       case InitQuery =>
-        val propertyGraph = testGraphFactory(Neo4JGraphFactory(query, params.mapValues(tckValueToCypherValue)))
+        val propertyGraph = testGraphFactory(CreateGraphFactory(query, params.mapValues(tckValueToCypherValue)))
         copy(graph = propertyGraph) -> CypherValueRecords.empty
       case SideEffectQuery =>
         // this one is tricky, not sure how can do it without Cypher

okapi-tck/src/main/scala/org/opencypher/okapi/tck/test/support/creation/neo4j/Neo4JGraphFactory.scala

@@ -5,8 +5,6 @@ dependencies {
     compile project(':okapi-api')
 
     compile group: 'org.opencypher',   name: 'front-end-9.0',            version: ver.cypher.frontend
-    compile group: 'org.neo4j.test',   name: 'neo4j-harness-enterprise', version: ver.neo4j.main
-    compile group: 'org.bouncycastle', name: 'bctls-jdk15on',            version: ver.bctls
     compile group: 'junit',            name: 'junit',                    version: ver.junit.main
     compile group: 'org.mockito',      name: 'mockito-all',              version: ver.mockito
     compile group: 'org.scalatest',    name: "scalatest".scala(),        version: ver.scalatest

okapi-testing/build.gradle

@@ -35,6 +35,7 @@ import cats.instances.list._
 import cats.syntax.all._
 import org.opencypher.okapi.api.value.CypherValue.{CypherEntity, CypherMap, CypherNode, CypherRelationship}
 import org.opencypher.okapi.impl.exception.{IllegalArgumentException, UnsupportedOperationException}
+import org.opencypher.okapi.impl.temporal.TemporalTypesHelper.parseDate
 import org.opencypher.okapi.impl.temporal.{Duration, TemporalTypesHelper}
 import org.opencypher.v9_0.ast._
 import org.opencypher.v9_0.ast.semantics.{SemanticErrorDef, SemanticState}
@@ -111,7 +112,10 @@ object CreateGraphFactory extends InMemoryGraphFactory {
       case head :: tail =>
         head match {
           case Create(pattern) =>
-            processPattern(pattern) >> processClauses(tail)
+            processPattern(pattern, merge = false) >> processClauses(tail)
+
+          case Merge(pattern, _, _) =>
+            processPattern(pattern, merge = true) >> processClauses(tail)
 
           case Unwind(expr, variable) =>
             for {
@@ -133,16 +137,16 @@ object CreateGraphFactory extends InMemoryGraphFactory {
     }
   }
 
-  def processPattern(pattern: Pattern): Result[Unit] = {
+  def processPattern(pattern: Pattern, merge: Boolean): Result[Unit] = {
     val parts = pattern.patternParts.map {
       case EveryPath(element) => element
       case other => throw UnsupportedOperationException(s"Processing pattern: ${other.getClass.getSimpleName}")
     }
 
-    Foldable[List].sequence_[Result, CypherEntity[Long]](parts.toList.map(pe => processPatternElement(pe)))
+    Foldable[List].sequence_[Result, CypherEntity[Long]](parts.toList.map(pe => processPatternElement(pe, merge)))
   }
 
-  def processPatternElement(patternElement: ASTNode): Result[CypherEntity[Long]] = {
+  def processPatternElement(patternElement: ASTNode, merge: Boolean): Result[CypherEntity[Long]] = {
     patternElement match {
       case NodePattern(Some(variable), labels, props, _) =>
         for {
@@ -160,7 +164,7 @@ object CreateGraphFactory extends InMemoryGraphFactory {
           }
           _ <- modify[ParsingContext] { context =>
             if (context.variableMapping.get(variable.name).isEmpty) {
-              context.updated(variable.name, node)
+              context.updated(variable.name, node, merge)
             } else {
               context
             }
@@ -169,12 +173,12 @@ object CreateGraphFactory extends InMemoryGraphFactory {
 
       case RelationshipChain(first, RelationshipPattern(Some(variable), relType, None, props, direction, _, _), third) =>
         for {
-          source <- processPatternElement(first)
+          source <- processPatternElement(first, merge)
           sourceId <- pure[ParsingContext, Long](source match {
             case n: CypherNode[Long] => n.id
             case r: CypherRelationship[Long] => r.endId
           })
-          target <- processPatternElement(third)
+          target <- processPatternElement(third, merge)
           properties <- props match {
             case Some(expr: MapExpression) => extractProperties(expr)
             case Some(other) => throw IllegalArgumentException("a RelationshipChain with MapExpression", other)
@@ -214,15 +218,41 @@ object CreateGraphFactory extends InMemoryGraphFactory {
 
         case ListLiteral(expressions) => expressions.toList.traverse[Result, Any](processExpr)
 
+        case Modulo(lhs, rhs) =>
+          for {
+            leftVal <- processExpr(lhs)
+            rightVal <- processExpr(rhs)
+            res <- pure[ParsingContext, Any](leftVal.asInstanceOf[Long] % rightVal.asInstanceOf[Long])
+          } yield res
+
+        case MapExpression(items) =>
+          for {
+            keys <- pure(items.map { case (k, _) => k.name })
+            valueTypes <- items.toList.traverse[Result, Any] { case (_, v) => processExpr(v) }
+            res <- pure[ParsingContext, Any](keys.zip(valueTypes).toMap)
+          } yield res
+
         case FunctionInvocation(_, FunctionName("date"), _, Seq(dateString: StringLiteral)) =>
-          pure[ParsingContext, Any](TemporalTypesHelper.parseDate(Right(dateString.value)))
+          pure[ParsingContext, Any](parseDate(Right(dateString.value)))
+
+        case FunctionInvocation(_, FunctionName("date"), _, Seq(map: MapExpression)) =>
+          for {
+            dateMap <- processExpr(map)
+            res <- pure[ParsingContext, Any](parseDate(Left(dateMap.asInstanceOf[Map[String, Long]].mapValues(_.toInt))))
+          } yield res
 
         case FunctionInvocation(_, FunctionName("localdatetime"), _, Seq(dateString: StringLiteral)) =>
           pure[ParsingContext, Any](TemporalTypesHelper.parseLocalDateTime(Right(dateString.value)))
 
         case FunctionInvocation(_, FunctionName("duration"), _, Seq(dateString: StringLiteral)) =>
           pure[ParsingContext, Any](Duration.parse(dateString.value))
 
+        case FunctionInvocation(_, FunctionName("duration"), _, Seq(map: MapExpression)) =>
+          for {
+            durationMap <- processExpr(map)
+            res <- pure[ParsingContext, Any](Duration(durationMap.asInstanceOf[Map[String, Long]]))
+          } yield res
+
         case Property(variable: Variable, propertyKey) =>
           inspect[ParsingContext, Any]({ context =>
             context.variableMapping(variable.name) match {
@@ -280,16 +310,22 @@ final case class ParsingContext(
 
   def popProtectedScope: ParsingContext = copy(protectedScopes = protectedScopes.tail)
 
-  def updated(k: String, v: Any): ParsingContext = v match {
-    case n: InMemoryTestNode =>
+  def updated(k: String, v: Any, merge: Boolean = false): ParsingContext = v match {
+    case n: InMemoryTestNode if !merge || !containsNode(n) =>
       copy(graph = graph.updated(n), variableMapping = variableMapping.updated(k, n))
 
-    case r: InMemoryTestRelationship =>
+    case r: InMemoryTestRelationship if !merge || !containsRel(r) =>
       copy(graph = graph.updated(r), variableMapping = variableMapping.updated(k, r))
 
     case _ =>
       copy(variableMapping = variableMapping.updated(k, v))
   }
+
+  private def containsNode(n: InMemoryTestNode): Boolean =
+    graph.nodes.exists(n.equalsSemantically)
+
+  private def containsRel(r: InMemoryTestRelationship): Boolean =
+    graph.relationships.exists(r.equalsSemantically)
 }
 
 object ParsingContext {

okapi-testing/src/main/scala/org/opencypher/okapi/testing/propertygraph/CreateQueryParser.scala

@@ -66,6 +66,10 @@ case class InMemoryTestNode(
   override def copy(id: Long = id, labels: Set[String] = labels, properties: CypherMap = properties): InMemoryTestNode.this.type = {
     InMemoryTestNode(id, labels, properties).asInstanceOf[this.type]
   }
+
+  def equalsSemantically(other: I): Boolean = {
+    this.labels == other.labels && this.properties == other.properties
+  }
 }
 
 case class InMemoryTestRelationship(
@@ -82,6 +86,10 @@ case class InMemoryTestRelationship(
     InMemoryTestRelationship(id, source, target, relType, properties).asInstanceOf[this.type]
   }
 
+  def equalsSemantically(other: I): Boolean = {
+    this.relType == other.relType && this.properties == other.properties
+  }
+
 }
 
 trait InMemoryGraphFactory {

okapi-testing/src/main/scala/org/opencypher/okapi/testing/propertygraph/InMemoryTestGraph.scala

@@ -83,6 +83,7 @@ Feature "TemporalCreateAcceptance": Scenario "Should construct date time with de
 Feature "TemporalArithmeticAcceptance": Scenario "Should add or subtract duration to or from local time #1"
 Feature "TemporalArithmeticAcceptance": Scenario "Should add or subtract duration to or from local time #2"
 Feature "TemporalArithmeticAcceptance": Scenario "Should add or subtract duration to or from local time #3"
+Feature "TemporalArithmeticAcceptance": Scenario "Should add or subtract duration to or from date #3"
 Feature "TemporalParseAcceptance": Scenario "Should parse date time with named time zone from string #1"
 Feature "TemporalParseAcceptance": Scenario "Should parse date time with named time zone from string #2"
 Feature "TemporalParseAcceptance": Scenario "Should parse date time with named time zone from string #3"

spark-cypher-tck/src/test/resources/temporal_blacklist

@@ -128,7 +128,7 @@ class TckSparkCypherTest extends CAPSTestSuite {
   }
 
   ignore("run custom scenario") {
-    val file = new File(getClass.getResource("CustomTest.feature").toURI)
+    val file = new File(getClass.getResource("/CustomTest.feature").toURI)
 
     CypherTCK
       .parseFilesystemFeature(file)