diff --git a/community/cypher/acceptance/src/test/scala/org/neo4j/internal/cypher/acceptance/LoadCsvAcceptanceTest.scala b/community/cypher/acceptance/src/test/scala/org/neo4j/internal/cypher/acceptance/LoadCsvAcceptanceTest.scala index 549897c0f62a7..b825ec5496cbc 100644 --- a/community/cypher/acceptance/src/test/scala/org/neo4j/internal/cypher/acceptance/LoadCsvAcceptanceTest.scala +++ b/community/cypher/acceptance/src/test/scala/org/neo4j/internal/cypher/acceptance/LoadCsvAcceptanceTest.scala @@ -25,9 +25,9 @@ import org.neo4j.cypher._ import org.neo4j.cypher.internal.ExecutionEngine import org.neo4j.cypher.internal.compiler.v3_0.test_helpers.CreateTempFileTestSupport import org.neo4j.cypher.internal.frontend.v3_0.helpers.StringHelper.RichString +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService import org.neo4j.graphdb.factory.GraphDatabaseSettings import org.neo4j.graphdb.security.URLAccessRule -import org.neo4j.kernel.GraphDatabaseAPI import org.neo4j.test.TestGraphDatabaseFactory import org.scalatest.BeforeAndAfterAll import org.neo4j.graphdb.config.Configuration @@ -354,10 +354,10 @@ class LoadCsvAcceptanceTest } test("should fail for file urls if local file access disallowed") { - val db = new TestGraphDatabaseFactory() + val db = new GraphDatabaseCypherService(new TestGraphDatabaseFactory() .newImpermanentDatabaseBuilder() .setConfig(GraphDatabaseSettings.allow_file_urls, "false") - .newGraphDatabase() + .newGraphDatabase()) intercept[LoadExternalResourceException] { new ExecutionEngine(db).execute(s"LOAD CSV FROM 'file:///tmp/blah.csv' AS line CREATE (a {name:line[0]})") @@ -371,10 +371,10 @@ class LoadCsvAcceptanceTest writer.println("something") ) - val db = new TestGraphDatabaseFactory() + val db = new GraphDatabaseCypherService(new TestGraphDatabaseFactory() .newImpermanentDatabaseBuilder() .setConfig(GraphDatabaseSettings.load_csv_file_url_root, dir.toString) - .newGraphDatabase() + .newGraphDatabase()) val result = new ExecutionEngine(db).execute(s"LOAD CSV FROM 'file:///tmp/blah.csv' AS line RETURN line[0] AS field") result.toList should equal(List(Map("field" -> "something"))) @@ -396,12 +396,12 @@ class LoadCsvAcceptanceTest } }) - val db = new TestGraphDatabaseFactory() + val db = new GraphDatabaseCypherService(new TestGraphDatabaseFactory() .addURLAccessRule( "testproto", new URLAccessRule { override def validate(config: Configuration, url: URL): URL = url }) .newImpermanentDatabaseBuilder() - .newGraphDatabase() + .newGraphDatabase()) val result = new ExecutionEngine(db).execute(s"LOAD CSV FROM 'testproto://foo.bar' AS line RETURN line[0] AS field") result.toList should equal(List(Map("field" -> "something"))) diff --git a/community/cypher/acceptance/src/test/scala/org/neo4j/internal/cypher/acceptance/MatchLongPatternAcceptanceTest.scala b/community/cypher/acceptance/src/test/scala/org/neo4j/internal/cypher/acceptance/MatchLongPatternAcceptanceTest.scala index 9ce713cd45c25..a6387d23910e3 100644 --- a/community/cypher/acceptance/src/test/scala/org/neo4j/internal/cypher/acceptance/MatchLongPatternAcceptanceTest.scala +++ b/community/cypher/acceptance/src/test/scala/org/neo4j/internal/cypher/acceptance/MatchLongPatternAcceptanceTest.scala @@ -24,11 +24,11 @@ import java.util import org.neo4j.cypher._ import org.neo4j.cypher.internal.{PlanDescription, ExecutionEngine} import org.neo4j.cypher.internal.compiler.v3_0.planner.logical.idp.IDPSolverMonitor -import org.neo4j.graphdb.GraphDatabaseService +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService import org.neo4j.graphdb.config.Setting import org.neo4j.graphdb.factory.GraphDatabaseSettings import org.neo4j.graphdb.factory.GraphDatabaseSettings.{cypher_idp_solver_duration_threshold, cypher_idp_solver_table_threshold} -import org.neo4j.kernel.{GraphDatabaseAPI, monitoring} +import org.neo4j.kernel.{GraphDatabaseQueryService, monitoring} import org.neo4j.test.ImpermanentGraphDatabase import scala.collection.JavaConverters._ @@ -191,7 +191,7 @@ class MatchLongPatternAcceptanceTest extends ExecutionEngineFunSuite with QueryS val config = databaseConfig() + (configKey -> configValue.toString) runWithConfig(config.toSeq: _*) { (engine, db) => - graph = db.asInstanceOf[GraphDatabaseAPI] + graph = db makeLargeMatrixDataset(100) val monitor = TestIDPSolverMonitor() val monitors: monitoring.Monitors = graph.getDependencyResolver.resolveDependency(classOf[org.neo4j.kernel.monitoring.Monitors]) @@ -232,12 +232,12 @@ class MatchLongPatternAcceptanceTest extends ExecutionEngineFunSuite with QueryS } } - private def runWithConfig(m: (Setting[_], String)*)(run: (ExecutionEngine, GraphDatabaseService) => Unit) = { + private def runWithConfig(m: (Setting[_], String)*)(run: (ExecutionEngine, GraphDatabaseQueryService) => Unit) = { val config: util.Map[String, String] = m.map { case (setting, value) => setting.name() -> value }.toMap.asJava - val graph = new ImpermanentGraphDatabase(config) + val graph = new GraphDatabaseCypherService(new ImpermanentGraphDatabase(config)) try { val engine = new ExecutionEngine(graph) run(engine, graph) diff --git a/community/cypher/cypher-compiler-3.0/src/main/scala/org/neo4j/cypher/internal/compiler/v3_0/CypherCompiler.scala b/community/cypher/cypher-compiler-3.0/src/main/scala/org/neo4j/cypher/internal/compiler/v3_0/CypherCompiler.scala index 7b933a6c68c76..5e0d70411f72f 100644 --- a/community/cypher/cypher-compiler-3.0/src/main/scala/org/neo4j/cypher/internal/compiler/v3_0/CypherCompiler.scala +++ b/community/cypher/cypher-compiler-3.0/src/main/scala/org/neo4j/cypher/internal/compiler/v3_0/CypherCompiler.scala @@ -34,8 +34,8 @@ import org.neo4j.cypher.internal.frontend.v3_0.ast.Statement import org.neo4j.cypher.internal.frontend.v3_0.notification.InternalNotification import org.neo4j.cypher.internal.frontend.v3_0.parser.CypherParser import org.neo4j.cypher.internal.frontend.v3_0.{InputPosition, SemanticTable, inSequence} -import org.neo4j.graphdb.GraphDatabaseService import org.neo4j.helpers.Clock +import org.neo4j.kernel.GraphDatabaseQueryService trait AstRewritingMonitor { def abortedRewriting(obj: AnyRef) @@ -71,7 +71,7 @@ case class CypherCompilerConfiguration(queryCacheSize: Int, object CypherCompilerFactory { val monitorTag = "cypher3.0" - def costBasedCompiler(graph: GraphDatabaseService, config: CypherCompilerConfiguration, clock: Clock, structure: CodeStructure[GeneratedQuery], + def costBasedCompiler(graph: GraphDatabaseQueryService, config: CypherCompilerConfiguration, clock: Clock, structure: CodeStructure[GeneratedQuery], monitors: Monitors, logger: InfoLogger, rewriterSequencer: (String) => RewriterStepSequencer, plannerName: Option[CostBasedPlannerName], @@ -117,7 +117,7 @@ object CypherCompilerFactory { new CypherCompiler(parser, checker, execPlanBuilder, rewriter, cache, planCacheFactory, cacheMonitor, monitors) } - def ruleBasedCompiler(graph: GraphDatabaseService, + def ruleBasedCompiler(graph: GraphDatabaseQueryService, config: CypherCompilerConfiguration, clock: Clock, monitors: Monitors, rewriterSequencer: (String) => RewriterStepSequencer): CypherCompiler = { val parser = new CypherParser diff --git a/community/cypher/cypher-compiler-3.0/src/main/scala/org/neo4j/cypher/internal/compiler/v3_0/executionplan/ExecutionPlanBuilder.scala b/community/cypher/cypher-compiler-3.0/src/main/scala/org/neo4j/cypher/internal/compiler/v3_0/executionplan/ExecutionPlanBuilder.scala index c6a383e03099a..4d69e7a7c12a0 100644 --- a/community/cypher/cypher-compiler-3.0/src/main/scala/org/neo4j/cypher/internal/compiler/v3_0/executionplan/ExecutionPlanBuilder.scala +++ b/community/cypher/cypher-compiler-3.0/src/main/scala/org/neo4j/cypher/internal/compiler/v3_0/executionplan/ExecutionPlanBuilder.scala @@ -36,9 +36,8 @@ import org.neo4j.cypher.internal.compiler.v3_0.{ExecutionMode, ProfileMode, _} import org.neo4j.cypher.internal.frontend.v3_0.PeriodicCommitInOpenTransactionException import org.neo4j.cypher.internal.frontend.v3_0.ast.Statement import org.neo4j.cypher.internal.frontend.v3_0.notification.InternalNotification -import org.neo4j.graphdb.GraphDatabaseService import org.neo4j.helpers.Clock -import org.neo4j.kernel.api.{Statement => KernelStatement} +import org.neo4j.kernel.GraphDatabaseQueryService trait RunnablePlan { @@ -95,7 +94,7 @@ trait ExecutablePlanBuilder { createFingerprintReference: (Option[PlanFingerprint]) => PlanFingerprintReference): ExecutionPlan } -class ExecutionPlanBuilder(graph: GraphDatabaseService, +class ExecutionPlanBuilder(graph: GraphDatabaseQueryService, clock: Clock, executionPlanBuilder: ExecutablePlanBuilder, createFingerprintReference: Option[PlanFingerprint] => PlanFingerprintReference) diff --git a/community/cypher/cypher-compiler-3.0/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/pipes/LazyIterator.scala b/community/cypher/cypher-compiler-3.0/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/pipes/LazyIterator.scala index 91439419476cb..3e36db1661ce3 100644 --- a/community/cypher/cypher-compiler-3.0/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/pipes/LazyIterator.scala +++ b/community/cypher/cypher-compiler-3.0/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/pipes/LazyIterator.scala @@ -19,12 +19,12 @@ */ package org.neo4j.cypher.internal.compiler.v3_0.pipes -import org.neo4j.graphdb.GraphDatabaseService +import org.neo4j.kernel.GraphDatabaseQueryService import org.scalatest.Assertions -class LazyIterator[T](count: Int, f: (Int, GraphDatabaseService) => T) extends Iterator[T]() with Assertions { - var db: Option[GraphDatabaseService] = None +class LazyIterator[T](count: Int, f: (Int, GraphDatabaseQueryService) => T) extends Iterator[T]() with Assertions { + var db: Option[GraphDatabaseQueryService] = None def this(count: Int, f: Int => T) = { this(count, (count: Int, _) => f(count)) diff --git a/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/CypherEngineProvider.java b/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/CypherEngineProvider.java index 8bdcfe2e6b37c..f2f6228fde7d9 100644 --- a/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/CypherEngineProvider.java +++ b/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/CypherEngineProvider.java @@ -19,6 +19,7 @@ */ package org.neo4j.cypher.internal.javacompat; +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService; import org.neo4j.helpers.Service; import org.neo4j.kernel.GraphDatabaseAPI; import org.neo4j.kernel.impl.logging.LogService; @@ -37,6 +38,6 @@ public CypherEngineProvider() protected QueryExecutionEngine createEngine( GraphDatabaseAPI graphAPI ) { LogService logService = graphAPI.getDependencyResolver().resolveDependency( LogService.class ); - return new ExecutionEngine( graphAPI, logService.getInternalLogProvider() ); + return new ExecutionEngine( new GraphDatabaseCypherService( graphAPI ), logService.getInternalLogProvider() ); } } diff --git a/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/ExecutionEngine.java b/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/ExecutionEngine.java index 5c34fbe5aec87..badab48fd78a8 100644 --- a/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/ExecutionEngine.java +++ b/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/ExecutionEngine.java @@ -22,9 +22,8 @@ import java.util.Map; import org.neo4j.cypher.CypherException; -import org.neo4j.graphdb.GraphDatabaseService; - import org.neo4j.graphdb.Result; +import org.neo4j.kernel.GraphDatabaseQueryService; import org.neo4j.kernel.impl.query.QueryExecutionEngine; import org.neo4j.kernel.impl.query.QueryExecutionKernelException; import org.neo4j.kernel.impl.query.QuerySession; @@ -46,7 +45,7 @@ public class ExecutionEngine implements QueryExecutionEngine * Creates an execution engine around the give graph database * @param database The database to wrap */ - public ExecutionEngine( GraphDatabaseService database ) + public ExecutionEngine( GraphDatabaseQueryService database ) { inner = createInnerEngine( database, NullLogProvider.getInstance() ); } @@ -56,12 +55,12 @@ public ExecutionEngine( GraphDatabaseService database ) * @param database The database to wrap * @param logProvider A {@link LogProvider} for cypher-statements */ - public ExecutionEngine( GraphDatabaseService database, LogProvider logProvider ) + public ExecutionEngine( GraphDatabaseQueryService database, LogProvider logProvider ) { inner = createInnerEngine( database, logProvider ); } - protected org.neo4j.cypher.internal.ExecutionEngine createInnerEngine( GraphDatabaseService database, LogProvider logProvider ) + protected org.neo4j.cypher.internal.ExecutionEngine createInnerEngine( GraphDatabaseQueryService database, LogProvider logProvider ) { return new org.neo4j.cypher.internal.ExecutionEngine( database, logProvider ); } diff --git a/community/cypher/cypher/src/main/java/org/neo4j/cypher/javacompat/internal/GraphDatabaseCypherService.java b/community/cypher/cypher/src/main/java/org/neo4j/cypher/javacompat/internal/GraphDatabaseCypherService.java index bd0194926e7b9..c33f235974f9f 100644 --- a/community/cypher/cypher/src/main/java/org/neo4j/cypher/javacompat/internal/GraphDatabaseCypherService.java +++ b/community/cypher/cypher/src/main/java/org/neo4j/cypher/javacompat/internal/GraphDatabaseCypherService.java @@ -30,8 +30,6 @@ import org.neo4j.graphdb.security.URLAccessValidationError; import org.neo4j.kernel.GraphDatabaseAPI; import org.neo4j.kernel.GraphDatabaseQueryService; -import org.neo4j.kernel.api.AccessMode; -import org.neo4j.kernel.api.KernelTransaction; public class GraphDatabaseCypherService implements GraphDatabaseQueryService { diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/CypherCompiler.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/CypherCompiler.scala index 2ff8b658cb242..f9a22c906bf07 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/CypherCompiler.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/CypherCompiler.scala @@ -23,10 +23,9 @@ import org.neo4j.cypher.internal.compatibility.exceptionHandlerFor3_0 import org.neo4j.cypher.internal.compiler.v3_0._ import org.neo4j.cypher.internal.frontend.v3_0.InputPosition import org.neo4j.cypher.{InvalidArgumentException, SyntaxException, _} -import org.neo4j.graphdb.GraphDatabaseService import org.neo4j.graphdb.factory.GraphDatabaseSettings import org.neo4j.helpers.Clock -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.api.KernelAPI import org.neo4j.kernel.configuration.Config import org.neo4j.kernel.monitoring.{Monitors => KernelMonitors} @@ -62,7 +61,7 @@ case class PreParsedQuery(statement: String, rawStatement: String, version: Cyph } } -class CypherCompiler(graph: GraphDatabaseService, +class CypherCompiler(graph: GraphDatabaseQueryService, kernelAPI: KernelAPI, kernelMonitors: KernelMonitors, configuredVersion: CypherVersion, @@ -159,9 +158,9 @@ class CypherCompiler(graph: GraphDatabaseService, getSetting(graph, setting, DEFAULT_QUERY_PLAN_TTL) } - private def getSetting[A](gds: GraphDatabaseService, configLookup: Config => A, default: A): A = gds match { + private def getSetting[A](gds: GraphDatabaseQueryService, configLookup: Config => A, default: A): A = gds match { // TODO: Cypher should not be pulling out components from casted interfaces, it should ask for Config as a dep - case (gdbApi:GraphDatabaseAPI) => configLookup(gdbApi.getDependencyResolver.resolveDependency(classOf[Config])) + case (gdbApi:GraphDatabaseQueryService) => configLookup(gdbApi.getDependencyResolver.resolveDependency(classOf[Config])) case _ => default } } diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/ExecutionEngine.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/ExecutionEngine.scala index 6313c5307c49e..20d401f5599ff 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/ExecutionEngine.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/ExecutionEngine.scala @@ -27,33 +27,31 @@ import org.neo4j.cypher.internal.compiler.v3_0.helpers.JavaResultValueConverter import org.neo4j.cypher.internal.compiler.v3_0.prettifier.Prettifier import org.neo4j.cypher.internal.compiler.v3_0.{LRUCache => LRUCachev3_0, _} import org.neo4j.cypher.internal.tracing.{CompilationTracer, TimingCompilationTracer} -import org.neo4j.graphdb.GraphDatabaseService import org.neo4j.graphdb.config.Setting import org.neo4j.graphdb.factory.GraphDatabaseSettings import org.neo4j.kernel.configuration.Config import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge -import org.neo4j.kernel.impl.factory.GraphDatabaseFacade import org.neo4j.kernel.impl.query.{QueryEngineProvider, QueryExecutionMonitor, QuerySession} -import org.neo4j.kernel.{GraphDatabaseAPI, api, monitoring} +import org.neo4j.kernel.{GraphDatabaseQueryService, api, monitoring} import org.neo4j.logging.{LogProvider, NullLogProvider} import scala.collection.JavaConverters._ trait StringCacheMonitor extends CypherCacheMonitor[String, api.Statement] + /** * This class construct and initialize both the cypher compiler and the cypher runtime, which is a very expensive * operation so please make sure this will be constructed only once and properly reused. */ -class ExecutionEngine(graph: GraphDatabaseService, logProvider: LogProvider = NullLogProvider.getInstance()) { +class ExecutionEngine(graph: GraphDatabaseQueryService, logProvider: LogProvider = NullLogProvider.getInstance()) { require(graph != null, "Can't work with a null graph database") // true means we run inside REST server protected val isServer = false - protected val graphAPI = graph.asInstanceOf[GraphDatabaseAPI] - protected val kernel = graphAPI.getDependencyResolver.resolveDependency(classOf[org.neo4j.kernel.api.KernelAPI]) - private val lastCommittedTxId = LastCommittedTxIdProvider(graphAPI) - protected val kernelMonitors: monitoring.Monitors = graphAPI.getDependencyResolver.resolveDependency(classOf[org.neo4j.kernel.monitoring.Monitors]) + protected val kernel = graph.getDependencyResolver.resolveDependency(classOf[org.neo4j.kernel.api.KernelAPI]) + private val lastCommittedTxId = LastCommittedTxIdProvider(graph) + protected val kernelMonitors: monitoring.Monitors = graph.getDependencyResolver.resolveDependency(classOf[org.neo4j.kernel.monitoring.Monitors]) private val compilationTracer: CompilationTracer = { if(optGraphSetting(graph, GraphDatabaseSettings.cypher_compiler_tracing, FALSE)) new TimingCompilationTracer(kernelMonitors.newMonitor(classOf[TimingCompilationTracer.EventListener])) @@ -94,7 +92,7 @@ class ExecutionEngine(graph: GraphDatabaseService, logProvider: LogProvider = Nu executionMonitor.startQueryExecution(session, query, javaParams) val (preparedPlanExecution, txInfo) = planQuery(query) - preparedPlanExecution.profile(graphAPI, txInfo, params, session) + preparedPlanExecution.profile(graph, txInfo, params, session) } @throws(classOf[SyntaxException]) @@ -120,7 +118,7 @@ class ExecutionEngine(graph: GraphDatabaseService, logProvider: LogProvider = Nu val javaParams = javaValues.asDeepJavaResultMap(params).asInstanceOf[JavaMap[String, AnyRef]] executionMonitor.startQueryExecution(session, query, javaParams) val (preparedPlanExecution, txInfo) = planQuery(query) - preparedPlanExecution.execute(graphAPI, txInfo, params, session) + preparedPlanExecution.execute(graph, txInfo, params, session) } @throws(classOf[SyntaxException]) @@ -207,9 +205,7 @@ class ExecutionEngine(graph: GraphDatabaseService, logProvider: LogProvider = Nu throw new IllegalStateException("Could not execute query due to insanely frequent schema changes") } - private val txBridge = graph.asInstanceOf[GraphDatabaseAPI] - .getDependencyResolver - .resolveDependency(classOf[ThreadToStatementContextBridge]) + private val txBridge = graph.getDependencyResolver.resolveDependency(classOf[ThreadToStatementContextBridge]) private def getOrCreateFromSchemaState[V](statement: api.Statement, creator: => V) = { val javaCreator = new java.util.function.Function[ExecutionEngine, V]() { @@ -258,18 +254,9 @@ class ExecutionEngine(graph: GraphDatabaseService, logProvider: LogProvider = Nu GraphDatabaseSettings.query_cache_size.getDefaultValue.toInt ) - private def optGraphSetting[V](graph: GraphDatabaseService, setting: Setting[V], defaultValue: V): V = { - def optGraphAs[T <: GraphDatabaseService : Manifest]: PartialFunction[GraphDatabaseService, T] = { - case (db: T) => db - } - optGraphAs[GraphDatabaseFacade] - .andThen(g => { - // TODO: Config should be passed in as a dependency to Cypher, not pulled out of casted interfaces - val config: Config = g.getDependencyResolver.resolveDependency(classOf[Config]) - Option(config.get(setting)) - }) - .andThen(_.getOrElse(defaultValue)) - .applyOrElse(graph, (_: GraphDatabaseService) => defaultValue) + private def optGraphSetting[V](graph: GraphDatabaseQueryService, setting: Setting[V], defaultValue: V): V = { + val config = graph.getDependencyResolver.resolveDependency(classOf[Config]) + Option(config.get(setting)).getOrElse(defaultValue) } } diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/ExecutionPlan.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/ExecutionPlan.scala index ea292d02b128e..71f75a61d8454 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/ExecutionPlan.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/ExecutionPlan.scala @@ -20,14 +20,14 @@ package org.neo4j.cypher.internal import org.neo4j.graphdb.Transaction -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.api.Statement import org.neo4j.kernel.impl.query.QuerySession final case class TransactionInfo(tx: Transaction, isTopLevelTx: Boolean, statement: Statement) trait ExecutionPlan { - def run(graph: GraphDatabaseAPI, txInfo: TransactionInfo, executionMode: CypherExecutionMode, params: Map[String, Any], session: QuerySession): ExtendedExecutionResult + def run(graph: GraphDatabaseQueryService, txInfo: TransactionInfo, executionMode: CypherExecutionMode, params: Map[String, Any], session: QuerySession): ExtendedExecutionResult def isPeriodicCommit: Boolean diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/LastCommittedTxIdProvider.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/LastCommittedTxIdProvider.scala index aa7167352a2fb..b2440a080d7f9 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/LastCommittedTxIdProvider.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/LastCommittedTxIdProvider.scala @@ -19,13 +19,12 @@ */ package org.neo4j.cypher.internal -import org.neo4j.graphdb.GraphDatabaseService -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.impl.transaction.log.TransactionIdStore -case class LastCommittedTxIdProvider(db: GraphDatabaseService) extends (() => Long) { +case class LastCommittedTxIdProvider(db: GraphDatabaseQueryService) extends (() => Long) { - private val resolver = db.asInstanceOf[GraphDatabaseAPI].getDependencyResolver + private val resolver = db.getDependencyResolver override def apply(): Long = { val txIdStore = resolver.resolveDependency(classOf[TransactionIdStore]) diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/PlannerCache.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/PlannerCache.scala index 6618bf58cfbb3..62b174ead3674 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/PlannerCache.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/PlannerCache.scala @@ -22,7 +22,7 @@ package org.neo4j.cypher.internal import org.neo4j.cypher.internal.compatibility.{CompatibilityFor2_3, CompatibilityFor2_3Cost, CompatibilityFor2_3Rule, CompatibilityFor3_0, CompatibilityFor3_0Cost, CompatibilityFor3_0Rule} import org.neo4j.cypher.internal.compiler.v3_0.CypherCompilerConfiguration import org.neo4j.cypher.{CypherPlanner, CypherRuntime, CypherUpdateStrategy} -import org.neo4j.graphdb.GraphDatabaseService +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.api.KernelAPI import org.neo4j.kernel.monitoring.{Monitors => KernelMonitors} import org.neo4j.logging.Log @@ -33,7 +33,7 @@ sealed trait PlannerSpec final case class PlannerSpec_v2_3(planner: CypherPlanner, runtime: CypherRuntime) extends PlannerSpec final case class PlannerSpec_v3_0(planner: CypherPlanner, runtime: CypherRuntime, updateStrategy: CypherUpdateStrategy) extends PlannerSpec -class PlannerFactory(graph: GraphDatabaseService, kernelAPI: KernelAPI, kernelMonitors: KernelMonitors, log: Log, +class PlannerFactory(graph: GraphDatabaseQueryService, kernelAPI: KernelAPI, kernelMonitors: KernelMonitors, log: Log, config: CypherCompilerConfiguration) { import helpers.wrappersFor2_3._ diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/PreparedPlanExecution.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/PreparedPlanExecution.scala index c62fd7411eaeb..69b39f049955a 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/PreparedPlanExecution.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/PreparedPlanExecution.scala @@ -19,13 +19,13 @@ */ package org.neo4j.cypher.internal -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.impl.query.QuerySession case class PreparedPlanExecution(plan: ExecutionPlan, executionMode: CypherExecutionMode, extractedParams: Map[String, Any]) { - def execute(graph: GraphDatabaseAPI, txInfo: TransactionInfo, params: Map[String, Any], session: QuerySession) = + def execute(graph: GraphDatabaseQueryService, txInfo: TransactionInfo, params: Map[String, Any], session: QuerySession) = plan.run(graph, txInfo, executionMode, params ++ extractedParams, session) - def profile(graph: GraphDatabaseAPI, txInfo: TransactionInfo, params: Map[String, Any], session: QuerySession) = + def profile(graph: GraphDatabaseQueryService, txInfo: TransactionInfo, params: Map[String, Any], session: QuerySession) = plan.run(graph, txInfo, CypherExecutionMode.profile, params ++ extractedParams, session) } diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/compatibility/CompatibilityFor2_3.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/compatibility/CompatibilityFor2_3.scala index d077281deb6a6..469bf8afaddc8 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/compatibility/CompatibilityFor2_3.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/compatibility/CompatibilityFor2_3.scala @@ -40,7 +40,7 @@ import org.neo4j.graphdb.Result.ResultVisitor import org.neo4j.graphdb._ import org.neo4j.graphdb.impl.notification.{NotificationCode, NotificationDetail} import org.neo4j.helpers.Clock -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.{GraphDatabaseQueryService} import org.neo4j.kernel.api.{KernelAPI, Statement} import org.neo4j.kernel.impl.core.NodeManager import org.neo4j.kernel.impl.query.{QueryExecutionMonitor, QuerySession} @@ -140,7 +140,7 @@ case class WrappedMonitors2_3(kernelMonitors: KernelMonitors) extends Monitors { trait CompatibilityFor2_3 { import org.neo4j.cypher.internal.compatibility.helpersv2_3._ - val graph: GraphDatabaseService + val graph: GraphDatabaseQueryService val queryCacheSize: Int val kernelMonitors: KernelMonitors val kernelAPI: KernelAPI @@ -184,12 +184,12 @@ trait CompatibilityFor2_3 { class ExecutionPlanWrapper(inner: ExecutionPlan_v2_3) extends org.neo4j.cypher.internal.ExecutionPlan { - private def queryContext(graph: GraphDatabaseAPI, txInfo: TransactionInfo): QueryContext = { + private def queryContext(graph: GraphDatabaseQueryService, txInfo: TransactionInfo): QueryContext = { val ctx = new TransactionBoundQueryContext(graph, txInfo.tx, txInfo.isTopLevelTx, txInfo.statement) new ExceptionTranslatingQueryContextFor2_3(ctx) } - def run(graph: GraphDatabaseAPI, txInfo: TransactionInfo, executionMode: CypherExecutionMode, params: Map[String, Any], session: QuerySession): ExtendedExecutionResult = { + def run(graph: GraphDatabaseQueryService, txInfo: TransactionInfo, executionMode: CypherExecutionMode, params: Map[String, Any], session: QuerySession): ExtendedExecutionResult = { implicit val s = session val innerExecutionMode = executionMode match { case CypherExecutionMode.explain => ExplainModev2_3 @@ -413,7 +413,7 @@ class EntityAccessorWrapper2_3(nodeManager: NodeManager) extends EntityAccessor override def newRelationshipProxyById(id: Long): Relationship = nodeManager.newRelationshipProxyById(id) } -case class CompatibilityFor2_3Cost(graph: GraphDatabaseService, +case class CompatibilityFor2_3Cost(graph: GraphDatabaseQueryService, config: CypherCompilerConfiguration, clock: Clock, kernelMonitors: KernelMonitors, @@ -437,24 +437,24 @@ case class CompatibilityFor2_3Cost(graph: GraphDatabaseService, case CypherRuntime.compiled => Some(CompiledRuntimeName) } - val nodeManager = graph.asInstanceOf[GraphDatabaseAPI].getDependencyResolver.resolveDependency(classOf[NodeManager]) + val nodeManager = graph.getDependencyResolver.resolveDependency(classOf[NodeManager]) CypherCompilerFactory.costBasedCompiler( - graph, new EntityAccessorWrapper2_3(nodeManager), config, clock, GeneratedQueryStructure, new WrappedMonitors2_3( kernelMonitors ), + graph.getGraphDatabaseService, new EntityAccessorWrapper2_3(nodeManager), config, clock, GeneratedQueryStructure, new WrappedMonitors2_3( kernelMonitors ), new StringInfoLogger2_3( log ), rewriterSequencer, plannerName, runtimeName) } override val queryCacheSize: Int = config.queryCacheSize } -case class CompatibilityFor2_3Rule(graph: GraphDatabaseService, +case class CompatibilityFor2_3Rule(graph: GraphDatabaseQueryService, config: CypherCompilerConfiguration, clock: Clock, kernelMonitors: KernelMonitors, kernelAPI: KernelAPI) extends CompatibilityFor2_3 { protected val compiler = { - val nodeManager = graph.asInstanceOf[GraphDatabaseAPI].getDependencyResolver.resolveDependency(classOf[NodeManager]) + val nodeManager = graph.getDependencyResolver.resolveDependency(classOf[NodeManager]) CypherCompilerFactory.ruleBasedCompiler( - graph, new EntityAccessorWrapper2_3(nodeManager), config, clock, new WrappedMonitors2_3( kernelMonitors ), rewriterSequencer) + graph.getGraphDatabaseService, new EntityAccessorWrapper2_3(nodeManager), config, clock, new WrappedMonitors2_3( kernelMonitors ), rewriterSequencer) } override val queryCacheSize: Int = config.queryCacheSize diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/compatibility/CompatibilityFor3_0.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/compatibility/CompatibilityFor3_0.scala index e409b4f0f3232..54b51848c0841 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/compatibility/CompatibilityFor3_0.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/compatibility/CompatibilityFor3_0.scala @@ -39,9 +39,9 @@ import org.neo4j.cypher.internal.spi.v3_0.TransactionBoundQueryContext.IndexSear import org.neo4j.cypher.internal.spi.v3_0._ import org.neo4j.graphdb.Result.{ResultRow, ResultVisitor} import org.neo4j.graphdb.impl.notification.{NotificationCode, NotificationDetail} -import org.neo4j.graphdb.{GraphDatabaseService, InputPosition, Node, Path, QueryExecutionType, Relationship, ResourceIterator} +import org.neo4j.graphdb.{InputPosition, Node, Path, QueryExecutionType, Relationship, ResourceIterator} import org.neo4j.helpers.Clock -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.api.{KernelAPI, Statement} import org.neo4j.kernel.impl.query.{QueryExecutionMonitor, QuerySession} import org.neo4j.kernel.monitoring.{Monitors => KernelMonitors} @@ -143,7 +143,7 @@ case class WrappedMonitors3_0(kernelMonitors: KernelMonitors) extends Monitors { } trait CompatibilityFor3_0 { - val graph: GraphDatabaseService + val graph: GraphDatabaseQueryService val queryCacheSize: Int val kernelMonitors: KernelMonitors val kernelAPI: KernelAPI @@ -187,14 +187,14 @@ trait CompatibilityFor3_0 { class ExecutionPlanWrapper(inner: ExecutionPlan_v3_0) extends ExecutionPlan { import org.neo4j.cypher.internal.compatibility.helpersv3_0._ - private def queryContext(graph: GraphDatabaseAPI, txInfo: TransactionInfo) = { + private def queryContext(graph: GraphDatabaseQueryService, txInfo: TransactionInfo) = { val searchMonitor = kernelMonitors.newMonitor(classOf[IndexSearchMonitor]) val transactionalContext = new TransactionBoundTransactionalContext(graph, txInfo.tx, txInfo.isTopLevelTx, txInfo.statement) val ctx = new TransactionBoundQueryContext(transactionalContext)(searchMonitor) new ExceptionTranslatingQueryContextFor3_0(ctx) } - def run(graph: GraphDatabaseAPI, txInfo: TransactionInfo, executionMode: CypherExecutionMode, params: Map[String, Any], session: QuerySession): ExtendedExecutionResult = { + def run(graph: GraphDatabaseQueryService, txInfo: TransactionInfo, executionMode: CypherExecutionMode, params: Map[String, Any], session: QuerySession): ExtendedExecutionResult = { implicit val s = session val innerExecutionMode = executionMode match { case CypherExecutionMode.explain => ExplainModev3_0 @@ -452,7 +452,7 @@ class StringInfoLogger3_0(log: Log) extends InfoLogger { } } -case class CompatibilityFor3_0Cost(graph: GraphDatabaseService, +case class CompatibilityFor3_0Cost(graph: GraphDatabaseQueryService, config: CypherCompilerConfiguration, clock: Clock, kernelMonitors: KernelMonitors, @@ -488,7 +488,7 @@ case class CompatibilityFor3_0Cost(graph: GraphDatabaseService, override val queryCacheSize: Int = config.queryCacheSize } -case class CompatibilityFor3_0Rule(graph: GraphDatabaseService, +case class CompatibilityFor3_0Rule(graph: GraphDatabaseQueryService, config: CypherCompilerConfiguration, clock: Clock, kernelMonitors: KernelMonitors, diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v2_3/TransactionBoundPlanContext.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v2_3/TransactionBoundPlanContext.scala index d0bd3598d11d2..c46796f27fafc 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v2_3/TransactionBoundPlanContext.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v2_3/TransactionBoundPlanContext.scala @@ -23,8 +23,8 @@ import org.neo4j.cypher.MissingIndexException import org.neo4j.cypher.internal.compiler.v2_3.pipes.EntityProducer import org.neo4j.cypher.internal.compiler.v2_3.pipes.matching.ExpanderStep import org.neo4j.cypher.internal.compiler.v2_3.spi._ -import org.neo4j.graphdb.{Node, GraphDatabaseService} -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.graphdb.Node +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.api.Statement import org.neo4j.kernel.api.constraints.UniquenessConstraint import org.neo4j.kernel.api.exceptions.KernelException @@ -34,7 +34,7 @@ import org.neo4j.kernel.impl.transaction.log.TransactionIdStore import scala.collection.JavaConverters._ -class TransactionBoundPlanContext(initialStatement: Statement, val gdb: GraphDatabaseService) +class TransactionBoundPlanContext(initialStatement: Statement, val gdb: GraphDatabaseQueryService) extends TransactionBoundTokenContext(initialStatement) with PlanContext { @Deprecated @@ -86,13 +86,13 @@ class TransactionBoundPlanContext(initialStatement: Statement, val gdb: GraphDat } def checkNodeIndex(idxName: String) { - if (!gdb.index().existsForNodes(idxName)) { + if (!statement.readOperations().nodeLegacyIndexesGetAll().contains(idxName)) { throw new MissingIndexException(idxName) } } def checkRelIndex(idxName: String) { - if ( !gdb.index().existsForRelationships(idxName) ) { + if (!statement.readOperations().relationshipLegacyIndexesGetAll().contains(idxName)) { throw new MissingIndexException(idxName) } } @@ -117,7 +117,7 @@ class TransactionBoundPlanContext(initialStatement: Statement, val gdb: GraphDat val statistics: GraphStatistics = InstrumentedGraphStatistics(TransactionBoundGraphStatistics(statement), MutableGraphStatisticsSnapshot()) - val txIdProvider: () => Long = gdb.asInstanceOf[GraphDatabaseAPI] + val txIdProvider: () => Long = gdb .getDependencyResolver .resolveDependency(classOf[TransactionIdStore]) .getLastCommittedTransactionId diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v2_3/TransactionBoundQueryContext.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v2_3/TransactionBoundQueryContext.scala index 9511859708946..edf6038bb80f5 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v2_3/TransactionBoundQueryContext.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v2_3/TransactionBoundQueryContext.scala @@ -44,7 +44,7 @@ import org.neo4j.kernel.api.index.{IndexDescriptor, InternalIndexState} import org.neo4j.kernel.impl.api.KernelStatement import org.neo4j.kernel.impl.core.{RelationshipProxy, ThreadToStatementContextBridge} import org.neo4j.graphdb.security.URLAccessValidationError -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.{GraphDatabaseQueryService, GraphDatabaseAPI} import java.util.function.Predicate import org.neo4j.graphalgo.impl.path.ShortestPath.ShortestPathPredicate import org.neo4j.graphalgo.impl.path.ShortestPath @@ -52,7 +52,7 @@ import org.neo4j.graphalgo.impl.path.ShortestPath import scala.collection.JavaConverters._ import scala.collection.{Iterator, mutable} -final class TransactionBoundQueryContext(graph: GraphDatabaseAPI, +final class TransactionBoundQueryContext(graph: GraphDatabaseQueryService, var tx: Transaction, val isTopLevelTx: Boolean, initialStatement: Statement) @@ -110,10 +110,10 @@ final class TransactionBoundQueryContext(graph: GraphDatabaseAPI, } } - def createNode(): Node = + override def createNode(): Node = graph.createNode() - def createRelationship(start: Node, end: Node, relType: String) = + override def createRelationship(start: Node, end: Node, relType: String) = start.createRelationshipTo(end, withName(relType)) def createRelationship(start: Long, end: Long, relType: Int) = { @@ -323,73 +323,75 @@ final class TransactionBoundQueryContext(graph: GraphDatabaseAPI, statement.dataWriteOperations().nodeRemoveProperty(id, propertyKeyId) } - def setProperty(id: Long, propertyKeyId: Int, value: Any) { + override def setProperty(id: Long, propertyKeyId: Int, value: Any) { statement.dataWriteOperations().nodeSetProperty(id, properties.Property.property(propertyKeyId, value) ) } - def getById(id: Long) = try { + override def getById(id: Long) = try { graph.getNodeById(id) } catch { case e: NotFoundException => throw new EntityNotFoundException(s"Node with id $id", e) } - def all: Iterator[Node] = graph.getAllNodes.iterator().asScala + override def all: Iterator[Node] = + JavaConversionSupport.mapToScalaENFXSafe(statement.readOperations().nodesGetAll())(getById) - def indexGet(name: String, key: String, value: Any): Iterator[Node] = - graph.index.forNodes(name).get(key, value).iterator().asScala + override def indexGet(name: String, key: String, value: Any): Iterator[Node] = + JavaConversionSupport.mapToScalaENFXSafe(statement.readOperations().nodeLegacyIndexGet(name, key, value))(getById) - def indexQuery(name: String, query: Any): Iterator[Node] = - graph.index.forNodes(name).query(query).iterator().asScala + override def indexQuery(name: String, query: Any): Iterator[Node] = + JavaConversionSupport.mapToScalaENFXSafe(statement.readOperations().nodeLegacyIndexQuery(name, query))(getById) - def isDeleted(n: Node): Boolean = + override def isDeleted(n: Node): Boolean = kernelStatement.hasTxStateWithChanges && kernelStatement.txState().nodeIsDeletedInThisTx(n.getId) } class RelationshipOperations extends BaseOperations[Relationship] { - def delete(obj: Relationship) { + override def delete(obj: Relationship) { statement.dataWriteOperations().relationshipDelete(obj.getId) } - def propertyKeyIds(id: Long): Iterator[Int] = + override def propertyKeyIds(id: Long): Iterator[Int] = asScala(statement.readOperations().relationshipGetPropertyKeys(id)) - def getProperty(id: Long, propertyKeyId: Int): Any = + override def getProperty(id: Long, propertyKeyId: Int): Any = statement.readOperations().relationshipGetProperty(id, propertyKeyId) - def hasProperty(id: Long, propertyKey: Int) = + override def hasProperty(id: Long, propertyKey: Int) = statement.readOperations().relationshipHasProperty(id, propertyKey) - def removeProperty(id: Long, propertyKeyId: Int) { + override def removeProperty(id: Long, propertyKeyId: Int) { statement.dataWriteOperations().relationshipRemoveProperty(id, propertyKeyId) } - def setProperty(id: Long, propertyKeyId: Int, value: Any) { + override def setProperty(id: Long, propertyKeyId: Int, value: Any) { statement.dataWriteOperations().relationshipSetProperty(id, properties.Property.property(propertyKeyId, value) ) } - def getById(id: Long) = try { + override def getById(id: Long) = try { graph.getRelationshipById(id) } catch { case e: NotFoundException => throw new EntityNotFoundException(s"Relationship with id $id", e) } - def all: Iterator[Relationship] = - graph.getAllRelationships.iterator().asScala + override def all: Iterator[Relationship] = { + JavaConversionSupport.mapToScalaENFXSafe(statement.readOperations().relationshipsGetAll())(getById) + } - def indexGet(name: String, key: String, value: Any): Iterator[Relationship] = - graph.index.forRelationships(name).get(key, value).iterator().asScala + override def indexGet(name: String, key: String, value: Any): Iterator[Relationship] = + JavaConversionSupport.mapToScalaENFXSafe(statement.readOperations().relationshipLegacyIndexGet(name, key, value, -1, -1))(getById) - def indexQuery(name: String, query: Any): Iterator[Relationship] = - graph.index.forRelationships(name).query(query).iterator().asScala + override def indexQuery(name: String, query: Any): Iterator[Relationship] = + JavaConversionSupport.mapToScalaENFXSafe(statement.readOperations().relationshipLegacyIndexQuery(name, query, -1, -1))(getById) - def isDeleted(r: Relationship): Boolean = + override def isDeleted(r: Relationship): Boolean = kernelStatement.hasTxStateWithChanges && kernelStatement.txState().relationshipIsDeletedInThisTx(r.getId) } - def getOrCreatePropertyKeyId(propertyKey: String) = + override def getOrCreatePropertyKeyId(propertyKey: String) = statement.tokenWriteOperations().propertyKeyGetOrCreateForName(propertyKey) - def upgrade(context: QueryContext): LockingQueryContext = new RepeatableReadQueryContext(context, new Locker { + override def upgrade(context: QueryContext): LockingQueryContext = new RepeatableReadQueryContext(context, new Locker { private val locks = new mutable.ListBuffer[Lock] def releaseAllLocks() { @@ -404,15 +406,15 @@ final class TransactionBoundQueryContext(graph: GraphDatabaseAPI, abstract class BaseOperations[T <: PropertyContainer] extends Operations[T] { def primitiveLongIteratorToScalaIterator(primitiveIterator: PrimitiveLongIterator): Iterator[Long] = new Iterator[Long] { - def hasNext: Boolean = primitiveIterator.hasNext + override def hasNext: Boolean = primitiveIterator.hasNext - def next(): Long = primitiveIterator.next + override def next(): Long = primitiveIterator.next } } - def getOrCreateFromSchemaState[K, V](key: K, creator: => V) = { + override def getOrCreateFromSchemaState[K, V](key: K, creator: => V) = { val javaCreator = new java.util.function.Function[K, V]() { - def apply(key: K) = creator + override def apply(key: K) = creator } statement.readOperations().schemaStateGetOrCreate(key, javaCreator) } @@ -463,7 +465,7 @@ final class TransactionBoundQueryContext(graph: GraphDatabaseAPI, statement.schemaWriteOperations().constraintDrop(new RelationshipPropertyExistenceConstraint(relTypeId, propertyKeyId)) override def getImportURL(url: URL): Either[String,URL] = graph match { - case db: GraphDatabaseAPI => + case db: GraphDatabaseQueryService => try { Right(db.validateURLAccess(url)) } catch { @@ -499,7 +501,7 @@ final class TransactionBoundQueryContext(graph: GraphDatabaseAPI, case (Some(min), Some(max)) => Evaluators.includingDepths(min, max) } - val baseTraversalDescription: TraversalDescription = graph.traversalDescription() + val baseTraversalDescription: TraversalDescription = graph.getGraphDatabaseService.traversalDescription() .evaluator(depthEval) .uniqueness(Uniqueness.RELATIONSHIP_PATH) diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundPlanContext.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundPlanContext.scala index 11ce90ffb689d..b7c711ad6f8ea 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundPlanContext.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundPlanContext.scala @@ -26,7 +26,8 @@ import org.neo4j.cypher.internal.compiler.v3_0.pipes.matching.ExpanderStep import org.neo4j.cypher.internal.compiler.v3_0.spi._ import org.neo4j.cypher.internal.frontend.v3_0.symbols import org.neo4j.cypher.internal.frontend.v3_0.symbols.CypherType -import org.neo4j.graphdb.{GraphDatabaseService, Node} +import org.neo4j.graphdb.Node +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.api.Statement import org.neo4j.kernel.api.constraints.UniquenessConstraint import org.neo4j.kernel.api.exceptions.KernelException @@ -37,7 +38,7 @@ import org.neo4j.kernel.api.proc.{Neo4jTypes, ProcedureSignature => KernelProced import scala.collection.JavaConverters._ -class TransactionBoundPlanContext(statement: Statement, val gdb: GraphDatabaseService) +class TransactionBoundPlanContext(statement: Statement, val gdb: GraphDatabaseQueryService) extends TransactionBoundTokenContext(statement) with PlanContext { @Deprecated @@ -89,13 +90,13 @@ class TransactionBoundPlanContext(statement: Statement, val gdb: GraphDatabaseSe } def checkNodeIndex(idxName: String) { - if (!gdb.index().existsForNodes(idxName)) { + if (!statement.readOperations().nodeLegacyIndexesGetAll().contains(idxName)) { throw new MissingIndexException(idxName) } } def checkRelIndex(idxName: String) { - if ( !gdb.index().existsForRelationships(idxName) ) { + if (!statement.readOperations().relationshipLegacyIndexesGetAll().contains(idxName)) { throw new MissingIndexException(idxName) } } diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundQueryContext.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundQueryContext.scala index a5edddecb4b5b..8aabdc16919d2 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundQueryContext.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundQueryContext.scala @@ -43,24 +43,23 @@ import org.neo4j.graphdb.RelationshipType._ import org.neo4j.graphdb._ import org.neo4j.graphdb.security.URLAccessValidationError import org.neo4j.graphdb.traversal.{Evaluators, TraversalDescription, Uniqueness} -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.api._ import org.neo4j.kernel.api.constraints.{NodePropertyExistenceConstraint, RelationshipPropertyExistenceConstraint, UniquenessConstraint} import org.neo4j.kernel.api.exceptions.ProcedureException import org.neo4j.kernel.api.exceptions.schema.{AlreadyConstrainedException, AlreadyIndexedException} import org.neo4j.kernel.api.index.{IndexDescriptor, InternalIndexState} import org.neo4j.kernel.api.txstate.TxStateHolder -import org.neo4j.kernel.impl.api.{KernelStatement => InternalKernelStatement} import org.neo4j.kernel.impl.core.NodeManager import org.neo4j.kernel.impl.locking.ResourceTypes import scala.collection.Iterator import scala.collection.JavaConverters._ -final class TransactionBoundQueryContext(val transactionalContext: TransactionalContext[GraphDatabaseAPI,Statement,TxStateHolder])(implicit indexSearchMonitor: IndexSearchMonitor) +final class TransactionBoundQueryContext(val transactionalContext: TransactionalContext[GraphDatabaseQueryService,Statement,TxStateHolder])(implicit indexSearchMonitor: IndexSearchMonitor) extends TransactionBoundTokenContext(transactionalContext.statement) with QueryContext { - type Graph = GraphDatabaseAPI + type Graph = GraphDatabaseQueryService type KernelStatement = Statement @@ -326,13 +325,14 @@ final class TransactionBoundQueryContext(val transactionalContext: Transactional case e: NotFoundException => throw new EntityNotFoundException(s"Node with id $id", e) } - override def all: Iterator[Node] = transactionalContext.graph.getAllNodes.iterator().asScala + override def all: Iterator[Node] = + JavaConversionSupport.mapToScalaENFXSafe(transactionalContext.statement.readOperations().nodesGetAll())(getById) override def indexGet(name: String, key: String, value: Any): Iterator[Node] = - transactionalContext.graph.index.forNodes(name).get(key, value).iterator().asScala + JavaConversionSupport.mapToScalaENFXSafe(transactionalContext.statement.readOperations().nodeLegacyIndexGet(name, key, value))(getById) override def indexQuery(name: String, query: Any): Iterator[Node] = - transactionalContext.graph.index.forNodes(name).query(query).iterator().asScala + JavaConversionSupport.mapToScalaENFXSafe(transactionalContext.statement.readOperations().nodeLegacyIndexQuery(name, query))(getById) override def isDeletedInThisTx(n: Node): Boolean = isDeletedInThisTx(n.getId) @@ -382,13 +382,15 @@ final class TransactionBoundQueryContext(val transactionalContext: Transactional case e: NotFoundException => throw new EntityNotFoundException(s"Relationship with id $id", e) } - override def all: Iterator[Relationship] = transactionalContext.graph.getAllRelationships.iterator().asScala + override def all: Iterator[Relationship] = { + JavaConversionSupport.mapToScalaENFXSafe(transactionalContext.statement.readOperations().relationshipsGetAll())(getById) + } override def indexGet(name: String, key: String, value: Any): Iterator[Relationship] = - transactionalContext.graph.index.forRelationships(name).get(key, value).iterator().asScala + JavaConversionSupport.mapToScalaENFXSafe(transactionalContext.statement.readOperations().relationshipLegacyIndexGet(name, key, value, -1, -1))(getById) override def indexQuery(name: String, query: Any): Iterator[Relationship] = - transactionalContext.graph.index.forRelationships(name).query(query).iterator().asScala + JavaConversionSupport.mapToScalaENFXSafe(transactionalContext.statement.readOperations().relationshipLegacyIndexQuery(name, query, -1, -1))(getById) override def isDeletedInThisTx(r: Relationship): Boolean = isDeletedInThisTx(r.getId) @@ -468,7 +470,7 @@ final class TransactionBoundQueryContext(val transactionalContext: Transactional transactionalContext.statement.schemaWriteOperations().constraintDrop(new RelationshipPropertyExistenceConstraint(relTypeId, propertyKeyId)) override def getImportURL(url: URL): Either[String,URL] = transactionalContext.graph match { - case db: GraphDatabaseAPI => + case db: GraphDatabaseQueryService => try { Right(db.validateURLAccess(url)) } catch { @@ -496,7 +498,8 @@ final class TransactionBoundQueryContext(val transactionalContext: Transactional case (Some(min), Some(max)) => Evaluators.includingDepths(min, max) } - val baseTraversalDescription: TraversalDescription = transactionalContext.graph.traversalDescription() + val baseTraversalDescription: TraversalDescription = transactionalContext.graph.getGraphDatabaseService + .traversalDescription() .evaluator(depthEval) .uniqueness(Uniqueness.RELATIONSHIP_PATH) diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundTransactionalContext.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundTransactionalContext.scala index 6bd70fd0121ff..0915bb466ac69 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundTransactionalContext.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundTransactionalContext.scala @@ -21,14 +21,15 @@ package org.neo4j.cypher.internal.spi.v3_0 import org.neo4j.cypher.internal.compiler.v3_0.spi.TransactionalContext import org.neo4j.graphdb.Transaction -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.api.Statement import org.neo4j.kernel.api.txstate.TxStateHolder import org.neo4j.kernel.impl.api.KernelStatement import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge -case class TransactionBoundTransactionalContext(graph: GraphDatabaseAPI, initialTx: Transaction, - val isTopLevelTx: Boolean, initialStatement: Statement) extends TransactionalContext[GraphDatabaseAPI, Statement, TxStateHolder] { +case class TransactionBoundTransactionalContext(graph: GraphDatabaseQueryService, initialTx: Transaction, + val isTopLevelTx: Boolean, initialStatement: Statement) + extends TransactionalContext[GraphDatabaseQueryService, Statement, TxStateHolder] { private var tx = initialTx private var open = true private var _statement = initialStatement diff --git a/community/cypher/cypher/src/test/java/org/neo4j/cypher/ManyMergesStressTest.java b/community/cypher/cypher/src/test/java/org/neo4j/cypher/ManyMergesStressTest.java index 373df9199cddc..53fbc9b693ca1 100644 --- a/community/cypher/cypher/src/test/java/org/neo4j/cypher/ManyMergesStressTest.java +++ b/community/cypher/cypher/src/test/java/org/neo4j/cypher/ManyMergesStressTest.java @@ -19,20 +19,22 @@ */ package org.neo4j.cypher; -import java.io.IOException; -import java.util.Random; -import java.util.concurrent.TimeUnit; - import org.junit.Ignore; import org.junit.Rule; import org.junit.Test; +import java.io.IOException; +import java.util.Random; +import java.util.concurrent.TimeUnit; + import org.neo4j.cypher.internal.javacompat.ExecutionEngine; import org.neo4j.cypher.internal.javacompat.ExecutionResult; +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService; import org.neo4j.graphdb.GraphDatabaseService; import org.neo4j.graphdb.Label; import org.neo4j.graphdb.Transaction; import org.neo4j.helpers.collection.Pair; +import org.neo4j.kernel.GraphDatabaseQueryService; import org.neo4j.test.EmbeddedDatabaseRule; import static java.lang.String.format; @@ -53,6 +55,7 @@ public class ManyMergesStressTest public void shouldWorkFine() throws IOException { GraphDatabaseService db = dbRule.getGraphDatabaseService(); + GraphDatabaseQueryService graph = new GraphDatabaseCypherService( db ); Label person = Label.label( "Person" ); @@ -80,7 +83,7 @@ public void shouldWorkFine() throws IOException tx.success(); } - ExecutionEngine engine = new ExecutionEngine( db ); + ExecutionEngine engine = new ExecutionEngine( graph ); for( int count = 0; count < TRIES; count++ ) { diff --git a/community/cypher/cypher/src/test/java/org/neo4j/cypher/QueryExecutionMonitorTest.scala b/community/cypher/cypher/src/test/java/org/neo4j/cypher/QueryExecutionMonitorTest.scala index b078fd71ffb6d..1326acc36da8a 100644 --- a/community/cypher/cypher/src/test/java/org/neo4j/cypher/QueryExecutionMonitorTest.scala +++ b/community/cypher/cypher/src/test/java/org/neo4j/cypher/QueryExecutionMonitorTest.scala @@ -24,10 +24,9 @@ import java.util.Collections import org.mockito.Mockito._ import org.neo4j.cypher.internal.ExecutionEngine import org.neo4j.cypher.internal.frontend.v3_0.test_helpers.CypherFunSuite -import org.neo4j.graphdb.GraphDatabaseService -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.impl.query.{QueryEngineProvider, QueryExecutionMonitor} -import org.neo4j.kernel.monitoring.Monitors import org.neo4j.test.TestGraphDatabaseFactory class QueryExecutionMonitorTest extends CypherFunSuite { @@ -207,25 +206,22 @@ class QueryExecutionMonitorTest extends CypherFunSuite { verify(monitor, times(1)).endSuccess(session) } - var graph: GraphDatabaseService = null + var graph: GraphDatabaseQueryService = null var monitor: QueryExecutionMonitor = null var engine: ExecutionEngine = null override protected def beforeEach(): Unit = { super.beforeEach() - graph = new TestGraphDatabaseFactory().newImpermanentDatabase() + graph = new GraphDatabaseCypherService(new TestGraphDatabaseFactory().newImpermanentDatabase()) monitor = mock[QueryExecutionMonitor] - monitors(graph).addMonitorListener(monitor) + val monitors = graph.getDependencyResolver.resolveDependency(classOf[org.neo4j.kernel.monitoring.Monitors]) + monitors.addMonitorListener(monitor) engine = new ExecutionEngine(graph) } override protected def afterEach(): Unit = { super.afterEach() - if (graph != null) graph.shutdown() + if (graph != null) graph.getGraphDatabaseService.shutdown() } - private def monitors(graph: GraphDatabaseService): Monitors = { - val graphAPI = graph.asInstanceOf[GraphDatabaseAPI] - graphAPI.getDependencyResolver.resolveDependency(classOf[org.neo4j.kernel.monitoring.Monitors]) - } } diff --git a/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/CypherLoggingTest.java b/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/CypherLoggingTest.java index e0ebde93467c4..3deb4e88dc9be 100644 --- a/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/CypherLoggingTest.java +++ b/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/CypherLoggingTest.java @@ -23,6 +23,7 @@ import org.junit.Test; +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService; import org.neo4j.logging.AssertableLogProvider; import org.neo4j.logging.LogProvider; import org.neo4j.test.TestGraphDatabaseFactory; @@ -49,6 +50,8 @@ public void shouldNotLogQueries() throws Exception private ExecutionEngine engineWithLogger( LogProvider logProvider ) throws IOException { - return new ExecutionEngine( new TestGraphDatabaseFactory().newImpermanentDatabase(), logProvider ); + return new ExecutionEngine( + new GraphDatabaseCypherService( new TestGraphDatabaseFactory().newImpermanentDatabase() ), + logProvider ); } } diff --git a/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/CypherUpdateMapTest.java b/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/CypherUpdateMapTest.java index 13a66a2340072..afa76a0309091 100644 --- a/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/CypherUpdateMapTest.java +++ b/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/CypherUpdateMapTest.java @@ -19,13 +19,15 @@ */ package org.neo4j.cypher.internal.javacompat; +import org.hamcrest.Matcher; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.neo4j.graphdb.GraphDatabaseService; +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService; import org.neo4j.graphdb.Node; import org.neo4j.graphdb.Transaction; +import org.neo4j.kernel.GraphDatabaseQueryService; import org.neo4j.test.TestGraphDatabaseFactory; import static org.hamcrest.Matchers.not; @@ -38,7 +40,7 @@ public class CypherUpdateMapTest { private ExecutionEngine engine; - private GraphDatabaseService gdb; + private GraphDatabaseQueryService gdb; @Test public void updateNodeByMapParameter() @@ -52,8 +54,8 @@ public void updateNodeByMapParameter() Node node1 = getNodeByIdInTx( 0 ); - assertThat( node1, inTx( gdb, hasProperty( "key1" ).withValue( "value1" ) ) ); - assertThat( node1, inTx( gdb, hasProperty( "key2" ).withValue( 1234 ) ) ); + assertThat( node1, inTxS( hasProperty( "key1" ).withValue( "value1" ) ) ); + assertThat( node1, inTxS( hasProperty( "key2" ).withValue( 1234 ) ) ); engine.execute( "MATCH (n:Reference) SET n = {data} RETURN n", @@ -64,9 +66,14 @@ public void updateNodeByMapParameter() Node node2 = getNodeByIdInTx( 0 ); - assertThat( node2, inTx( gdb, not( hasProperty( "key1" ) ) ) ); - assertThat( node2, inTx( gdb, not( hasProperty( "key2" ) ) ) ); - assertThat( node2, inTx( gdb, hasProperty( "key3" ).withValue(5678) ) ); + assertThat( node2, inTxS( not( hasProperty( "key1" ) ) ) ); + assertThat( node2, inTxS( not( hasProperty( "key2" ) ) ) ); + assertThat( node2, inTxS( hasProperty( "key3" ).withValue(5678) ) ); + } + + public Matcher inTxS( final Matcher inner ) + { + return inTx( gdb.getGraphDatabaseService(), inner, false ); } private Node getNodeByIdInTx( int nodeId ) @@ -80,13 +87,13 @@ private Node getNodeByIdInTx( int nodeId ) @Before public void setup() { - gdb = new TestGraphDatabaseFactory().newImpermanentDatabase(); + gdb = new GraphDatabaseCypherService(new TestGraphDatabaseFactory().newImpermanentDatabase()); engine = new ExecutionEngine(gdb); } @After public void cleanup() { - gdb.shutdown(); + gdb.getGraphDatabaseService().shutdown(); } } diff --git a/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/ExecutionEngineTests.java b/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/ExecutionEngineTests.java index bfc17260c8f56..055c74a11029f 100644 --- a/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/ExecutionEngineTests.java +++ b/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/ExecutionEngineTests.java @@ -19,12 +19,13 @@ */ package org.neo4j.cypher.internal.javacompat; -import java.util.List; -import java.util.Map; - import org.junit.Rule; import org.junit.Test; +import java.util.List; +import java.util.Map; + +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService; import org.neo4j.test.DatabaseRule; import org.neo4j.test.ImpermanentDatabaseRule; @@ -39,7 +40,7 @@ public class ExecutionEngineTests @Test public void shouldConvertListsAndMapsWhenPassingFromScalaToJava() throws Exception { - ExecutionEngine executionEngine = new ExecutionEngine( database.getGraphDatabaseService() ); + ExecutionEngine executionEngine = new ExecutionEngine( new GraphDatabaseCypherService(database.getGraphDatabaseService()) ); ExecutionResult result = executionEngine.execute( "RETURN { key : 'Value' , " + "collectionKey: [{ inner: 'Map1' }, { inner: 'Map2' }]}" ); diff --git a/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/ExecutionResultTest.java b/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/ExecutionResultTest.java index 2d919b846b599..442768481305b 100644 --- a/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/ExecutionResultTest.java +++ b/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/ExecutionResultTest.java @@ -28,6 +28,7 @@ import java.util.Map; import org.neo4j.cypher.ArithmeticException; +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService; import org.neo4j.graphdb.Node; import org.neo4j.graphdb.ResourceIterator; import org.neo4j.graphdb.Result; @@ -53,7 +54,7 @@ public class ExecutionResultTest @Before public void initializeExecutionEngine() throws Exception { - engine = new ExecutionEngine( db ); + engine = new ExecutionEngine( new GraphDatabaseCypherService(db) ); } //TODO this test is not valid for compiled runtime as the transaction will be closed when the iterator was created diff --git a/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/JavaValueCompatibilityTest.java b/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/JavaValueCompatibilityTest.java index ce3ef5351f6da..c0563dcf75f8f 100644 --- a/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/JavaValueCompatibilityTest.java +++ b/community/cypher/cypher/src/test/java/org/neo4j/cypher/internal/javacompat/JavaValueCompatibilityTest.java @@ -20,13 +20,14 @@ package org.neo4j.cypher.internal.javacompat; +import org.junit.Before; +import org.junit.Test; + import java.io.IOException; import java.util.List; import java.util.Map; -import org.junit.Before; -import org.junit.Test; - +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService; import org.neo4j.graphdb.GraphDatabaseService; import org.neo4j.graphdb.ResourceIterator; import org.neo4j.test.TestGraphDatabaseFactory; @@ -42,7 +43,7 @@ public class JavaValueCompatibilityTest public void setUp() throws IOException { GraphDatabaseService db = new TestGraphDatabaseFactory().newImpermanentDatabaseBuilder().newGraphDatabase(); - engine = new ExecutionEngine( db ); + engine = new ExecutionEngine( new GraphDatabaseCypherService( db) ); } @Test diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/ExecutionEngineIT.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/ExecutionEngineIT.scala index 94a80c6cc43a6..6db2e3c843639 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/ExecutionEngineIT.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/ExecutionEngineIT.scala @@ -22,10 +22,11 @@ package org.neo4j.cypher import org.neo4j.cypher.internal.ExecutionEngine import org.neo4j.cypher.internal.compiler.v3_0.CostBasedPlannerName import org.neo4j.cypher.internal.frontend.v3_0.test_helpers.CypherFunSuite +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService import org.neo4j.graphdb.GraphDatabaseService import org.neo4j.graphdb.Result.{ResultRow, ResultVisitor} import org.neo4j.graphdb.factory.GraphDatabaseSettings -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge import org.neo4j.test.TestGraphDatabaseFactory @@ -226,7 +227,7 @@ class ExecutionEngineIT extends CypherFunSuite { // call to close actually worked } - private implicit class RichDb(db: GraphDatabaseService) { + private implicit class RichDb(db: GraphDatabaseService) extends GraphDatabaseCypherService(db) { def planDescriptionForQuery(query: String) = { val res = db.execute(query) res.resultAsString() @@ -234,7 +235,7 @@ class ExecutionEngineIT extends CypherFunSuite { } } - private def txBridge(db: GraphDatabaseService) = { - db.asInstanceOf[GraphDatabaseAPI].getDependencyResolver.resolveDependency(classOf[ThreadToStatementContextBridge]) + private def txBridge(db: GraphDatabaseQueryService) = { + db.getDependencyResolver.resolveDependency(classOf[ThreadToStatementContextBridge]) } } diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/ExecutionEngineTest.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/ExecutionEngineTest.scala index da42bf2fe0897..fa364ef09a2b7 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/ExecutionEngineTest.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/ExecutionEngineTest.scala @@ -27,6 +27,7 @@ import org.neo4j.cypher.internal.compiler.v3_0.CompilationPhaseTracer.Compilatio import org.neo4j.cypher.internal.compiler.v3_0.test_helpers.CreateTempFileTestSupport import org.neo4j.cypher.internal.tracing.TimingCompilationTracer import org.neo4j.cypher.internal.tracing.TimingCompilationTracer.QueryEvent +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService import org.neo4j.graphdb._ import org.neo4j.graphdb.config.Setting import org.neo4j.graphdb.factory.GraphDatabaseSettings @@ -489,7 +490,7 @@ order by a.COL1""") test("createEngineWithSpecifiedParserVersion") { val config = Map[Setting[_], String](GraphDatabaseSettings.cypher_parser_version -> "2.3") val db = new TestGraphDatabaseFactory().newImpermanentDatabase(config.asJava) - val engine = new ExecutionEngine(db) + val engine = new ExecutionEngine(new GraphDatabaseCypherService(db)) try { // This syntax is valid today, but should give an exception in 1.5 @@ -1055,6 +1056,6 @@ order by a.COL1""") val db = new TestGraphDatabaseFactory().newEmbeddedDatabaseBuilder("target/readonly") .setConfig( GraphDatabaseSettings.read_only, "true" ) .newGraphDatabase() - new ExecutionEngine(db) + new ExecutionEngine(new GraphDatabaseCypherService(db)) } } diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/GraphDatabaseTestSupport.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/GraphDatabaseTestSupport.scala index 801446de81f22..03075da689a19 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/GraphDatabaseTestSupport.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/GraphDatabaseTestSupport.scala @@ -26,11 +26,12 @@ import org.neo4j.cypher.internal.frontend.v3_0.test_helpers.{CypherFunSuite, Cyp import org.neo4j.cypher.internal.helpers.GraphIcing import org.neo4j.cypher.internal.spi.v3_0.TransactionBoundPlanContext import org.neo4j.cypher.internal.spi.v3_0.TransactionBoundQueryContext.IndexSearchMonitor +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService import org.neo4j.graphdb._ import org.neo4j.graphdb.config.Setting import org.neo4j.kernel.api.{DataWriteOperations, KernelAPI} import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge -import org.neo4j.kernel.{GraphDatabaseAPI, monitoring} +import org.neo4j.kernel.{GraphDatabaseQueryService, monitoring} import org.neo4j.test.TestGraphDatabaseFactory import scala.collection.JavaConverters._ @@ -39,7 +40,7 @@ import scala.collection.Map trait GraphDatabaseTestSupport extends CypherTestSupport with GraphIcing { self: CypherFunSuite => - var graph: GraphDatabaseAPI = null + var graph: GraphDatabaseQueryService = null var nodes: List[Node] = null def databaseConfig(): Map[Setting[_],String] = Map() @@ -49,8 +50,8 @@ trait GraphDatabaseTestSupport extends CypherTestSupport with GraphIcing { graph = createGraphDatabase() } - protected def createGraphDatabase(): GraphDatabaseAPI = { - new TestGraphDatabaseFactory().newImpermanentDatabase(databaseConfig().asJava).asInstanceOf[GraphDatabaseAPI] + protected def createGraphDatabase(): GraphDatabaseQueryService = { + new GraphDatabaseCypherService(new TestGraphDatabaseFactory().newImpermanentDatabase(databaseConfig().asJava)) } override protected def stopTest() { @@ -58,7 +59,7 @@ trait GraphDatabaseTestSupport extends CypherTestSupport with GraphIcing { super.stopTest() } finally { - if (graph != null) graph.shutdown() + if (graph != null) graph.getGraphDatabaseService.shutdown() } } diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/IndexOpAcceptanceTest.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/IndexOpAcceptanceTest.scala index 636e5fc683877..b9cc9980bd8af 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/IndexOpAcceptanceTest.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/IndexOpAcceptanceTest.scala @@ -19,12 +19,13 @@ */ package org.neo4j.cypher -import org.neo4j.cypher.internal.ExecutionEngine -import org.neo4j.kernel.api.exceptions.schema.{NoSuchIndexException, DropIndexFailureException} +import java.io.{File, FileOutputStream} import java.util.concurrent.TimeUnit -import java.io.{FileOutputStream, File} -import org.neo4j.graphdb.factory.GraphDatabaseFactory + +import org.neo4j.cypher.internal.ExecutionEngine +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService import org.neo4j.graphdb.GraphDatabaseService +import org.neo4j.kernel.api.exceptions.schema.{DropIndexFailureException, NoSuchIndexException} import org.neo4j.test.TestGraphDatabaseFactory class IndexOpAcceptanceTest extends ExecutionEngineFunSuite with QueryStatisticsTestSupport { @@ -97,7 +98,7 @@ class IndexOpAcceptanceTest extends ExecutionEngineFunSuite with QueryStatistics private def createDbWithFailedIndex: GraphDatabaseService = { new File("target/test-data/impermanent-db").deleteAll() var graph = new TestGraphDatabaseFactory().newEmbeddedDatabase("target/test-data/impermanent-db") - eengine = new ExecutionEngine(graph) + eengine = new ExecutionEngine(new GraphDatabaseCypherService(graph)) execute("CREATE INDEX ON :Person(name)") execute("create (:Person {name:42})") val tx = graph.beginTx() @@ -114,7 +115,7 @@ class IndexOpAcceptanceTest extends ExecutionEngineFunSuite with QueryStatistics stream.close() graph = new TestGraphDatabaseFactory().newEmbeddedDatabase("target/test-data/impermanent-db") - eengine = new ExecutionEngine(graph) + eengine = new ExecutionEngine(new GraphDatabaseCypherService(graph)) graph } } diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/RunWithConfigTestSupport.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/RunWithConfigTestSupport.scala index 25ce659a27dde..1b6b1d6307909 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/RunWithConfigTestSupport.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/RunWithConfigTestSupport.scala @@ -22,6 +22,7 @@ package org.neo4j.cypher import java.util import org.neo4j.cypher.internal.ExecutionEngine +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService import org.neo4j.graphdb.config.Setting import org.neo4j.test.TestGraphDatabaseFactory @@ -32,7 +33,7 @@ trait RunWithConfigTestSupport { val config: util.Map[Setting[_], String] = m.toMap.asJava val graph = new TestGraphDatabaseFactory().newImpermanentDatabase(config) try { - val engine = new ExecutionEngine(graph) + val engine = new ExecutionEngine(new GraphDatabaseCypherService(graph)) run(engine) } finally { graph.shutdown() diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/LastCommittedTxIdProviderTest.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/LastCommittedTxIdProviderTest.scala index b5561c8032765..1a49675f49df3 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/LastCommittedTxIdProviderTest.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/LastCommittedTxIdProviderTest.scala @@ -20,21 +20,22 @@ package org.neo4j.cypher.internal import org.neo4j.cypher.internal.frontend.v3_0.test_helpers.CypherFunSuite -import org.neo4j.kernel.{GraphDatabaseAPI, NeoStoreDataSource} +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService +import org.neo4j.kernel.{GraphDatabaseQueryService, NeoStoreDataSource} import org.neo4j.test.TestGraphDatabaseFactory import org.scalatest.BeforeAndAfterAll class LastCommittedTxIdProviderTest extends CypherFunSuite with BeforeAndAfterAll { - var db: GraphDatabaseAPI = null + var db: GraphDatabaseQueryService = null var lastCommittedTxIdProvider: LastCommittedTxIdProvider = null override protected def beforeAll(): Unit = { - db = new TestGraphDatabaseFactory().newImpermanentDatabase().asInstanceOf[GraphDatabaseAPI] + db = new GraphDatabaseCypherService(new TestGraphDatabaseFactory().newImpermanentDatabase()) lastCommittedTxIdProvider = LastCommittedTxIdProvider(db) } - override protected def afterAll(): Unit = db.shutdown() + override protected def afterAll(): Unit = db.getGraphDatabaseService.shutdown() test("should return correct last committed tx id") { val startingTxId = lastCommittedTxIdProvider() diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/CompilerComparisonTest.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/CompilerComparisonTest.scala index 62005f0918052..203dbd1aad050 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/CompilerComparisonTest.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/CompilerComparisonTest.scala @@ -32,12 +32,12 @@ import org.neo4j.cypher.internal.compiler.v3_0.planner.logical.plans.rewriter.Lo import org.neo4j.cypher.internal.compiler.v3_0.tracing.rewriters.RewriterStepSequencer import org.neo4j.cypher.internal.frontend.v3_0.ast.Statement import org.neo4j.cypher.internal.frontend.v3_0.parser.CypherParser -import org.neo4j.cypher.internal.spi.v3_0.{TransactionBoundTransactionalContext, GeneratedQueryStructure, TransactionBoundPlanContext, TransactionBoundQueryContext} +import org.neo4j.cypher.internal.spi.v3_0.{GeneratedQueryStructure, TransactionBoundPlanContext, TransactionBoundQueryContext, TransactionBoundTransactionalContext} +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService import org.neo4j.cypher.{ExecutionEngineFunSuite, NewPlannerTestSupport, QueryStatisticsTestSupport} -import org.neo4j.graphdb.GraphDatabaseService import org.neo4j.graphdb.factory.GraphDatabaseFactory import org.neo4j.helpers.Clock -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.monitoring.{Monitors => KernelMonitors} import scala.xml.Elem @@ -57,7 +57,7 @@ class CompilerComparisonTest extends ExecutionEngineFunSuite with QueryStatistic errorIfShortestPathFallbackUsedAtRuntime = true ) - val compilers = Seq[(String, GraphDatabaseService => CypherCompiler)]( + val compilers = Seq[(String, GraphDatabaseQueryService => CypherCompiler)]( "legacy (rule)" -> legacyCompiler, "ronja (idp)" -> ronjaCompiler(IDPPlannerName), "ronja (dp)" -> ronjaCompiler(DPPlannerName) @@ -287,7 +287,7 @@ class CompilerComparisonTest extends ExecutionEngineFunSuite with QueryStatistic private val rewriterSequencer = RewriterStepSequencer.newPlain _ - private def ronjaCompiler(plannerName: CostBasedPlannerName, metricsFactoryInput: MetricsFactory = SimpleMetricsFactory)(graph: GraphDatabaseService): CypherCompiler = { + private def ronjaCompiler(plannerName: CostBasedPlannerName, metricsFactoryInput: MetricsFactory = SimpleMetricsFactory)(graph: GraphDatabaseQueryService): CypherCompiler = { val kernelMonitors = new KernelMonitors() val monitors = new WrappedMonitors3_0(kernelMonitors) val parser = new CypherParser @@ -320,7 +320,7 @@ class CompilerComparisonTest extends ExecutionEngineFunSuite with QueryStatistic new CypherCompiler(parser, checker, execPlanBuilder, rewriter, cache, planCacheFactory, cacheFlushMonitor, monitors) } - private def legacyCompiler(graph: GraphDatabaseService): CypherCompiler = { + private def legacyCompiler(graph: GraphDatabaseQueryService): CypherCompiler = { val kernelMonitors = new KernelMonitors() val monitors = new WrappedMonitors3_0(kernelMonitors) val parser = new CypherParser @@ -377,7 +377,7 @@ class CompilerComparisonTest extends ExecutionEngineFunSuite with QueryStatistic private def executionResults: Seq[DataSetResults] = (for ((dataSet, queries) <- queriesByDataSet) yield { val (dataSetName, dataSetDir) = dataSet - val db = new GraphDatabaseFactory().newEmbeddedDatabase(dataSetDir).asInstanceOf[GraphDatabaseAPI] + val db = new GraphDatabaseCypherService(new GraphDatabaseFactory().newEmbeddedDatabase(dataSetDir)) try { val queryResults = for ((queryName, queryText) <- queries) yield { val results = for ((compilerName, compilerCreator) <- compilers) yield { @@ -535,7 +535,7 @@ class CompilerComparisonTest extends ExecutionEngineFunSuite with QueryStatistic println(s"report written to ${report.getAbsolutePath}") } - private def runQueryWith(query: String, compiler: CypherCompiler, db: GraphDatabaseAPI): (List[Map[String, Any]], InternalExecutionResult) = { + private def runQueryWith(query: String, compiler: CypherCompiler, db: GraphDatabaseQueryService): (List[Map[String, Any]], InternalExecutionResult) = { val (plan: ExecutionPlan, parameters) = db.withTx { tx => val planContext = new TransactionBoundPlanContext(db.statement, db) diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/DoubleCheckCreateUniqueTest.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/DoubleCheckCreateUniqueTest.scala index be425127bc3fa..79ad844ea47fe 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/DoubleCheckCreateUniqueTest.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/DoubleCheckCreateUniqueTest.scala @@ -20,13 +20,13 @@ package org.neo4j.cypher.internal.compiler.v3_0 import java.lang.Iterable -import java.net.URL import java.util import org.neo4j.cypher.internal.compiler.v3_0.mutation.{CreateUniqueAction, UniqueLink} import org.neo4j.cypher.internal.compiler.v3_0.pipes.QueryState import org.neo4j.cypher.internal.frontend.v3_0.SemanticDirection import org.neo4j.cypher.internal.frontend.v3_0.test_helpers.CypherFunSuite +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService import org.neo4j.graphdb._ import org.neo4j.graphdb.event.{KernelEventHandler, TransactionEventHandler} import org.neo4j.graphdb.index.IndexManager @@ -48,7 +48,7 @@ getRelationships on a node, we'll create a new relationship. class DoubleCheckCreateUniqueTest extends CypherFunSuite { var done = false - val db = new Wrapper(new TestGraphDatabaseFactory().newImpermanentDatabase().asInstanceOf[GraphDatabaseAPI]) + val db = new Wrapper(new TestGraphDatabaseFactory().newImpermanentDatabase()) var tx:Transaction = null test("double_check_unique") { @@ -97,80 +97,13 @@ class DoubleCheckCreateUniqueTest extends CypherFunSuite { } } -class Wrapper(delegate: GraphDatabaseAPI) extends GraphDatabaseAPI -{ +class Wrapper(graph: GraphDatabaseService) extends GraphDatabaseCypherService(graph) { var afterGetRelationship: Node => Unit = (n) => {} override def createNode(): Node = { - val n = delegate.createNode() + val n = graph.createNode() new PausingNode(n, afterGetRelationship) } - - override def createNode(labels: Label*): Node = delegate.createNode(labels:_*) - - override def shutdown(): Unit = delegate.shutdown() - - override def findNodesByLabelAndProperty(label: Label, key: String, value: scala.Any): ResourceIterable[Node] = - delegate.findNodesByLabelAndProperty(label, key, value) - - override def registerKernelEventHandler(handler: KernelEventHandler): KernelEventHandler = - delegate.registerKernelEventHandler(handler) - - override def unregisterTransactionEventHandler[T](handler: TransactionEventHandler[T]): TransactionEventHandler[T] = - delegate.unregisterTransactionEventHandler(handler) - - override def getAllNodes: ResourceIterable[Node] = delegate.getAllNodes - - override def getRelationshipById(id: Long): Relationship = delegate.getRelationshipById(id) - - override def findNode(label: Label, key: String, value: scala.Any): Node = findNode(label, key, value) - - override def execute(query: String): Result = delegate.execute(query) - - override def execute(query: String, parameters: util.Map[String, AnyRef]): Result = - delegate.execute(query, parameters) - - override def unregisterKernelEventHandler(handler: KernelEventHandler): KernelEventHandler = - delegate.unregisterKernelEventHandler(handler) - - override def registerTransactionEventHandler[T](handler: TransactionEventHandler[T]): TransactionEventHandler[T] = - delegate.registerTransactionEventHandler(handler) - - override def getAllRelationshipTypes: ResourceIterable[RelationshipType] = delegate.getAllRelationshipTypes - - override def getAllRelationships: ResourceIterable[Relationship] = delegate.getAllRelationships - - override def getAllPropertyKeys: ResourceIterable[String] = delegate.getAllPropertyKeys - - override def getAllLabels: ResourceIterable[Label] = delegate.getAllLabels - - override def traversalDescription(): TraversalDescription = delegate.traversalDescription() - - override def index(): IndexManager = delegate.index() - - override def getNodeById(id: Long): Node = delegate.getNodeById(id) - - override def isAvailable(timeout: Long): Boolean = delegate.isAvailable(timeout) - - override def schema(): Schema = delegate.schema() - - override def findNodes(label: Label, key: String, value: scala.Any): ResourceIterator[Node] = - delegate.findNodes(label, key, value) - - override def findNodes(label: Label): ResourceIterator[Node] = delegate.findNodes(label) - - override def bidirectionalTraversalDescription(): BidirectionalTraversalDescription = - delegate.bidirectionalTraversalDescription() - - override def beginTx(): Transaction = delegate.beginTx() - - override def getDependencyResolver: DependencyResolver = delegate.getDependencyResolver - - override def storeId(): StoreId = delegate.storeId() - - override def validateURLAccess(url: URL): URL = delegate.validateURLAccess(url) - - override def getStoreDir: String = delegate.getStoreDir } class PausingNode(n: Node, afterGetRelationship: Node => Unit) extends Node { diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/LazyTest.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/LazyTest.scala index bab6db7bc4d80..62601a91f435a 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/LazyTest.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/LazyTest.scala @@ -40,7 +40,7 @@ import org.neo4j.cypher.internal.frontend.v3_0.symbols.CTInteger import org.neo4j.cypher.internal.spi.v3_0.MonoDirectionalTraversalMatcher import org.neo4j.graphdb._ import org.neo4j.helpers.collection.Iterables.asResourceIterable -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.api.{ReadOperations, Statement} import org.neo4j.kernel.configuration.Config import org.neo4j.kernel.impl.api.OperationsFacade @@ -183,7 +183,7 @@ class LazyTest extends ExecutionEngineFunSuite { test("graph global queries are lazy") { //Given: - val fakeGraph = mock[GraphDatabaseAPI] + val fakeGraph = mock[GraphDatabaseQueryService] val tx = mock[Transaction] val nodeManager = mock[NodeManager] val dependencies = mock[DependencyResolver] diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/QueryStateHelper.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/QueryStateHelper.scala index 89303db3741aa..a347b8ba5e464 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/QueryStateHelper.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/QueryStateHelper.scala @@ -22,8 +22,8 @@ package org.neo4j.cypher.internal.compiler.v3_0 import org.neo4j.cypher.internal.compiler.v3_0.pipes.{ExternalCSVResource, NullPipeDecorator, PipeDecorator, QueryState} import org.neo4j.cypher.internal.compiler.v3_0.spi.{QueryContext, UpdateCountingQueryContext} import org.neo4j.cypher.internal.spi.v3_0.TransactionBoundQueryContext.IndexSearchMonitor -import org.neo4j.graphdb.{GraphDatabaseService, Transaction} -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.graphdb.Transaction +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.api.Statement import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge import org.neo4j.kernel.monitoring.{Monitors => KernelMonitors} @@ -34,11 +34,11 @@ import scala.collection.mutable object QueryStateHelper { def empty: QueryState = newWith() - def newWith(db: GraphDatabaseService = null, query: QueryContext = null, resources: ExternalCSVResource = null, - params: Map[String, Any] = Map.empty, decorator: PipeDecorator = NullPipeDecorator) = + def newWith(db: GraphDatabaseQueryService = null, query: QueryContext = null, resources: ExternalCSVResource = null, + params: Map[String, Any] = Map.empty, decorator: PipeDecorator = NullPipeDecorator) = new QueryState(query = query, resources = resources, params = params, decorator = decorator, triadicState = mutable.Map.empty, repeatableReads = mutable.Map.empty) - def queryStateFrom(db: GraphDatabaseAPI, tx: Transaction, params: Map[String, Any] = Map.empty): QueryState = { + def queryStateFrom(db: GraphDatabaseQueryService, tx: Transaction, params: Map[String, Any] = Map.empty): QueryState = { val statement: Statement = db.getDependencyResolver.resolveDependency(classOf[ThreadToStatementContextBridge]).get() val searchMonitor = new KernelMonitors().newMonitor(classOf[IndexSearchMonitor]) val transactionalContext = new TransactionBoundTransactionalContext(db, tx, true, statement) diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/codegen/ir/CodeGenSugar.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/codegen/ir/CodeGenSugar.scala index 562bcc3adf18a..b3abc0f51d460 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/codegen/ir/CodeGenSugar.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/codegen/ir/CodeGenSugar.scala @@ -34,7 +34,7 @@ import org.neo4j.cypher.internal.spi.v3_0.TransactionBoundQueryContext.IndexSear import org.neo4j.cypher.internal.spi.v3_0.{TransactionBoundTransactionalContext, GeneratedQueryStructure, TransactionBoundQueryContext} import org.neo4j.graphdb.GraphDatabaseService import org.neo4j.helpers.Clock -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.api.Statement import org.neo4j.kernel.api.txstate.TxStateHolder import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge @@ -53,7 +53,7 @@ trait CodeGenSugar extends MockitoSugar { } def compileAndExecute(plan: LogicalPlan, - graphDb: GraphDatabaseAPI, + graphDb: GraphDatabaseQueryService, mode: ExecutionMode = NormalMode, params: Map[String, AnyRef] = Map.empty, taskCloser: TaskCloser = new TaskCloser) = { @@ -61,7 +61,7 @@ trait CodeGenSugar extends MockitoSugar { } def executeCompiled(plan: CompiledPlan, - graphDb: GraphDatabaseAPI, + graphDb: GraphDatabaseQueryService, mode: ExecutionMode = NormalMode, params: Map[String, AnyRef] = Map.empty, taskCloser: TaskCloser = new TaskCloser): InternalExecutionResult = { @@ -128,7 +128,7 @@ trait CodeGenSugar extends MockitoSugar { private def mockQueryContext() = { val qc = mock[QueryContext] - val transactionalContext = mock[TransactionalContext[GraphDatabaseAPI, Statement, TxStateHolder]] + val transactionalContext = mock[TransactionalContext[GraphDatabaseQueryService, Statement, TxStateHolder]] val statement = mock[Statement] when(qc.transactionalContext).thenReturn(transactionalContext.asInstanceOf[TransactionalContext[qc.Graph, qc.KernelStatement, qc.StateView]]) when(transactionalContext.statement).thenReturn(statement) diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/codegen/ir/CompiledProfilingTest.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/codegen/ir/CompiledProfilingTest.scala index 712bd35cb3fd9..8029416d7306c 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/codegen/ir/CompiledProfilingTest.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/codegen/ir/CompiledProfilingTest.scala @@ -35,7 +35,8 @@ import org.neo4j.cypher.internal.compiler.v3_0.spi.{TransactionalContext, QueryC import org.neo4j.cypher.internal.frontend.v3_0.ast.SignedDecimalIntegerLiteral import org.neo4j.cypher.internal.frontend.v3_0.symbols import org.neo4j.cypher.internal.frontend.v3_0.test_helpers.CypherFunSuite -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.api._ import org.neo4j.kernel.api.txstate.TxStateHolder import org.neo4j.kernel.impl.core.{NodeManager, NodeProxy} @@ -56,7 +57,7 @@ class CompiledProfilingTest extends CypherFunSuite with CodeGenSugar { val statement = mock[Statement] val queryContext = mock[QueryContext] - val transactionalContext = mock[TransactionalContext[GraphDatabaseAPI,Statement,TxStateHolder]] + val transactionalContext = mock[TransactionalContext[GraphDatabaseQueryService,Statement,TxStateHolder]] when(queryContext.transactionalContext).thenReturn(transactionalContext.asInstanceOf[TransactionalContext[queryContext.Graph, queryContext.KernelStatement, queryContext.StateView]]) when(transactionalContext.statement).thenReturn(statement) @@ -97,7 +98,7 @@ class CompiledProfilingTest extends CypherFunSuite with CodeGenSugar { test("should profile hash join") { //given - val graphDb = new TestGraphDatabaseFactory().newImpermanentDatabase().asInstanceOf[GraphDatabaseAPI] + val graphDb = new GraphDatabaseCypherService(new TestGraphDatabaseFactory().newImpermanentDatabase()) val tx = graphDb.beginTx() graphDb.createNode() graphDb.createNode() diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/pipes/ActualCostCalculationTest.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/pipes/ActualCostCalculationTest.scala index 965fe5f3e452b..3d174db3b4e1b 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/pipes/ActualCostCalculationTest.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/pipes/ActualCostCalculationTest.scala @@ -30,9 +30,11 @@ import org.neo4j.cypher.internal.frontend.v3_0.test_helpers.CypherFunSuite import org.neo4j.cypher.internal.frontend.v3_0.{LabelId, PropertyKeyId, SemanticDirection, ast} import org.neo4j.cypher.internal.spi.v3_0.TransactionBoundQueryContext.IndexSearchMonitor import org.neo4j.cypher.internal.spi.v3_0.{TransactionBoundTransactionalContext, TransactionBoundPlanContext, TransactionBoundQueryContext} +import org.neo4j.cypher.internal.spi.v3_0.{TransactionBoundPlanContext, TransactionBoundQueryContext} +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService import org.neo4j.graphdb._ import org.neo4j.graphdb.factory.GraphDatabaseFactory -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge import scala.collection.mutable @@ -58,7 +60,7 @@ class ActualCostCalculationTest extends CypherFunSuite { ignore("do the test") { val path = Files.createTempDirectory("apa").toFile.getAbsolutePath - val graph: GraphDatabaseService = new GraphDatabaseFactory().newEmbeddedDatabase(new File(path)) + val graph: GraphDatabaseQueryService = new GraphDatabaseCypherService(new GraphDatabaseFactory().newEmbeddedDatabase(new File(path))) try { graph.createIndex(LABEL, PROPERTY) val results = ResultTable.empty @@ -84,7 +86,7 @@ class ActualCostCalculationTest extends CypherFunSuite { ignore("cost for eagerness") { val path = Files.createTempDirectory("apa").toFile.getAbsolutePath - val graph: GraphDatabaseService = new GraphDatabaseFactory().newEmbeddedDatabase(new File(path)) + val graph: GraphDatabaseQueryService = new GraphDatabaseCypherService(new GraphDatabaseFactory().newEmbeddedDatabase(new File(path))) try { graph.createIndex(LABEL, PROPERTY) val results = ResultTable.empty @@ -110,7 +112,7 @@ class ActualCostCalculationTest extends CypherFunSuite { ignore("hash joins") { val path = Files.createTempDirectory("apa").toFile.getAbsolutePath - val graph: GraphDatabaseService = new GraphDatabaseFactory().newEmbeddedDatabase(new File(path)) + val graph: GraphDatabaseQueryService = new GraphDatabaseCypherService(new GraphDatabaseFactory().newEmbeddedDatabase(new File(path))) val labels = Seq("A", "B", "C", "D", "E", "F", "G", "H", "I", "J") val x = ListBuffer.empty[Array[Double]] val y = ListBuffer.empty[Double] @@ -179,7 +181,7 @@ class ActualCostCalculationTest extends CypherFunSuite { override def toString: String = s"$numberOfRows, $elapsed" } - private def expandResult(graph: GraphDatabaseService) = { + private def expandResult(graph: GraphDatabaseQueryService) = { val scan = labelScan val scanCost = medianPerRowCount(runSimulation(graph, scan)).head val simulation = runSimulation(graph, expand(scan, RELATIONSHIP)).map(_.subtractTime(scanCost.elapsed)) @@ -215,15 +217,15 @@ class ActualCostCalculationTest extends CypherFunSuite { sorted(values.size / 2) } - private def runSimulation(graph: GraphDatabaseService, pipe: Pipe): Seq[DataPoint] = + private def runSimulation(graph: GraphDatabaseQueryService, pipe: Pipe): Seq[DataPoint] = runSimulation(graph, Seq(pipe)) //executes the provided pipes and returns execution times - private def runSimulation(graph: GraphDatabaseService, pipes: Seq[Pipe]) = { + private def runSimulation(graph: GraphDatabaseQueryService, pipes: Seq[Pipe]) = { val results = new ListBuffer[DataPoint] graph.withTx { tx => - val transactionalContext = new TransactionBoundTransactionalContext(graph.asInstanceOf[GraphDatabaseAPI], tx, true, graph.statement) + val transactionalContext = new TransactionBoundTransactionalContext(graph, tx, true, graph.statement) val queryContext = new TransactionBoundQueryContext(transactionalContext)(mock[IndexSearchMonitor]) val state = QueryStateHelper.emptyWith(queryContext) for (x <- 0 to 25) { @@ -241,7 +243,7 @@ class ActualCostCalculationTest extends CypherFunSuite { results.sortBy(_.elapsed).slice(5, results.size - 5) } - private def setUpDb(graph: GraphDatabaseService, chunkSize: Int) { + private def setUpDb(graph: GraphDatabaseQueryService, chunkSize: Int) { graph.withTx { _ => for (i <- 1 to chunkSize) { val node = graph.createNode(LABEL) @@ -253,7 +255,7 @@ class ActualCostCalculationTest extends CypherFunSuite { } //create a database where each subsequent label is more frequent - private def setupDbForJoins(graph: GraphDatabaseService, labels: Seq[String]) = { + private def setupDbForJoins(graph: GraphDatabaseQueryService, labels: Seq[String]) = { val nLabels = labels.size //divide so that each subsequent label is more frequent, //e.g. [100, 200, 300,...] with 100 + 200 + 300 ~ N @@ -282,7 +284,7 @@ class ActualCostCalculationTest extends CypherFunSuite { private def eager(pipe: Pipe) = new EagerPipe(pipe)() - private def indexSeek(graph: GraphDatabaseService) = { + private def indexSeek(graph: GraphDatabaseQueryService) = { graph.withTx { _ => val ctx = new TransactionBoundPlanContext(graph.statement, graph) val literal = Literal(42) @@ -296,11 +298,12 @@ class ActualCostCalculationTest extends CypherFunSuite { } } - implicit class RichGraph(graph: GraphDatabaseService) { - def statement = graph.asInstanceOf[GraphDatabaseAPI].getDependencyResolver.resolveDependency(classOf[ThreadToStatementContextBridge]).get() + implicit class RichGraph(mad: GraphDatabaseQueryService) { + def statement = mad.getDependencyResolver.resolveDependency(classOf[ThreadToStatementContextBridge]).get() + val graph = mad.getGraphDatabaseService def withTx[T](f: Transaction => T): T = { - val tx = graph.beginTx() + val tx = mad.beginTx() try { val result = f(tx) tx.success() @@ -310,12 +313,16 @@ class ActualCostCalculationTest extends CypherFunSuite { } } + def shutdown() = graph.shutdown() + + def createNode(label: Label) = graph.createNode(label) + def createIndex(label: Label, propertyName: String) = { - graph.withTx { _ => + mad.withTx { _ => graph.schema().indexFor(label).on(propertyName).create() } - graph.withTx { _ => + mad.withTx { _ => graph.schema().awaitIndexesOnline(10, TimeUnit.SECONDS) } } diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/helpers/GraphIcing.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/helpers/GraphIcing.scala index 830e74d6bebdf..643018260f672 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/helpers/GraphIcing.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/helpers/GraphIcing.scala @@ -19,11 +19,12 @@ */ package org.neo4j.cypher.internal.helpers +import java.util import java.util.concurrent.TimeUnit import org.neo4j.graphdb.Label._ import org.neo4j.graphdb._ -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.api.Statement import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge import org.neo4j.kernel.impl.transaction.TransactionStats @@ -40,10 +41,27 @@ trait GraphIcing { } } - implicit class RichGraphDatabaseService(graph: GraphDatabaseService) - extends RichGraphDatabaseAPI(graph.asInstanceOf[GraphDatabaseAPI]) + implicit class RichGraphDatabaseAPI(mad: GraphDatabaseQueryService) { - implicit class RichGraphDatabaseAPI(graph: GraphDatabaseAPI) { + var graph = mad.getGraphDatabaseService + + def getAllNodes() = graph.getAllNodes + + def getAllRelationships() = graph.getAllRelationships + + def getAllRelationshipTypes() = graph.getAllRelationshipTypes + + def index() = graph.index + + def schema() = graph.schema + + def shutdown() = graph.shutdown() + + def createNode(label: Label) = graph.createNode(label) + + def execute(query: String) = graph.execute(query) + + def execute(query: String, params: util.HashMap[String, Object]) = graph.execute(query, params) def indexPropsForLabel(label: String): List[List[String]] = { val indexDefs = graph.schema.getIndexes(Label.label(label)).asScala.toList diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundQueryContextTest.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundQueryContextTest.scala index ac32dc34459f7..77e3a4eb2767b 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundQueryContextTest.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundQueryContextTest.scala @@ -26,10 +26,11 @@ import org.neo4j.cypher.internal.compiler.v3_0.helpers.DynamicIterable import org.neo4j.cypher.internal.frontend.v3_0.SemanticDirection import org.neo4j.cypher.internal.frontend.v3_0.test_helpers.CypherFunSuite import org.neo4j.cypher.internal.spi.v3_0.TransactionBoundQueryContext.IndexSearchMonitor +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService import org.neo4j.graphdb._ import org.neo4j.graphdb.config.Setting import org.neo4j.graphdb.factory.GraphDatabaseSettings -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.api._ import org.neo4j.kernel.impl.api.{KernelStatement, KernelTransactionImplementation} import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge @@ -40,20 +41,20 @@ import scala.collection.JavaConverters._ class TransactionBoundQueryContextTest extends CypherFunSuite { - var graph: GraphDatabaseAPI = null + var graph: GraphDatabaseQueryService = null var outerTx: Transaction = null var statement: Statement = null val indexSearchMonitor = mock[IndexSearchMonitor] override def beforeEach() { super.beforeEach() - graph = new TestGraphDatabaseFactory().newImpermanentDatabase().asInstanceOf[GraphDatabaseAPI] + graph = new GraphDatabaseCypherService(new TestGraphDatabaseFactory().newImpermanentDatabase()) outerTx = mock[Transaction] statement = new KernelStatement(mock[KernelTransactionImplementation], null, null, null, null, new Procedures()) } override def afterEach() { - graph.shutdown() + graph.getGraphDatabaseService.shutdown() } test ("should_mark_transaction_successful_if_successful") { @@ -127,9 +128,9 @@ class TransactionBoundQueryContextTest extends CypherFunSuite { test ("should deny file URLs when not allowed by config") { // GIVEN - graph.shutdown() + graph.getGraphDatabaseService.shutdown() val config = Map[Setting[_], String](GraphDatabaseSettings.allow_file_urls -> "false") - graph = new TestGraphDatabaseFactory().newImpermanentDatabase(config.asJava).asInstanceOf[GraphDatabaseAPI] + graph = new GraphDatabaseCypherService(new TestGraphDatabaseFactory().newImpermanentDatabase(config.asJava)) val tx = graph.beginTx() val stmt = graph.getDependencyResolver.resolveDependency(classOf[ThreadToStatementContextBridge]).get() val transactionalContext = new TransactionBoundTransactionalContext(graph, outerTx, isTopLevelTx = true, stmt) diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/performance/PerformanceTest.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/performance/PerformanceTest.scala index a45766186aba9..bebfde797a257 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/performance/PerformanceTest.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/performance/PerformanceTest.scala @@ -21,25 +21,27 @@ package org.neo4j.cypher.performance import org.neo4j.cypher.internal.ExecutionEngine import org.neo4j.cypher.internal.frontend.v3_0.test_helpers.CypherFunSuite +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService import org.neo4j.graphdb.factory.GraphDatabaseFactory -import org.neo4j.graphdb.{GraphDatabaseService, Node, RelationshipType} +import org.neo4j.graphdb.{Node, RelationshipType} +import org.neo4j.kernel.GraphDatabaseQueryService import scala.util.Random class PerformanceTest extends CypherFunSuite { val r = new Random() - var db: GraphDatabaseService = null + var db: GraphDatabaseQueryService = null var engine: ExecutionEngine = null override def beforeEach() { super.beforeEach() - db = new GraphDatabaseFactory().newEmbeddedDatabase("target/db"); + db = new GraphDatabaseCypherService(new GraphDatabaseFactory().newEmbeddedDatabase("target/db")) engine = new ExecutionEngine(db) } override def afterEach() { - db.shutdown() + db.getGraphDatabaseService.shutdown() super.afterEach() } diff --git a/enterprise/kernel/src/test/scala/org/neo4j/cypher/EnterpriseGraphDatabaseTestSupport.scala b/enterprise/kernel/src/test/scala/org/neo4j/cypher/EnterpriseGraphDatabaseTestSupport.scala index f5ff5720f2ec2..6dfe3d8d051ca 100644 --- a/enterprise/kernel/src/test/scala/org/neo4j/cypher/EnterpriseGraphDatabaseTestSupport.scala +++ b/enterprise/kernel/src/test/scala/org/neo4j/cypher/EnterpriseGraphDatabaseTestSupport.scala @@ -20,13 +20,14 @@ package org.neo4j.cypher import org.neo4j.cypher.internal.frontend.v3_0.test_helpers.CypherFunSuite -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.test.TestEnterpriseGraphDatabaseFactory trait EnterpriseGraphDatabaseTestSupport extends GraphDatabaseTestSupport { self: CypherFunSuite => - override protected def createGraphDatabase(): GraphDatabaseAPI = { - new TestEnterpriseGraphDatabaseFactory().newImpermanentDatabase().asInstanceOf[GraphDatabaseAPI] + override protected def createGraphDatabase(): GraphDatabaseQueryService = { + new GraphDatabaseCypherService(new TestEnterpriseGraphDatabaseFactory().newImpermanentDatabase()) } } diff --git a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/ArticleTest.scala b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/ArticleTest.scala index 8eb01ab20b21a..3176f76f713a5 100644 --- a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/ArticleTest.scala +++ b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/ArticleTest.scala @@ -24,13 +24,14 @@ import java.io.{File, PrintWriter, StringWriter} import org.junit.Test import org.neo4j.cypher._ import org.neo4j.cypher.export.{DatabaseSubGraph, SubGraphExporter} +import org.neo4j.cypher.internal.{ExecutionEngine, RewindableExecutionResult} import org.neo4j.cypher.internal.compiler.v3_0.executionplan.InternalExecutionResult import org.neo4j.cypher.internal.compiler.v3_0.prettifier.Prettifier import org.neo4j.cypher.internal.javacompat.GraphImpl -import org.neo4j.cypher.internal.{ExecutionEngine, RewindableExecutionResult} +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService import org.neo4j.graphdb._ import org.neo4j.graphdb.index.Index -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.test.GraphDatabaseServiceCleaner.cleanDatabaseContent import org.neo4j.test.{AsciiDocGenerator, GraphDescription, TestGraphDatabaseFactory} import org.neo4j.visualization.asciidoc.AsciidocHelper @@ -43,7 +44,7 @@ Use this base class for tests that are more flowing text with queries intersecte */ abstract class ArticleTest extends Assertions with DocumentationHelper { - var db: GraphDatabaseAPI = null + var db: GraphDatabaseQueryService = null implicit var engine: ExecutionEngine = null var nodes: Map[String, Long] = null var nodeIndex: Index[Node] = null @@ -123,9 +124,9 @@ abstract class ArticleTest extends Assertions with DocumentationHelper { if (emptyGraph) { val db = new TestGraphDatabaseFactory(). newImpermanentDatabaseBuilder(). - newGraphDatabase().asInstanceOf[GraphDatabaseAPI] + newGraphDatabase() try { - val engine = new ExecutionEngine(db) + val engine = new ExecutionEngine(new GraphDatabaseCypherService(db)) val result = executeQuery(query)(engine) testAssertions(result) result.dumpToString() @@ -146,7 +147,7 @@ abstract class ArticleTest extends Assertions with DocumentationHelper { val create = if (!empty) { db.inTx { val out = new StringWriter() - new SubGraphExporter(DatabaseSubGraph.from(db)).export(new PrintWriter(out)) + new SubGraphExporter(DatabaseSubGraph.from(db.getGraphDatabaseService)).export(new PrintWriter(out)) out.toString } } else "match n-[r?]->() delete n, r;" @@ -220,11 +221,11 @@ abstract class ArticleTest extends Assertions with DocumentationHelper { private def init() = { dir = createDir(section) - db = new TestGraphDatabaseFactory(). + db = new GraphDatabaseCypherService(new TestGraphDatabaseFactory(). newImpermanentDatabaseBuilder(). - newGraphDatabase().asInstanceOf[GraphDatabaseAPI] + newGraphDatabase()) - cleanDatabaseContent( db.asInstanceOf[GraphDatabaseService] ) + cleanDatabaseContent( db.getGraphDatabaseService ) db.inTx { nodeIndex = db.index().forNodes("nodes") @@ -232,7 +233,7 @@ abstract class ArticleTest extends Assertions with DocumentationHelper { val g = new GraphImpl(graphDescription.toArray[String]) val description = GraphDescription.create(g) - nodes = description.create(db).asScala.map { + nodes = description.create(db.getGraphDatabaseService).asScala.map { case (name, node) => name -> node.getId }.toMap diff --git a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/CallTest.scala b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/CallTest.scala index b9e0286edd8f4..83529223b3dc2 100644 --- a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/CallTest.scala +++ b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/CallTest.scala @@ -22,7 +22,7 @@ package org.neo4j.cypher.docgen import org.junit.Test import org.neo4j.cypher.QueryStatisticsTestSupport import org.neo4j.graphdb.{Label, Node} -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.impl.proc.Procedures import org.neo4j.procedure.example.IndexingProcedure diff --git a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/CreateTest.scala b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/CreateTest.scala index 17849272137eb..7193cca351814 100644 --- a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/CreateTest.scala +++ b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/CreateTest.scala @@ -22,7 +22,7 @@ package org.neo4j.cypher.docgen import org.junit.Test import org.neo4j.cypher.QueryStatisticsTestSupport import org.neo4j.graphdb.{Label, Node, Relationship} -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService class CreateTest extends DocumentingTestBase with QueryStatisticsTestSupport with SoftReset { @@ -82,7 +82,7 @@ class CreateTest extends DocumentingTestBase with QueryStatisticsTestSupport wit assertions = (p) => assert(p.size === 1)) } - def createTwoPersonNodesWithNames(db: GraphDatabaseAPI) = { + def createTwoPersonNodesWithNames(db: GraphDatabaseQueryService) = { db.inTx { db.createNode(Label.label("Person")).setProperty("name", "Node A") db.createNode(Label.label("Person")).setProperty("name", "Node B") @@ -101,7 +101,7 @@ class CreateTest extends DocumentingTestBase with QueryStatisticsTestSupport wit } @Test def set_property_to_a_collection() { - val createTwoNodesWithProperty = (db: GraphDatabaseAPI) => db.inTx { + val createTwoNodesWithProperty = (db: GraphDatabaseQueryService) => db.inTx { db.createNode().setProperty("name", "Andres") db.createNode().setProperty("name", "Michael") } diff --git a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/DocumentingTestBase.scala b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/DocumentingTestBase.scala index 5bee6f665e195..6ef3d8c481b7a 100644 --- a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/DocumentingTestBase.scala +++ b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/DocumentingTestBase.scala @@ -33,10 +33,11 @@ import org.neo4j.cypher.internal.frontend.v3_0.helpers.Eagerly import org.neo4j.cypher.internal.helpers.GraphIcing import org.neo4j.cypher.internal.javacompat.GraphImpl import org.neo4j.cypher.internal.{ExecutionEngine, RewindableExecutionResult} +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService import org.neo4j.graphdb._ import org.neo4j.graphdb.factory.GraphDatabaseSettings import org.neo4j.graphdb.index.Index -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.configuration.Settings import org.neo4j.kernel.impl.api.KernelStatement import org.neo4j.kernel.impl.api.index.IndexingService @@ -52,10 +53,9 @@ import org.scalatest.junit.JUnitSuite import scala.collection.JavaConverters._ import scala.reflect.ClassTag - trait DocumentationHelper extends GraphIcing { def generateConsole: Boolean - def db: GraphDatabaseAPI + def db: GraphDatabaseQueryService def niceify(in: String): String = in.toLowerCase.replace(" ", "-") @@ -129,7 +129,7 @@ trait DocumentationHelper extends GraphIcing { val writer = new GraphvizWriter(getGraphvizStyle) db.inTx { - writer.emit(out, Walker.fullGraph(db)) + writer.emit(out, Walker.fullGraph(db.getGraphDatabaseService)) } val graphOutput = """["dot", "%s.svg", "neoviz", "%s"] @@ -157,7 +157,7 @@ abstract class DocumentingTestBase extends JUnitSuite with DocumentationHelper w } def prepareAndTestQuery(title: String, text: String, queryText: String, optionalResultExplanation: String = "", - prepare: GraphDatabaseAPI => Unit, assertions: InternalExecutionResult => Unit) { + prepare: GraphDatabaseQueryService => Unit, assertions: InternalExecutionResult => Unit) { internalTestQuery(title, text, queryText, optionalResultExplanation, None, Some(prepare), Map.empty, assertions) } @@ -170,7 +170,7 @@ abstract class DocumentingTestBase extends JUnitSuite with DocumentationHelper w queryText: String, realQuery: Option[String], expectedException: Option[ClassTag[_ <: CypherException]], - prepare: Option[GraphDatabaseAPI => Unit], + prepare: Option[GraphDatabaseQueryService => Unit], assertions: InternalExecutionResult => Unit) { preparationQueries = List() @@ -238,7 +238,7 @@ abstract class DocumentingTestBase extends JUnitSuite with DocumentationHelper w queryText: String, optionalResultExplanation: String, expectedException: Option[ClassTag[_ <: CypherException]], - prepare: Option[GraphDatabaseAPI => Unit], + prepare: Option[GraphDatabaseQueryService => Unit], parameters: Map[String, Any], assertions: InternalExecutionResult => Unit) { @@ -255,7 +255,7 @@ abstract class DocumentingTestBase extends JUnitSuite with DocumentationHelper w if (generateInitialGraphForConsole) { val out = new StringWriter() db.inTx { - new SubGraphExporter(DatabaseSubGraph.from(db)).export(new PrintWriter(out)) + new SubGraphExporter(DatabaseSubGraph.from(db.getGraphDatabaseService)).export(new PrintWriter(out)) consoleData = out.toString } } @@ -286,9 +286,9 @@ abstract class DocumentingTestBase extends JUnitSuite with DocumentationHelper w } } - def prepareForTest(title: String, prepare: Option[GraphDatabaseAPI => Unit]) { + def prepareForTest(title: String, prepare: Option[GraphDatabaseQueryService => Unit]) { prepare.foreach { - (prepareStep: GraphDatabaseAPI => Any) => prepareStep(db) + (prepareStep: GraphDatabaseQueryService => Any) => prepareStep(db) } if (preparationQueries.nonEmpty) { dumpPreparationQueries(preparationQueries, dir, title) @@ -330,7 +330,7 @@ abstract class DocumentingTestBase extends JUnitSuite with DocumentationHelper w results.headOption } - var db: GraphDatabaseAPI = null + var db: GraphDatabaseQueryService = null var engine: ExecutionEngine = null var nodeMap: Map[String, Long] = null var nodeIndex: Index[Node] = null @@ -441,17 +441,17 @@ abstract class DocumentingTestBase extends JUnitSuite with DocumentationHelper w override def hardReset() { tearDown() - db = newTestGraphDatabaseFactory().newImpermanentDatabaseBuilder(). + db = new GraphDatabaseCypherService(newTestGraphDatabaseFactory().newImpermanentDatabaseBuilder(). setConfig(GraphDatabaseSettings.node_keys_indexable, "name"). setConfig(GraphDatabaseSettings.node_auto_indexing, Settings.TRUE). - newGraphDatabase().asInstanceOf[GraphDatabaseAPI] + newGraphDatabase()) engine = new ExecutionEngine(db) softReset() } override def softReset() { - cleanDatabaseContent(db) + cleanDatabaseContent(db.getGraphDatabaseService) db.inTx { db.schema().awaitIndexesOnline(10, TimeUnit.SECONDS) @@ -462,7 +462,7 @@ abstract class DocumentingTestBase extends JUnitSuite with DocumentationHelper w val description = GraphDescription.create(g) - nodeMap = description.create(db).asScala.map { + nodeMap = description.create(db.getGraphDatabaseService).asScala.map { case (name, node) => name -> node.getId }.toMap diff --git a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/StartTest.scala b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/StartTest.scala index 5d514fcb869ed..dc14ba25bb167 100644 --- a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/StartTest.scala +++ b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/StartTest.scala @@ -21,7 +21,7 @@ package org.neo4j.cypher.docgen import org.junit.Assert.assertEquals import org.junit.Test -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService class StartTest extends DocumentingTestBase { override def graphDescription = List("A KNOWS B", "A KNOWS C") @@ -41,7 +41,7 @@ class StartTest extends DocumentingTestBase { @Test def relationships_by_index() { generateConsole = false - val setPropertyAndUpdateLegacyIndex = (db: GraphDatabaseAPI) => db.inTx { + val setPropertyAndUpdateLegacyIndex = (db: GraphDatabaseQueryService) => db.inTx { val r = db.getRelationshipById(0) val property = "name" val value = "Andrés" diff --git a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/Document.scala b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/Document.scala index c59476771e457..6badf7d05c495 100644 --- a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/Document.scala +++ b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/Document.scala @@ -22,7 +22,7 @@ package org.neo4j.cypher.docgen.tooling import org.neo4j.cypher.internal.compiler.v3_0.executionplan.InternalExecutionResult import org.neo4j.cypher.internal.compiler.v3_0.prettifier.Prettifier import org.neo4j.cypher.internal.frontend.v3_0.InternalException -import org.neo4j.graphdb.GraphDatabaseService +import org.neo4j.kernel.GraphDatabaseQueryService case class ContentWithInit(init: Seq[String], queryResultPlaceHolder: QueryResultPlaceHolder) { @@ -260,7 +260,7 @@ sealed trait QueryAssertions case class ResultAssertions(f: InternalExecutionResult => Unit) extends QueryAssertions -case class ResultAndDbAssertions(f: (InternalExecutionResult, GraphDatabaseService) => Unit) extends QueryAssertions +case class ResultAndDbAssertions(f: (InternalExecutionResult, GraphDatabaseQueryService) => Unit) extends QueryAssertions case object NoAssertions extends QueryAssertions diff --git a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/DocumentingTest.scala b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/DocumentingTest.scala index e785aafaafb9a..53c9c7a339475 100644 --- a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/DocumentingTest.scala +++ b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/DocumentingTest.scala @@ -26,7 +26,7 @@ import org.neo4j.cypher.internal.helpers.GraphIcing import org.neo4j.cypher.internal.spi.v3_0.{TransactionBoundTransactionalContext, TransactionBoundQueryContext} import org.neo4j.cypher.internal.spi.v3_0.TransactionBoundQueryContext.IndexSearchMonitor import org.neo4j.graphdb.{GraphDatabaseService, Transaction} -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.api.index.IndexDescriptor import org.scalatest.{Assertions, Matchers} @@ -106,7 +106,7 @@ trait DocumentingTest extends CypherFunSuite with Assertions with Matchers with } private def runQueries(doc: Document): TestRunResult = { - val builder = (db: GraphDatabaseService, tx: Transaction) => new QueryResultContentBuilder(new ValueFormatter(db, tx)) + val builder = (db: GraphDatabaseQueryService, tx: Transaction) => new QueryResultContentBuilder(new ValueFormatter(db, tx)) val runner = new QueryRunner(builder) val result = runner.runQueries(contentsWithInit = doc.contentWithQueries, doc.title) @@ -116,9 +116,9 @@ trait DocumentingTest extends CypherFunSuite with Assertions with Matchers with // Used to format values coming from Cypher. Maps, collections, nodes, relationships and paths all have custom // formatting applied to them -class ValueFormatter(db: GraphDatabaseService, tx: Transaction) extends (Any => String) with CypherSerializer with GraphIcing { +class ValueFormatter(db: GraphDatabaseQueryService, tx: Transaction) extends (Any => String) with CypherSerializer with GraphIcing { def apply(x: Any): String = { - val transactionalContext = new TransactionBoundTransactionalContext(db.asInstanceOf[GraphDatabaseAPI], tx, true, db.statement) + val transactionalContext = new TransactionBoundTransactionalContext(db, tx, true, db.statement) val ctx = new TransactionBoundQueryContext(transactionalContext)(QuietMonitor) serialize(x, ctx) } diff --git a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/QueryRunner.scala b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/QueryRunner.scala index 42dbadaed0496..6d01dcfb287b5 100644 --- a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/QueryRunner.scala +++ b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/QueryRunner.scala @@ -23,7 +23,8 @@ import org.neo4j.cypher.internal.RewindableExecutionResult import org.neo4j.cypher.internal.compiler.v3_0.executionplan.InternalExecutionResult import org.neo4j.cypher.internal.frontend.v3_0.InternalException import org.neo4j.cypher.internal.helpers.GraphIcing -import org.neo4j.graphdb.{GraphDatabaseService, Transaction} +import org.neo4j.graphdb.Transaction +import org.neo4j.kernel.GraphDatabaseQueryService import scala.collection.immutable.Iterable import scala.util.{Failure, Success, Try} @@ -37,7 +38,7 @@ import scala.util.{Failure, Success, Try} * we drop the database and create a new one. This way we can make sure that two queries don't affect each other more than * necessary. */ -class QueryRunner(formatter: (GraphDatabaseService, Transaction) => InternalExecutionResult => Content) extends GraphIcing { +class QueryRunner(formatter: (GraphDatabaseQueryService, Transaction) => InternalExecutionResult => Content) extends GraphIcing { def runQueries(contentsWithInit: Seq[ContentWithInit], title: String): TestRunResult = { diff --git a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/RestartableDatabase.scala b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/RestartableDatabase.scala index ee2227bda876e..1ede3d3928b01 100644 --- a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/RestartableDatabase.scala +++ b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/RestartableDatabase.scala @@ -39,14 +39,15 @@ package org.neo4j.cypher.docgen.tooling * along with this program. If not, see . */ import org.neo4j.cypher.internal.ExecutionEngine -import org.neo4j.graphdb.GraphDatabaseService +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.test.TestGraphDatabaseFactory import scala.util.Try /* I exist so my users can have a restartable database that is lazily created */ class RestartableDatabase(init: Seq[String], factory: TestGraphDatabaseFactory = new TestGraphDatabaseFactory()) { - private var _db: GraphDatabaseService = null + private var _db: GraphDatabaseQueryService = null private var _engine: ExecutionEngine = null private var _failures: Seq[QueryRunResult] = null private var _markedForRestart = false @@ -58,7 +59,7 @@ class RestartableDatabase(init: Seq[String], factory: TestGraphDatabaseFactory = private def createAndStartIfNecessary() { if (_db == null) { - _db = factory.newImpermanentDatabase() + _db = new GraphDatabaseCypherService(factory.newImpermanentDatabase()) _engine = new ExecutionEngine(_db) _failures = initialize(_engine, init) } @@ -91,7 +92,7 @@ class RestartableDatabase(init: Seq[String], factory: TestGraphDatabaseFactory = private def restart() { if (_db == null) return - _db.shutdown() + _db.getGraphDatabaseService.shutdown() _db = null _markedForRestart = false } diff --git a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/captureStateAsGraphViz.scala b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/captureStateAsGraphViz.scala index 464a7437bf163..a67ec1f0d37eb 100644 --- a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/captureStateAsGraphViz.scala +++ b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/captureStateAsGraphViz.scala @@ -23,7 +23,7 @@ import java.io.ByteArrayOutputStream import org.neo4j.cypher.internal.frontend.v3_0._ import org.neo4j.cypher.internal.helpers.GraphIcing -import org.neo4j.graphdb.GraphDatabaseService +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.visualization.graphviz.{AsciiDocSimpleStyle, GraphvizWriter} import org.neo4j.walk.Walker @@ -33,14 +33,14 @@ import org.neo4j.walk.Walker */ object captureStateAsGraphViz extends GraphIcing { - def apply(db: GraphDatabaseService, name: String, count: Int, options: String): GraphViz = GraphViz(emitGraphviz(s"$name-$count", options, db)) + def apply(db: GraphDatabaseQueryService, name: String, count: Int, options: String): GraphViz = GraphViz(emitGraphviz(s"$name-$count", options, db)) - private def emitGraphviz(testid: String, graphVizOptions: String, db: GraphDatabaseService): String = { + private def emitGraphviz(testid: String, graphVizOptions: String, db: GraphDatabaseQueryService): String = { val out = new ByteArrayOutputStream() val writer = new GraphvizWriter(AsciiDocSimpleStyle.withAutomaticRelationshipTypeColors()) db.inTx { - writer.emit(out, Walker.fullGraph(db)) + writer.emit(out, Walker.fullGraph(db.getGraphDatabaseService)) } """.Graph diff --git a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/tests/QueryResultContentBuilderTest.scala b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/tests/QueryResultContentBuilderTest.scala index 3e32afe8b1773..b95d95e30ffe1 100644 --- a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/tests/QueryResultContentBuilderTest.scala +++ b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/tests/QueryResultContentBuilderTest.scala @@ -23,6 +23,7 @@ import org.neo4j.cypher.internal.ExecutionEngine import org.neo4j.cypher.docgen.tooling._ import org.neo4j.cypher.internal.RewindableExecutionResult import org.neo4j.cypher.internal.frontend.v3_0.test_helpers.CypherFunSuite +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService import org.neo4j.test.TestGraphDatabaseFactory class QueryResultContentBuilderTest extends CypherFunSuite { @@ -44,7 +45,7 @@ class QueryResultContentBuilderTest extends CypherFunSuite { def runQuery(query: String, init: String = ""): Content = { val db = new TestGraphDatabaseFactory().newImpermanentDatabase() if (init != "") db.execute(init) - val engine = new ExecutionEngine(db) + val engine = new ExecutionEngine(new GraphDatabaseCypherService(db)) val builder = new QueryResultContentBuilder(x => x.toString) val queryResult = RewindableExecutionResult(engine.execute(query)) diff --git a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/tests/QueryRunnerTest.scala b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/tests/QueryRunnerTest.scala index c39d98ba9cda4..379323289dfde 100644 --- a/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/tests/QueryRunnerTest.scala +++ b/manual/cypher/cypher-docs/src/test/scala/org/neo4j/cypher/docgen/tooling/tests/QueryRunnerTest.scala @@ -24,6 +24,7 @@ import org.neo4j.cypher.docgen.tooling._ import org.neo4j.cypher.internal.compiler.v3_0.executionplan.InternalExecutionResult import org.neo4j.cypher.internal.frontend.v3_0.test_helpers.CypherFunSuite import org.neo4j.graphdb.{GraphDatabaseService, Transaction} +import org.neo4j.kernel.GraphDatabaseQueryService import org.scalatest.exceptions.TestFailedException import org.scalatest.matchers.{MatchResult, Matcher} @@ -57,7 +58,7 @@ class QueryRunnerTest extends CypherFunSuite { run(Seq(query), new TablePlaceHolder(assertions)) private def run(initQueries: Seq[String], content: QueryResultPlaceHolder): TestRunResult = { - val formatter = (_: GraphDatabaseService, _: Transaction) => (_: InternalExecutionResult) => NoContent + val formatter = (_: GraphDatabaseQueryService, _: Transaction) => (_: InternalExecutionResult) => NoContent val runner = new QueryRunner(formatter) runner.runQueries(contentsWithInit = Seq(ContentWithInit(initQueries, content)), "title") } diff --git a/manual/cypher/graphgist/src/main/java/org/neo4j/cypher/javacompat/internal/DocsExecutionEngine.java b/manual/cypher/graphgist/src/main/java/org/neo4j/cypher/javacompat/internal/DocsExecutionEngine.java index 0d6c8cea78252..b747c1deb63db 100644 --- a/manual/cypher/graphgist/src/main/java/org/neo4j/cypher/javacompat/internal/DocsExecutionEngine.java +++ b/manual/cypher/graphgist/src/main/java/org/neo4j/cypher/javacompat/internal/DocsExecutionEngine.java @@ -24,7 +24,7 @@ import org.neo4j.cypher.CypherException; import org.neo4j.cypher.internal.compiler.v3_0.executionplan.InternalExecutionResult; -import org.neo4j.graphdb.GraphDatabaseService; +import org.neo4j.kernel.GraphDatabaseQueryService; import org.neo4j.logging.LogProvider; import org.neo4j.logging.NullLogProvider; @@ -39,7 +39,7 @@ public class DocsExecutionEngine * Creates an execution engine around the give graph database * @param database The database to wrap */ - public DocsExecutionEngine( GraphDatabaseService database ) + public DocsExecutionEngine( GraphDatabaseQueryService database ) { this( database, NullLogProvider.getInstance() ); } @@ -50,13 +50,13 @@ public DocsExecutionEngine( GraphDatabaseService database ) * @param database The database to wrap * @param logProvider A Log provider for cypher-statements */ - public DocsExecutionEngine( GraphDatabaseService database, LogProvider logProvider ) + public DocsExecutionEngine( GraphDatabaseQueryService database, LogProvider logProvider ) { inner = (org.neo4j.cypher.internal.DocsExecutionEngine) createInnerEngine( database, logProvider ); } - protected - org.neo4j.cypher.internal.ExecutionEngine createInnerEngine( GraphDatabaseService database, LogProvider logProvider ) + protected org.neo4j.cypher.internal.ExecutionEngine createInnerEngine( GraphDatabaseQueryService database, + LogProvider logProvider ) { return new org.neo4j.cypher.internal.DocsExecutionEngine( database, logProvider, null, null ); } diff --git a/manual/cypher/graphgist/src/main/java/org/neo4j/doc/cypherdoc/BlockType.java b/manual/cypher/graphgist/src/main/java/org/neo4j/doc/cypherdoc/BlockType.java index 4423a4a56a286..75d93a0483311 100644 --- a/manual/cypher/graphgist/src/main/java/org/neo4j/doc/cypherdoc/BlockType.java +++ b/manual/cypher/graphgist/src/main/java/org/neo4j/doc/cypherdoc/BlockType.java @@ -304,7 +304,7 @@ String process( Block block, State state ) prettifiedStatements.add( state.engine.prettify( webQuery ) ); try (Transaction tx = state.database.beginTx()) { - state.database.schema().awaitIndexesOnline( 10000, TimeUnit.SECONDS ); + state.database.getGraphDatabaseService().schema().awaitIndexesOnline( 10000, TimeUnit.SECONDS ); tx.success(); } } @@ -457,7 +457,7 @@ else if ( id.startsWith( "_result" ) ) } else { - writer.emit( out, Walker.fullGraph( state.database ) ); + writer.emit( out, Walker.fullGraph( state.database.getGraphDatabaseService() ) ); } tx.success(); } diff --git a/manual/cypher/graphgist/src/main/java/org/neo4j/doc/cypherdoc/CypherDoc.java b/manual/cypher/graphgist/src/main/java/org/neo4j/doc/cypherdoc/CypherDoc.java index 148781eaf9df7..c126c176ac121 100644 --- a/manual/cypher/graphgist/src/main/java/org/neo4j/doc/cypherdoc/CypherDoc.java +++ b/manual/cypher/graphgist/src/main/java/org/neo4j/doc/cypherdoc/CypherDoc.java @@ -29,10 +29,11 @@ import java.util.*; import org.neo4j.cypher.javacompat.internal.DocsExecutionEngine; -import org.neo4j.graphdb.GraphDatabaseService; +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService; import org.neo4j.graphdb.config.Setting; import org.neo4j.graphdb.factory.GraphDatabaseSettings; import org.neo4j.graphdb.mockfs.EphemeralFileSystemAbstraction; +import org.neo4j.kernel.GraphDatabaseQueryService; import org.neo4j.test.TestGraphDatabaseFactory; /** @@ -72,7 +73,8 @@ public static String parse( String input, File parentDirectory, String url ) //TODO remove config when compiled plans are feature complete Map, String> config = new HashMap<>(); config.put( GraphDatabaseSettings.cypher_runtime, "INTERPRETED" ); - GraphDatabaseService database = new TestGraphDatabaseFactory().setFileSystem( fs ).newImpermanentDatabase(config); + GraphDatabaseQueryService database = new GraphDatabaseCypherService( + new TestGraphDatabaseFactory().setFileSystem( fs ).newImpermanentDatabase( config ) ); Connection conn = null; TestFailureException failure = null; @@ -94,7 +96,7 @@ public static String parse( String input, File parentDirectory, String url ) } finally { - database.shutdown(); + database.getGraphDatabaseService().shutdown(); if ( failure != null ) { dumpStoreFiles( fs, failure, "after-shutdown" ); diff --git a/manual/cypher/graphgist/src/main/java/org/neo4j/doc/cypherdoc/Result.java b/manual/cypher/graphgist/src/main/java/org/neo4j/doc/cypherdoc/Result.java index cf34a6b45c75f..e7b526a77eaa6 100644 --- a/manual/cypher/graphgist/src/main/java/org/neo4j/doc/cypherdoc/Result.java +++ b/manual/cypher/graphgist/src/main/java/org/neo4j/doc/cypherdoc/Result.java @@ -25,11 +25,11 @@ import java.util.Set; import org.neo4j.cypher.internal.compiler.v3_0.executionplan.InternalExecutionResult; -import org.neo4j.graphdb.GraphDatabaseService; import org.neo4j.graphdb.Node; import org.neo4j.graphdb.Path; import org.neo4j.graphdb.Relationship; import org.neo4j.graphdb.Transaction; +import org.neo4j.kernel.GraphDatabaseQueryService; class Result { @@ -39,7 +39,7 @@ class Result final Set nodeIds = new HashSet<>(); final Set relationshipIds = new HashSet<>(); - public Result( String query, InternalExecutionResult result, GraphDatabaseService database ) + public Result( String query, InternalExecutionResult result, GraphDatabaseQueryService database ) { this.query = query; text = result.dumpToString(); diff --git a/manual/cypher/graphgist/src/main/java/org/neo4j/doc/cypherdoc/State.java b/manual/cypher/graphgist/src/main/java/org/neo4j/doc/cypherdoc/State.java index 8363b097fe621..2832c94806510 100644 --- a/manual/cypher/graphgist/src/main/java/org/neo4j/doc/cypherdoc/State.java +++ b/manual/cypher/graphgist/src/main/java/org/neo4j/doc/cypherdoc/State.java @@ -27,12 +27,12 @@ import java.util.Map; import org.neo4j.cypher.javacompat.internal.DocsExecutionEngine; -import org.neo4j.graphdb.GraphDatabaseService; +import org.neo4j.kernel.GraphDatabaseQueryService; class State { final DocsExecutionEngine engine; - final GraphDatabaseService database; + final GraphDatabaseQueryService database; final Connection sqlDatabase; final File parentDirectory; final String url; @@ -44,7 +44,7 @@ class State Result latestSqlResult; Result testedSqlResult; - State( DocsExecutionEngine engine, GraphDatabaseService database, Connection sqlConnection, + State( DocsExecutionEngine engine, GraphDatabaseQueryService database, Connection sqlConnection, File parentDirectory, String url ) { diff --git a/manual/cypher/graphgist/src/main/scala/org/neo4j/cypher/internal/DocsExecutionEngine.scala b/manual/cypher/graphgist/src/main/scala/org/neo4j/cypher/internal/DocsExecutionEngine.scala index 3f741b8706cbf..cb91390bf44b2 100644 --- a/manual/cypher/graphgist/src/main/scala/org/neo4j/cypher/internal/DocsExecutionEngine.scala +++ b/manual/cypher/graphgist/src/main/scala/org/neo4j/cypher/internal/DocsExecutionEngine.scala @@ -23,13 +23,13 @@ import java.util.{Map => JavaMap} import org.neo4j.cypher.SyntaxException import org.neo4j.cypher.internal.compiler.v3_0.executionplan.InternalExecutionResult -import org.neo4j.graphdb.GraphDatabaseService +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.impl.query.{QueryExecutionMonitor, QuerySession} import org.neo4j.logging.{LogProvider, NullLogProvider} import scala.collection.JavaConverters._ -class DocsExecutionEngine(graph: GraphDatabaseService, logProvider: LogProvider = NullLogProvider.getInstance) +class DocsExecutionEngine(graph: GraphDatabaseQueryService, logProvider: LogProvider = NullLogProvider.getInstance) (implicit monitor: QueryExecutionMonitor, session: QuerySession) extends ExecutionEngine(graph, logProvider) { diff --git a/manual/cypher/graphgist/src/test/java/org/neo4j/cypher/javacompat/internal/DocsExecutionEngineTest.java b/manual/cypher/graphgist/src/test/java/org/neo4j/cypher/javacompat/internal/DocsExecutionEngineTest.java index 0d2d9c2cc5b4e..cb63006cb9158 100644 --- a/manual/cypher/graphgist/src/test/java/org/neo4j/cypher/javacompat/internal/DocsExecutionEngineTest.java +++ b/manual/cypher/graphgist/src/test/java/org/neo4j/cypher/javacompat/internal/DocsExecutionEngineTest.java @@ -24,8 +24,8 @@ import org.junit.Test; import org.neo4j.cypher.internal.compiler.v3_0.executionplan.InternalExecutionResult; -import org.neo4j.graphdb.GraphDatabaseService; import org.neo4j.graphdb.mockfs.EphemeralFileSystemAbstraction; +import org.neo4j.kernel.GraphDatabaseQueryService; import org.neo4j.test.TestGraphDatabaseFactory; import static org.hamcrest.MatcherAssert.assertThat; @@ -34,21 +34,21 @@ public class DocsExecutionEngineTest { - private static GraphDatabaseService database; + private static GraphDatabaseQueryService database; private static DocsExecutionEngine engine; @Before public void setup() { EphemeralFileSystemAbstraction fs = new EphemeralFileSystemAbstraction(); - database = new TestGraphDatabaseFactory().setFileSystem( fs ).newImpermanentDatabase(); + database = new GraphDatabaseCypherService(new TestGraphDatabaseFactory().setFileSystem( fs ).newImpermanentDatabase()); engine = new DocsExecutionEngine( database ); } @After public void teardown() { - database.shutdown(); + database.getGraphDatabaseService().shutdown(); } @Test diff --git a/manual/cypher/graphgist/src/test/java/org/neo4j/doc/cypherdoc/BlockTypeTest.java b/manual/cypher/graphgist/src/test/java/org/neo4j/doc/cypherdoc/BlockTypeTest.java index adf3e08107ff5..edffa110ed786 100644 --- a/manual/cypher/graphgist/src/test/java/org/neo4j/doc/cypherdoc/BlockTypeTest.java +++ b/manual/cypher/graphgist/src/test/java/org/neo4j/doc/cypherdoc/BlockTypeTest.java @@ -39,8 +39,9 @@ import org.neo4j.cypher.internal.compiler.v3_0.executionplan.InternalExecutionResult; import org.neo4j.cypher.javacompat.internal.DocsExecutionEngine; -import org.neo4j.graphdb.GraphDatabaseService; +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService; import org.neo4j.graphdb.ResourceIterator; +import org.neo4j.kernel.GraphDatabaseQueryService; import org.neo4j.test.TestGraphDatabaseFactory; import static org.hamcrest.MatcherAssert.assertThat; @@ -57,7 +58,7 @@ public class BlockTypeTest { - private GraphDatabaseService database; + private GraphDatabaseQueryService database; private DocsExecutionEngine engine; private State state; @@ -83,7 +84,7 @@ public class BlockTypeTest @Before public void setup() throws SQLException { - database = new TestGraphDatabaseFactory().newImpermanentDatabase(); + database = new GraphDatabaseCypherService(new TestGraphDatabaseFactory().newImpermanentDatabase()); engine = new DocsExecutionEngine( database ); Connection conn = DriverManager.getConnection( "jdbc:hsqldb:mem:graphgisttests;shutdown=true" ); conn.setAutoCommit( true ); @@ -93,7 +94,7 @@ public void setup() throws SQLException @After public void tearDown() { - database.shutdown(); + database.getGraphDatabaseService().shutdown(); } @Test @@ -219,7 +220,7 @@ public void query_with_parameters() @Test public void graph() { - database.execute( "CREATE (n:Person {name:\"Adam\"});" ); + engine.execute( "CREATE (n:Person {name:\"Adam\"});" ); Block block = Block.getBlock( Arrays.asList( "// graph:xyz" ) ); assertThat( block.type, sameInstance( BlockType.GRAPH ) ); String output; @@ -273,7 +274,7 @@ public void graph_result_includes_relationships() @Test public void graphWithoutId() { - database.execute( "CREATE (n:Person {name:\"Adam\"});" ); + engine.execute( "CREATE (n:Person {name:\"Adam\"});" ); Block block = Block.getBlock( Arrays.asList( "//graph" ) ); assertThat( block.type, sameInstance( BlockType.GRAPH ) ); String output; diff --git a/manual/cypher/refcard-tests/src/test/scala/org/neo4j/cypher/docgen/RefcardTest.scala b/manual/cypher/refcard-tests/src/test/scala/org/neo4j/cypher/docgen/RefcardTest.scala index 23e52f36b3570..232d752436a79 100644 --- a/manual/cypher/refcard-tests/src/test/scala/org/neo4j/cypher/docgen/RefcardTest.scala +++ b/manual/cypher/refcard-tests/src/test/scala/org/neo4j/cypher/docgen/RefcardTest.scala @@ -29,9 +29,10 @@ import org.neo4j.cypher.internal.compiler.v3_0.prettifier.Prettifier import org.neo4j.cypher.internal.helpers.GraphIcing import org.neo4j.cypher.internal.javacompat.GraphImpl import org.neo4j.cypher.internal.{ExecutionEngine, ExecutionResult, RewindableExecutionResult} +import org.neo4j.cypher.javacompat.internal.GraphDatabaseCypherService import org.neo4j.graphdb._ import org.neo4j.graphdb.index.Index -import org.neo4j.kernel.GraphDatabaseAPI +import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.test.{GraphDatabaseServiceCleaner, GraphDescription, TestGraphDatabaseFactory} import org.neo4j.visualization.asciidoc.AsciidocHelper import org.scalatest.Assertions @@ -43,7 +44,7 @@ Use this base class for refcard tests */ abstract class RefcardTest extends Assertions with DocumentationHelper with GraphIcing { - var db: GraphDatabaseAPI = null + var db: GraphDatabaseQueryService = null implicit var engine: ExecutionEngine = null var nodes: Map[String, Long] = null var nodeIndex: Index[Node] = null @@ -221,9 +222,9 @@ abstract class RefcardTest extends Assertions with DocumentationHelper with Grap dir = createDir(section) allQueriesWriter = new OutputStreamWriter(new FileOutputStream(new File("target/all-queries.asciidoc"), true), StandardCharsets.UTF_8) - db = newTestGraphDatabaseFactory().newImpermanentDatabaseBuilder().newGraphDatabase().asInstanceOf[GraphDatabaseAPI] + db = new GraphDatabaseCypherService(newTestGraphDatabaseFactory().newImpermanentDatabaseBuilder().newGraphDatabase()) - GraphDatabaseServiceCleaner.cleanDatabaseContent(db) + GraphDatabaseServiceCleaner.cleanDatabaseContent(db.getGraphDatabaseService) db.inTx { nodeIndex = db.index().forNodes("nodeIndexName") @@ -231,7 +232,7 @@ abstract class RefcardTest extends Assertions with DocumentationHelper with Grap val g = new GraphImpl(graphDescription.toArray[String]) val description = GraphDescription.create(g) - nodes = description.create(db).asScala.map { + nodes = description.create(db.getGraphDatabaseService).asScala.map { case (name, node) => name -> node.getId }.toMap