Renaming 'enterprise interpreted' to 'slotted' runtime

neo4j · Sep 1, 2017 · 78c9ee9 · 78c9ee9
1 parent ee4078b
commit 78c9ee9
Show file tree

Hide file tree

Showing 21 changed files with 38 additions and 38 deletions.
diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/CypherRuntime.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/CypherRuntime.scala
@@ -25,8 +25,8 @@ case object CypherRuntime extends CypherOptionCompanion[CypherRuntime] {
 
   case object default extends CypherRuntime("default")
   case object interpreted extends CypherRuntime("interpreted")
-  case object registerInterpreted extends CypherRuntime("enterprise-interpreted")
+  case object slotted extends CypherRuntime("slotted")
   case object compiled extends CypherRuntime("compiled")
 
-  val all: Set[CypherRuntime] = Set(interpreted, compiled, registerInterpreted)
+  val all: Set[CypherRuntime] = Set(interpreted, compiled, slotted)
 }
diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/CypherPreParser.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/CypherPreParser.scala
@@ -55,7 +55,7 @@ case object CypherPreParser extends Parser with Base {
   def RuntimeOption: Rule1[RuntimePreParserOption] = rule("runtime option")(
     option("runtime", "interpreted") ~ push(InterpretedRuntimeOption)
       | option("runtime", "compiled") ~ push(CompiledRuntimeOption)
-      | option("runtime", "enterprise-interpreted") ~ push(RegisterInterpretedRuntimeOption)
+      | option("runtime", "slotted") ~ push(SlottedRuntimeOption)
   )
 
   def StrategyOption: Rule1[UpdateStrategyOption] = rule("strategy option")(

diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/PreParserOption.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/PreParserOption.scala
@@ -34,7 +34,7 @@ case object GreedyPlannerOption extends PlannerPreParserOption("greedy")
 case object IDPPlannerOption extends PlannerPreParserOption("idp")
 case object DPPlannerOption extends PlannerPreParserOption("dp")
 case object InterpretedRuntimeOption extends RuntimePreParserOption("interpreted")
-case object RegisterInterpretedRuntimeOption extends RuntimePreParserOption("enterprise-interpreted")
+case object SlottedRuntimeOption extends RuntimePreParserOption("slotted")
 case object CompiledRuntimeOption extends RuntimePreParserOption("compiled")
 case object EagerOption extends UpdateStrategyOption("eager")
 case class DebugOption(key: String) extends PreParserOption

diff --git a/...ypher/src/main/scala/org/neo4j/cypher/internal/compatibility/v3_3/CostCompatibility.scala b/...ypher/src/main/scala/org/neo4j/cypher/internal/compatibility/v3_3/CostCompatibility.scala
@@ -62,7 +62,7 @@ case class CostCompatibility[CONTEXT <: CommunityRuntimeContext,
   override val maybeRuntimeName: Option[RuntimeName] = runtime match {
     case CypherRuntime.default => None
     case CypherRuntime.interpreted => Some(InterpretedRuntimeName)
-    case CypherRuntime.registerInterpreted => Some(EnterpriseInterpretedRuntimeName)
+    case CypherRuntime.`slotted` => Some(SlottedRuntimeName)
     case CypherRuntime.compiled => Some(CompiledRuntimeName)
   }
 

diff --git a/...her/src/main/scala/org/neo4j/cypher/internal/compatibility/v3_3/runtime/RuntimeName.scala b/...her/src/main/scala/org/neo4j/cypher/internal/compatibility/v3_3/runtime/RuntimeName.scala
@@ -28,8 +28,8 @@ case object InterpretedRuntimeName extends RuntimeName {
   override val name = "INTERPRETED"
 }
 
-case object EnterpriseInterpretedRuntimeName extends RuntimeName {
-  override val name = "ENTERPRISE-INTERPRETED"
+case object SlottedRuntimeName extends RuntimeName {
+  override val name = "SLOTTED"
 }
 
 case object CompiledRuntimeName extends RuntimeName {

diff --git a/community/kernel/src/main/java/org/neo4j/graphdb/factory/GraphDatabaseSettings.java b/community/kernel/src/main/java/org/neo4j/graphdb/factory/GraphDatabaseSettings.java
@@ -186,7 +186,7 @@ public class GraphDatabaseSettings implements LoadableConfig
     @Internal
     public static final Setting<String> cypher_runtime = setting(
             "unsupported.cypher.runtime",
-            options( "INTERPRETED", "COMPILED", "ENTERPRISE-INTERPRETED" ,  DEFAULT ), DEFAULT );
+            options( "INTERPRETED", "COMPILED", "SLOTTED" ,  DEFAULT ), DEFAULT );
 
     @Description( "Enable tracing of compilation in cypher." )
     @Internal

diff --git a/enterprise/cypher/acceptance-spec-suite/src/test/java/cypher/AcceptanceSpecSuiteTest.java b/enterprise/cypher/acceptance-spec-suite/src/test/java/cypher/AcceptanceSpecSuiteTest.java
@@ -118,17 +118,17 @@ public static class CostCompiledSourceCode
     @RunWith( Cucumber.class )
     @CucumberOptions(
             plugin = {
-                    DB_CONFIG + "cost-interpreted-enterprise.json",
-                    HTML_REPORT + SUITE_NAME + "/cost-interpreted-enterprise",
-                    JSON_REPORT + SUITE_NAME + "/cost-interpreted-enterprise",
-                    BLACKLIST_PLUGIN + "cost-interpreted-enterprise.txt"
+                    DB_CONFIG + "cost-slotted.json",
+                    HTML_REPORT + SUITE_NAME + "/cost-slotted",
+                    JSON_REPORT + SUITE_NAME + "/cost-slotted",
+                    BLACKLIST_PLUGIN + "cost-slotted.txt"
             },
             glue = { GLUE_PATH },
             features = { FEATURE_PATH + FEATURE_TO_RUN },
             tags = { "~@pending" },
             strict = true
     )
-    public static class CostEnterpriseInterpreted
+    public static class CostSlotted
     {
     }
 

diff --git a/...lacklists/cost-interpreted-enterprise.txt → ...est/resources/blacklists/cost-slotted.txt b/...lacklists/cost-interpreted-enterprise.txt → ...est/resources/blacklists/cost-slotted.txt
diff --git a/...ypher/acceptance-spec-suite/src/test/resources/db-config/cost-interpreted-enterprise.json b/...ypher/acceptance-spec-suite/src/test/resources/db-config/cost-interpreted-enterprise.json
diff --git a/enterprise/cypher/acceptance-spec-suite/src/test/resources/db-config/cost-slotted.json b/enterprise/cypher/acceptance-spec-suite/src/test/resources/db-config/cost-slotted.json
@@ -0,0 +1,4 @@
+{
+  "planner" : "cost",
+  "runtime" : "slotted"
+}
diff --git a/...spec-suite/src/test/scala/org/neo4j/internal/cypher/acceptance/CreateAcceptanceTest.scala b/...spec-suite/src/test/scala/org/neo4j/internal/cypher/acceptance/CreateAcceptanceTest.scala
@@ -76,8 +76,8 @@ class CreateAcceptanceTest extends ExecutionEngineFunSuite with QueryStatisticsT
     result.toList should equal(List(Map("type(r)" -> typ)))
   }
 
-  test("should create nodes with label and property with enterprise interpreted") {
-    //TODO: Remove this test once we can create relationships in enterprise interpreted
+  test("should create nodes with label and property with slotted runtime") {
+    //TODO: Remove this test once we can create relationships in slotted runtime
     val createdNumber = 1
 
     val query = "CREATE" + List.fill(createdNumber)("(:Bar{prop: 1})").mkString(", ")

diff --git a/...-suite/src/test/scala/org/neo4j/internal/cypher/acceptance/ExpressionAcceptanceTest.scala b/...-suite/src/test/scala/org/neo4j/internal/cypher/acceptance/ExpressionAcceptanceTest.scala
@@ -97,15 +97,15 @@ class ExpressionAcceptanceTest extends ExecutionEngineFunSuite with CypherCompar
   test("prepending item to a list should behave correctly in all runtimes") {
     val query = "CYPHER WITH {a:[1,2,3]} AS x RETURN 'a:' + x.a AS r"
 
-    val result = succeedWith(Configs.All - Configs.SlottedInterpreted, query)
+    val result = succeedWith(Configs.AllExceptSlotted, query)
 
     result.toList.head("r") should equal(List("a:", 1, 2, 3))
   }
 
   test("appending item to a list should behave correctly in all runtimes") {
     val query = "CYPHER WITH {a:[1,2,3]} AS x RETURN x.a + 'a:' AS r"
 
-    val result = succeedWith(Configs.All - Configs.SlottedInterpreted, query)
+    val result = succeedWith(Configs.AllExceptSlotted, query)
 
     result.toList.head("r") should equal(List(1, 2, 3, "a:"))
   }

diff --git a/...suite/src/test/scala/org/neo4j/internal/cypher/acceptance/UniqueIndexAcceptanceTest.scala b/...suite/src/test/scala/org/neo4j/internal/cypher/acceptance/UniqueIndexAcceptanceTest.scala
@@ -134,7 +134,7 @@ class UniqueIndexAcceptanceTest extends ExecutionEngineFunSuite with CypherCompa
       graph should haveConstraints(s"${constraintCreator.typeName}:Person(name)")
 
       //WHEN
-      val result = updateWithAndExpectPlansToBeSimilar(Configs.Interpreted - Configs.Cost2_3, "MERGE (n:Person {name: 'Andres'}) RETURN n.name")
+      val result = updateWithAndExpectPlansToBeSimilar(Configs.CommunityInterpreted - Configs.Cost2_3, "MERGE (n:Person {name: 'Andres'}) RETURN n.name")
 
       //THEN
       result shouldNot use("NodeIndexSeek")

diff --git a/...t/scala/org/neo4j/internal/cypher/acceptance/VarLengthExpandQueryPlanAcceptanceTest.scala b/...t/scala/org/neo4j/internal/cypher/acceptance/VarLengthExpandQueryPlanAcceptanceTest.scala
@@ -34,7 +34,7 @@ class VarLengthExpandQueryPlanAcceptanceTest extends ExecutionEngineFunSuite wit
         |
         |Planner COST
         |
-        |Runtime ENTERPRISE-INTERPRETED
+        |Runtime SLOTTED
         |
         |+-----------------------+----------------+------+---------+-----------------+-------------------+----------------------+------------------+----------------------------------+
         || Operator              | Estimated Rows | Rows | DB Hits | Page Cache Hits | Page Cache Misses | Page Cache Hit Ratio | Variables        | Other                            |
@@ -62,7 +62,7 @@ class VarLengthExpandQueryPlanAcceptanceTest extends ExecutionEngineFunSuite wit
         |
         |Planner COST
         |
-        |Runtime ENTERPRISE-INTERPRETED
+        |Runtime SLOTTED
         |
         |+-----------------------+----------------+------+---------+-----------------+-------------------+----------------------+------------------+--------------------------------+
         || Operator              | Estimated Rows | Rows | DB Hits | Page Cache Hits | Page Cache Misses | Page Cache Hit Ratio | Variables        | Other                          |

diff --git a/...rise/cypher/compatibility-spec-suite/src/test/java/cypher/CompatibilitySpecSuiteTest.java b/...rise/cypher/compatibility-spec-suite/src/test/java/cypher/CompatibilitySpecSuiteTest.java
@@ -118,10 +118,10 @@ public static class CostCompiledSourceCode
     @RunWith( Cucumber.class )
     @CucumberOptions(
             plugin = {
-                    DB_CONFIG + "cost-interpreted-enterprise.json",
-                    HTML_REPORT + SUITE_NAME + "/cost-interpreted-enterprise",
-                    JSON_REPORT + SUITE_NAME + "/cost-interpreted-enterprise",
-                    BLACKLIST_PLUGIN + "cost-interpreted-enterprise.txt",
+                    DB_CONFIG + "cost-slotted.json",
+                    HTML_REPORT + SUITE_NAME + "/cost-slotted",
+                    JSON_REPORT + SUITE_NAME + "/cost-slotted",
+                    BLACKLIST_PLUGIN + "cost-slotted.txt",
             },
             glue = { GLUE_PATH },
             features = { FEATURE_PATH + FEATURE_TO_RUN },

diff --git a/...lacklists/cost-interpreted-enterprise.txt → ...est/resources/blacklists/cost-slotted.txt b/...lacklists/cost-interpreted-enterprise.txt → ...est/resources/blacklists/cost-slotted.txt
diff --git a/...er/compatibility-spec-suite/src/test/resources/db-config/cost-interpreted-enterprise.json b/...er/compatibility-spec-suite/src/test/resources/db-config/cost-interpreted-enterprise.json
diff --git a/enterprise/cypher/compatibility-spec-suite/src/test/resources/db-config/cost-slotted.json b/enterprise/cypher/compatibility-spec-suite/src/test/resources/db-config/cost-slotted.json
@@ -0,0 +1,4 @@
+{
+  "planner" : "cost",
+  "runtime" : "slotted"
+}
diff --git a/...er/src/main/scala/org/neo4j/cypher/internal/BuildEnterpriseInterpretedExecutionPlan.scala b/...er/src/main/scala/org/neo4j/cypher/internal/BuildEnterpriseInterpretedExecutionPlan.scala
@@ -71,7 +71,7 @@ object BuildEnterpriseInterpretedExecutionPlan extends Phase[EnterpriseRuntimeCo
       val func = BuildInterpretedExecutionPlan.getExecutionPlanFunction(periodicCommitInfo, from.queryText, updating,
                                                                         resultBuilderFactory,
                                                                         context.notificationLogger,
-                                                                        EnterpriseInterpretedRuntimeName)
+                                                                        SlottedRuntimeName)
       val fingerprint = context.createFingerprintReference(fp)
       val periodicCommit = periodicCommitInfo.isDefined
       val indexes = logicalPlan.indexUsage
@@ -106,7 +106,7 @@ object BuildEnterpriseInterpretedExecutionPlan extends Phase[EnterpriseRuntimeCo
     override def isStale(lastTxId: () => Long, statistics: GraphStatistics): Boolean = fingerprint
       .isStale(lastTxId, statistics)
 
-    override def runtimeUsed: RuntimeName = EnterpriseInterpretedRuntimeName
+    override def runtimeUsed: RuntimeName = SlottedRuntimeName
 
     override def notifications(planContext: PlanContext): Seq[InternalNotification] =
       BuildInterpretedExecutionPlan.checkForNotifications(pipe, planContext, config)

diff --git a/...ise/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/EnterpriseRuntimeBuilder.scala b/...ise/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/EnterpriseRuntimeBuilder.scala
@@ -46,13 +46,13 @@ object EnterpriseRuntimeBuilder extends RuntimeBuilder[Transformer[EnterpriseRun
       case Some(InterpretedRuntimeName) =>
         BuildInterpretedExecutionPlan
 
-      case Some(EnterpriseInterpretedRuntimeName) if useErrorsOverWarnings =>
+      case Some(SlottedRuntimeName) if useErrorsOverWarnings =>
         BuildEnterpriseInterpretedExecutionPlan andThen
           If[EnterpriseRuntimeContext, LogicalPlanState, CompilationState](_.maybeExecutionPlan.isEmpty) {
             Do((_, _) => throw new InvalidArgumentException("The given query is not currently supported in the selected runtime"))
           }
 
-      case Some(EnterpriseInterpretedRuntimeName) =>
+      case Some(SlottedRuntimeName) =>
         BuildEnterpriseInterpretedExecutionPlan andThen
           If[EnterpriseRuntimeContext, LogicalPlanState, CompilationState](_.maybeExecutionPlan.isEmpty) {
             Do((_: EnterpriseRuntimeContext).notificationLogger.log(RuntimeUnsupportedNotification)) andThen

diff --git a/enterprise/cypher/cypher/src/test/scala/org/neo4j/cypher/RootPlanAcceptanceTest.scala b/enterprise/cypher/cypher/src/test/scala/org/neo4j/cypher/RootPlanAcceptanceTest.scala
@@ -19,7 +19,7 @@
  */
 package org.neo4j.cypher
 
-import org.neo4j.cypher.internal.compatibility.v3_3.runtime.{CompiledRuntimeName, EnterpriseInterpretedRuntimeName, InterpretedRuntimeName, RuntimeName}
+import org.neo4j.cypher.internal.compatibility.v3_3.runtime.{CompiledRuntimeName, SlottedRuntimeName, InterpretedRuntimeName, RuntimeName}
 import org.neo4j.cypher.internal.compiler.v3_3._
 import org.neo4j.cypher.internal.frontend.v3_3.PlannerName
 import org.neo4j.cypher.internal.javacompat.PlanDescription
@@ -39,7 +39,7 @@ class RootPlanAcceptanceTest extends ExecutionEngineFunSuite {
       .withCypherVersion(CypherVersion.v3_3)
       .withRuntime(CompiledRuntimeName)
       .shouldHaveCypherVersion(CypherVersion.v3_3)
-      .shouldHaveRuntime(EnterpriseInterpretedRuntimeName)
+      .shouldHaveRuntime(SlottedRuntimeName)
   }
 
   test("query that should go through the compiled runtime") {