From 5e36e1fd3a6649fcd562b3b218ce15445fd447cf Mon Sep 17 00:00:00 2001 From: Nigel Small Date: Mon, 18 Nov 2019 08:02:00 +0000 Subject: [PATCH 1/7] StatementResult->Result --- README.md | 2 +- .../main/java/org/neo4j/driver/Record.java | 2 +- .../main/java/org/neo4j/driver/Records.java | 2 +- .../{StatementResult.java => Result.java} | 4 +- .../main/java/org/neo4j/driver/Session.java | 10 +- .../main/java/org/neo4j/driver/Statement.java | 4 +- .../org/neo4j/driver/StatementRunner.java | 18 +-- .../org/neo4j/driver/async/AsyncSession.java | 10 +- .../driver/async/AsyncStatementRunner.java | 20 ++-- ...entResultCursor.java => ResultCursor.java} | 6 +- .../internal/AbstractStatementRunner.java | 12 +- ...atementResult.java => InternalResult.java} | 10 +- .../driver/internal/InternalSession.java | 22 ++-- .../driver/internal/InternalTransaction.java | 16 +-- .../async/AsyncAbstractStatementRunner.java | 10 +- .../internal/async/InternalAsyncSession.java | 20 ++-- .../async/InternalAsyncTransaction.java | 8 +- .../driver/internal/async/NetworkSession.java | 38 +++--- ...saction.java => UnmanagedTransaction.java} | 20 ++-- .../cluster/RoutingProcedureRunner.java | 4 +- ...sultCursor.java => AsyncResultCursor.java} | 4 +- ...orImpl.java => AsyncResultCursorImpl.java} | 4 +- ...java => AsyncResultCursorOnlyFactory.java} | 14 +-- ....java => DisposableAsyncResultCursor.java} | 6 +- ...rFactory.java => ResultCursorFactory.java} | 6 +- ...Impl.java => ResultCursorFactoryImpl.java} | 18 +-- ...tResultCursor.java => RxResultCursor.java} | 2 +- ...ursorImpl.java => RxResultCursorImpl.java} | 12 +- .../internal/handlers/PullHandlers.java | 14 +-- ...sactionPullResponseCompletionListener.java | 6 +- .../internal/messaging/BoltProtocol.java | 12 +- .../internal/messaging/v1/BoltProtocolV1.java | 20 ++-- .../internal/messaging/v3/BoltProtocolV3.java | 20 ++-- .../internal/messaging/v4/BoltProtocolV4.java | 12 +- .../reactive/AbstractRxStatementRunner.java | 10 +- ...ementResult.java => InternalRxResult.java} | 20 ++-- .../internal/reactive/InternalRxSession.java | 16 +-- .../reactive/InternalRxTransaction.java | 16 +-- .../{RxStatementResult.java => RxResult.java} | 4 +- .../org/neo4j/driver/reactive/RxSession.java | 8 +- .../driver/reactive/RxStatementRunner.java | 10 +- driver/src/main/javadoc/overview.html | 2 +- .../integration/ConnectionHandlingIT.java | 36 +++--- .../driver/integration/ConnectionPoolIT.java | 8 +- .../driver/integration/DirectDriverIT.java | 4 +- .../driver/integration/EncryptionIT.java | 4 +- .../driver/integration/EntityTypeIT.java | 8 +- .../org/neo4j/driver/integration/ErrorIT.java | 10 +- .../neo4j/driver/integration/LoadCSVIT.java | 4 +- .../driver/integration/NestedQueries.java | 14 +-- .../driver/integration/ParametersIT.java | 38 +++--- .../driver/integration/ResultStreamIT.java | 38 +++--- .../integration/RoutingDriverBoltKitTest.java | 8 +- .../driver/integration/RoutingDriverIT.java | 6 +- .../driver/integration/ScalarTypeIT.java | 6 +- .../driver/integration/SessionBoltV3IT.java | 14 +-- .../neo4j/driver/integration/SessionIT.java | 68 +++++------ .../driver/integration/SessionMixIT.java | 22 ++-- .../driver/integration/SessionResetIT.java | 28 ++--- .../neo4j/driver/integration/StatementIT.java | 4 +- .../integration/StatementRunnerCloseIT.java | 20 ++-- .../neo4j/driver/integration/SummaryIT.java | 6 +- .../driver/integration/TemporalTypesIT.java | 4 +- .../integration/TransactionBoltV3IT.java | 8 +- .../driver/integration/TransactionIT.java | 18 +-- .../integration/TrustCustomCertificateIT.java | 4 +- ...ionIT.java => UnmanagedTransactionIT.java} | 38 +++--- .../integration/async/AsyncSessionIT.java | 108 +++++++++--------- .../integration/async/AsyncTransactionIT.java | 86 +++++++------- .../reactive/RxNestedQueriesIT.java | 8 +- ...StatementResultIT.java => RxResultIT.java} | 64 +++++------ .../integration/reactive/RxSessionIT.java | 12 +- .../integration/reactive/RxTransactionIT.java | 92 +++++++-------- .../internal/DirectDriverBoltKitTest.java | 22 ++-- ...esultTest.java => InternalResultTest.java} | 58 +++++----- .../internal/InternalTransactionTest.java | 8 +- ...st.java => AsyncResultCursorImplTest.java} | 54 ++++----- .../async/InternalAsyncSessionTest.java | 8 +- .../async/InternalAsyncTransactionTest.java | 8 +- .../internal/async/NetworkSessionTest.java | 22 ++-- .../async/ResultCursorsHolderTest.java | 10 +- ...est.java => UnmanagedTransactionTest.java} | 30 ++--- ... => AsyncResultCursorOnlyFactoryTest.java} | 34 +++--- ...a => DisposableAsyncResultCursorTest.java} | 14 +-- ....java => ResultCursorFactoryImplTest.java} | 50 ++++---- ...lTest.java => RxResultCursorImplTest.java} | 28 ++--- ...ionPullResponseCompletionListenerTest.java | 4 +- ...ionPullResponseCompletionListenerTest.java | 10 +- .../messaging/v1/BoltProtocolV1Test.java | 16 +-- .../messaging/v3/BoltProtocolV3Test.java | 18 +-- .../messaging/v4/BoltProtocolV4Test.java | 22 ++-- ...ultTest.java => InternalRxResultTest.java} | 48 ++++---- .../reactive/InternalRxSessionTest.java | 32 +++--- .../reactive/InternalRxTransactionTest.java | 32 +++--- .../driver/stress/AbstractStressTestBase.java | 8 +- .../driver/stress/AsyncFailingQuery.java | 4 +- .../driver/stress/AsyncFailingQueryInTx.java | 4 +- .../neo4j/driver/stress/AsyncReadQuery.java | 4 +- .../driver/stress/AsyncReadQueryInTx.java | 4 +- .../neo4j/driver/stress/AsyncWriteQuery.java | 4 +- .../neo4j/driver/stress/AsyncWrongQuery.java | 4 +- .../driver/stress/AsyncWrongQueryInTx.java | 4 +- .../driver/stress/BlockingFailingQuery.java | 4 +- .../stress/BlockingFailingQueryInTx.java | 4 +- .../driver/stress/BlockingReadQuery.java | 4 +- .../driver/stress/BlockingReadQueryInTx.java | 4 +- .../driver/stress/BlockingWriteQuery.java | 4 +- .../driver/stress/BlockingWriteQueryInTx.java | 4 +- .../BlockingWriteQueryUsingReadSession.java | 6 +- ...lockingWriteQueryUsingReadSessionInTx.java | 6 +- .../driver/stress/CausalClusteringIT.java | 24 ++-- .../org/neo4j/driver/stress/RxReadQuery.java | 4 +- .../neo4j/driver/stress/RxReadQueryInTx.java | 4 +- .../driver/stress/RxReadQueryWithRetries.java | 4 +- .../driver/stress/SessionPoolingStressIT.java | 4 +- .../neo4j/driver/util/SessionExtension.java | 18 +-- .../java/org/neo4j/driver/util/TestUtil.java | 4 +- .../cc/ClusterMemberRoleDiscoveryFactory.java | 6 +- .../AsyncExplicitTransactionExample.java | 4 +- .../neo4j/docs/driver/BasicAuthExample.java | 4 +- .../driver/ConfigConnectionPoolExample.java | 4 +- .../driver/ConfigCustomResolverExample.java | 4 +- .../neo4j/docs/driver/CypherErrorExample.java | 4 +- .../neo4j/docs/driver/HelloWorldExample.java | 4 +- .../docs/driver/PassBookmarkExample.java | 14 +-- .../driver/ReadWriteTransactionExample.java | 4 +- .../docs/driver/ResultConsumeExample.java | 4 +- .../driver/RxTransactionFunctionExample.java | 6 +- 128 files changed, 990 insertions(+), 992 deletions(-) rename driver/src/main/java/org/neo4j/driver/{StatementResult.java => Result.java} (97%) rename driver/src/main/java/org/neo4j/driver/async/{StatementResultCursor.java => ResultCursor.java} (97%) rename driver/src/main/java/org/neo4j/driver/internal/{InternalStatementResult.java => InternalResult.java} (92%) rename driver/src/main/java/org/neo4j/driver/internal/async/{ExplicitTransaction.java => UnmanagedTransaction.java} (91%) rename driver/src/main/java/org/neo4j/driver/internal/cursor/{AsyncStatementResultCursor.java => AsyncResultCursor.java} (84%) rename driver/src/main/java/org/neo4j/driver/internal/cursor/{AsyncStatementResultCursorImpl.java => AsyncResultCursorImpl.java} (96%) rename driver/src/main/java/org/neo4j/driver/internal/cursor/{AsyncStatementResultCursorOnlyFactory.java => AsyncResultCursorOnlyFactory.java} (78%) rename driver/src/main/java/org/neo4j/driver/internal/cursor/{DisposableAsyncStatementResultCursor.java => DisposableAsyncResultCursor.java} (93%) rename driver/src/main/java/org/neo4j/driver/internal/cursor/{StatementResultCursorFactory.java => ResultCursorFactory.java} (82%) rename driver/src/main/java/org/neo4j/driver/internal/cursor/{StatementResultCursorFactoryImpl.java => ResultCursorFactoryImpl.java} (74%) rename driver/src/main/java/org/neo4j/driver/internal/cursor/{RxStatementResultCursor.java => RxResultCursor.java} (93%) rename driver/src/main/java/org/neo4j/driver/internal/cursor/{RxStatementResultCursorImpl.java => RxResultCursorImpl.java} (90%) rename driver/src/main/java/org/neo4j/driver/internal/reactive/{InternalRxStatementResult.java => InternalRxResult.java} (86%) rename driver/src/main/java/org/neo4j/driver/reactive/{RxStatementResult.java => RxResult.java} (97%) rename driver/src/test/java/org/neo4j/driver/integration/{ExplicitTransactionIT.java => UnmanagedTransactionIT.java} (87%) rename driver/src/test/java/org/neo4j/driver/integration/reactive/{RxStatementResultIT.java => RxResultIT.java} (87%) rename driver/src/test/java/org/neo4j/driver/internal/{InternalStatementResultTest.java => InternalResultTest.java} (85%) rename driver/src/test/java/org/neo4j/driver/internal/async/{AsyncStatementResultCursorImplTest.java => AsyncResultCursorImplTest.java} (87%) rename driver/src/test/java/org/neo4j/driver/internal/async/{ExplicitTransactionTest.java => UnmanagedTransactionTest.java} (85%) rename driver/src/test/java/org/neo4j/driver/internal/cursor/{AsyncStatementResultCursorOnlyFactoryTest.java => AsyncResultCursorOnlyFactoryTest.java} (74%) rename driver/src/test/java/org/neo4j/driver/internal/cursor/{DisposableAsyncStatementResultCursorTest.java => DisposableAsyncResultCursorTest.java} (85%) rename driver/src/test/java/org/neo4j/driver/internal/cursor/{StatementResultCursorFactoryImplTest.java => ResultCursorFactoryImplTest.java} (71%) rename driver/src/test/java/org/neo4j/driver/internal/cursor/{RxStatementResultCursorImplTest.java => RxResultCursorImplTest.java} (86%) rename driver/src/test/java/org/neo4j/driver/internal/reactive/{InternalRxStatementResultTest.java => InternalRxResultTest.java} (79%) diff --git a/README.md b/README.md index 6b6626b0fe..8475ee338a 100644 --- a/README.md +++ b/README.md @@ -49,7 +49,7 @@ To run a simple query, the following can be used: ```java Driver driver = GraphDatabase.driver("bolt://localhost:7687", AuthTokens.basic("neo4j", "PasSW0rd")); try (Session session = driver.session()) { - StatementResult rs = session.run("CREATE (n) RETURN n"); + Result result = session.run("CREATE (n) RETURN n"); } driver.close(); ``` diff --git a/driver/src/main/java/org/neo4j/driver/Record.java b/driver/src/main/java/org/neo4j/driver/Record.java index 2e63549fdd..946bb3c7ae 100644 --- a/driver/src/main/java/org/neo4j/driver/Record.java +++ b/driver/src/main/java/org/neo4j/driver/Record.java @@ -33,7 +33,7 @@ * Container for Cypher result values. *

* Streams of records are returned from Cypher statement execution, contained - * within a {@link StatementResult}. + * within a {@link Result}. *

* A record is a form of ordered map and, as such, contained values can be * accessed by either positional {@link #get(int) index} or textual diff --git a/driver/src/main/java/org/neo4j/driver/Records.java b/driver/src/main/java/org/neo4j/driver/Records.java index d71b8241b3..864a806c0d 100644 --- a/driver/src/main/java/org/neo4j/driver/Records.java +++ b/driver/src/main/java/org/neo4j/driver/Records.java @@ -23,7 +23,7 @@ /** * Static utility methods for retaining records * - * @see StatementResult#list() + * @see Result#list() * @since 1.0 */ public abstract class Records diff --git a/driver/src/main/java/org/neo4j/driver/StatementResult.java b/driver/src/main/java/org/neo4j/driver/Result.java similarity index 97% rename from driver/src/main/java/org/neo4j/driver/StatementResult.java rename to driver/src/main/java/org/neo4j/driver/Result.java index 90e33fccb9..bf0807b143 100644 --- a/driver/src/main/java/org/neo4j/driver/StatementResult.java +++ b/driver/src/main/java/org/neo4j/driver/Result.java @@ -53,7 +53,7 @@ * * @since 1.0 */ -public interface StatementResult extends Iterator +public interface Result extends Iterator { /** * Retrieve the keys of the records this result contains. @@ -143,7 +143,7 @@ public interface StatementResult extends Iterator * * If the records in the result is not fully consumed, then calling this method will exhausts the result. * - * If you want to access unconsumed records after summary, you shall use {@link StatementResult#list()} to buffer all records into memory before summary. + * If you want to access unconsumed records after summary, you shall use {@link Result#list()} to buffer all records into memory before summary. * * @return a summary for the whole query result. */ diff --git a/driver/src/main/java/org/neo4j/driver/Session.java b/driver/src/main/java/org/neo4j/driver/Session.java index a790653340..b2835d6bb6 100644 --- a/driver/src/main/java/org/neo4j/driver/Session.java +++ b/driver/src/main/java/org/neo4j/driver/Session.java @@ -141,7 +141,7 @@ public interface Session extends Resource, StatementRunner * @param config configuration for the new transaction. * @return a stream of result values and associated metadata. */ - StatementResult run( String statement, TransactionConfig config ); + Result run(String statement, TransactionConfig config ); /** * Run a statement with parameters in an auto-commit transaction with specified {@link TransactionConfig configuration} and return a result stream. @@ -169,7 +169,7 @@ public interface Session extends Resource, StatementRunner * Map parameters = new HashMap<>(); * parameters.put("myNameParam", "Bob"); * - * StatementResult cursor = session.run("MATCH (n) WHERE n.name = {myNameParam} RETURN (n)", parameters, config); + * Result result = session.run("MATCH (n) WHERE n.name = {myNameParam} RETURN (n)", parameters, config); * } * * @@ -178,7 +178,7 @@ public interface Session extends Resource, StatementRunner * @param config configuration for the new transaction. * @return a stream of result values and associated metadata. */ - StatementResult run( String statement, Map parameters, TransactionConfig config ); + Result run(String statement, Map parameters, TransactionConfig config ); /** * Run a statement in an auto-commit transaction with specified {@link TransactionConfig configuration} and return a result stream. @@ -194,7 +194,7 @@ public interface Session extends Resource, StatementRunner * .build(); * * Statement statement = new Statement("MATCH (n) WHERE n.name=$myNameParam RETURN n.age"); - * StatementResult cursor = session.run(statement.withParameters(Values.parameters("myNameParam", "Bob"))); + * Result result = session.run(statement.withParameters(Values.parameters("myNameParam", "Bob"))); * } * * @@ -202,7 +202,7 @@ public interface Session extends Resource, StatementRunner * @param config configuration for the new transaction. * @return a stream of result values and associated metadata. */ - StatementResult run( Statement statement, TransactionConfig config ); + Result run(Statement statement, TransactionConfig config ); /** * Return the bookmark received following the last completed diff --git a/driver/src/main/java/org/neo4j/driver/Statement.java b/driver/src/main/java/org/neo4j/driver/Statement.java index fea533f606..2ec9002a06 100644 --- a/driver/src/main/java/org/neo4j/driver/Statement.java +++ b/driver/src/main/java/org/neo4j/driver/Statement.java @@ -35,8 +35,8 @@ * * @see Session * @see Transaction - * @see StatementResult - * @see StatementResult#consume() + * @see Result + * @see Result#consume() * @see ResultSummary * @since 1.0 */ diff --git a/driver/src/main/java/org/neo4j/driver/StatementRunner.java b/driver/src/main/java/org/neo4j/driver/StatementRunner.java index 0ec6445a81..d32565e652 100644 --- a/driver/src/main/java/org/neo4j/driver/StatementRunner.java +++ b/driver/src/main/java/org/neo4j/driver/StatementRunner.java @@ -42,7 +42,7 @@ * *

@@ -80,7 +80,7 @@ public interface StatementRunner * 
      * {@code
      *
-     * StatementResult cursor = session.run( "MATCH (n) WHERE n.name = {myNameParam} RETURN (n)",
+     * Result result = session.run( "MATCH (n) WHERE n.name = {myNameParam} RETURN (n)",
      *                                       Values.parameters( "myNameParam", "Bob" ) );
      * }
      *
@@ -89,7 +89,7 @@ public interface StatementRunner * @param parameters input parameters, should be a map Value, see {@link Values#parameters(Object...)}. * @return a stream of result values and associated metadata */ - StatementResult run( String statementTemplate, Value parameters ); + Result run(String statementTemplate, Value parameters ); /** * Run a statement and return a result stream. @@ -110,7 +110,7 @@ public interface StatementRunner * Map parameters = new HashMap(); * parameters.put("myNameParam", "Bob"); * - * StatementResult cursor = session.run( "MATCH (n) WHERE n.name = {myNameParam} RETURN (n)", + * Result result = session.run( "MATCH (n) WHERE n.name = {myNameParam} RETURN (n)", * parameters ); * } * @@ -119,7 +119,7 @@ public interface StatementRunner * @param statementParameters input data for the statement * @return a stream of result values and associated metadata */ - StatementResult run( String statementTemplate, Map statementParameters ); + Result run(String statementTemplate, Map statementParameters ); /** * Run a statement and return a result stream. @@ -136,7 +136,7 @@ public interface StatementRunner * @param statementParameters input data for the statement * @return a stream of result values and associated metadata */ - StatementResult run( String statementTemplate, Record statementParameters ); + Result run(String statementTemplate, Record statementParameters ); /** * Run a statement and return a result stream. @@ -144,7 +144,7 @@ public interface StatementRunner * @param statementTemplate text of a Neo4j statement * @return a stream of result values and associated metadata */ - StatementResult run( String statementTemplate ); + Result run(String statementTemplate ); /** * Run a statement and return a result stream. @@ -153,12 +153,12 @@ public interface StatementRunner * {@code * * Statement statement = new Statement( "MATCH (n) WHERE n.name=$myNameParam RETURN n.age" ); - * StatementResult cursor = session.run( statement.withParameters( Values.parameters( "myNameParam", "Bob" ) ) ); + * Result result = session.run( statement.withParameters( Values.parameters( "myNameParam", "Bob" ) ) ); * } * * * @param statement a Neo4j statement * @return a stream of result values and associated metadata */ - StatementResult run( Statement statement ); + Result run(Statement statement ); } diff --git a/driver/src/main/java/org/neo4j/driver/async/AsyncSession.java b/driver/src/main/java/org/neo4j/driver/async/AsyncSession.java index 56c3ef5e57..decee1ba62 100644 --- a/driver/src/main/java/org/neo4j/driver/async/AsyncSession.java +++ b/driver/src/main/java/org/neo4j/driver/async/AsyncSession.java @@ -221,7 +221,7 @@ public interface AsyncSession extends AsyncStatementRunner * @return new {@link CompletionStage} that gets completed with a result cursor when query execution is successful. * Stage can be completed exceptionally when error happens, e.g. connection can't be acquired from the pool. */ - CompletionStage runAsync( String statement, TransactionConfig config ); + CompletionStage runAsync(String statement, TransactionConfig config ); /** * Run a statement asynchronously in an auto-commit transaction with the specified {@link TransactionConfig configuration} and return a @@ -249,7 +249,7 @@ public interface AsyncSession extends AsyncStatementRunner * Map parameters = new HashMap(); * parameters.put("myNameParam", "Bob"); * - * CompletionStage cursorStage = session.runAsync( + * CompletionStage cursorStage = session.runAsync( * "MATCH (n) WHERE n.name = {myNameParam} RETURN (n)", * parameters, * config); @@ -264,7 +264,7 @@ public interface AsyncSession extends AsyncStatementRunner * @return new {@link CompletionStage} that gets completed with a result cursor when query execution is successful. * Stage can be completed exceptionally when error happens, e.g. connection can't be acquired from the pool. */ - CompletionStage runAsync( String statement, Map parameters, TransactionConfig config ); + CompletionStage runAsync(String statement, Map parameters, TransactionConfig config ); /** * Run a statement asynchronously in an auto-commit transaction with the specified {@link TransactionConfig configuration} and return a @@ -281,7 +281,7 @@ public interface AsyncSession extends AsyncStatementRunner * .build(); * * Statement statement = new Statement( "MATCH (n) WHERE n.name=$myNameParam RETURN n.age" ); - * CompletionStage cursorStage = session.runAsync(statement, config); + * CompletionStage cursorStage = session.runAsync(statement, config); * } * * It is not allowed to chain blocking operations on the returned {@link CompletionStage}. See class javadoc in {@link AsyncStatementRunner} for @@ -292,7 +292,7 @@ public interface AsyncSession extends AsyncStatementRunner * @return new {@link CompletionStage} that gets completed with a result cursor when query execution is successful. * Stage can be completed exceptionally when error happens, e.g. connection can't be acquired from the pool. */ - CompletionStage runAsync( Statement statement, TransactionConfig config ); + CompletionStage runAsync(Statement statement, TransactionConfig config ); /** * Return the bookmark received following the last completed diff --git a/driver/src/main/java/org/neo4j/driver/async/AsyncStatementRunner.java b/driver/src/main/java/org/neo4j/driver/async/AsyncStatementRunner.java index cf6aa2c49a..0f00eaf7c5 100644 --- a/driver/src/main/java/org/neo4j/driver/async/AsyncStatementRunner.java +++ b/driver/src/main/java/org/neo4j/driver/async/AsyncStatementRunner.java @@ -51,7 +51,7 @@ * *
    *
  • Read from or discard a result, for instance via - * {@link StatementResultCursor#nextAsync()}, {@link StatementResultCursor#consumeAsync()}
    • + * {@link ResultCursor#nextAsync()}, {@link ResultCursor#consumeAsync()} *
  • Explicitly commit/rollback a transaction using {@link AsyncTransaction#commitAsync()}, {@link AsyncTransaction#rollbackAsync()}
    • *
  • Close a session using {@link AsyncSession#closeAsync()}
    • *
@@ -67,7 +67,7 @@ *

Asynchronous API

*

* All overloads of {@link #runAsync(Statement)} execute queries in async fashion and return {@link CompletionStage} of - * a new {@link StatementResultCursor}. Stage can be completed exceptionally when error happens, e.g. connection can't + * a new {@link ResultCursor}. Stage can be completed exceptionally when error happens, e.g. connection can't * be acquired from the pool. *

* Note: Returned stage can be completed by an IO thread which should never block. Otherwise IO operations on @@ -101,7 +101,7 @@ public interface AsyncStatementRunner * 

      * {@code
      *
-     * CompletionStage cursorStage = session.runAsync(
+     * CompletionStage cursorStage = session.runAsync(
      *             "MATCH (n) WHERE n.name = {myNameParam} RETURN (n)",
      *             Values.parameters("myNameParam", "Bob"));
      * }
@@ -114,7 +114,7 @@ public interface AsyncStatementRunner
      * @return new {@link CompletionStage} that gets completed with a result cursor when query execution is successful.
      * Stage can be completed exceptionally when error happens, e.g. connection can't be acquired from the pool.
      */
-    CompletionStage runAsync( String statementTemplate, Value parameters );
+    CompletionStage runAsync(String statementTemplate, Value parameters );
 
     /**
      * Run a statement asynchronously and return a {@link CompletionStage} with a
@@ -135,7 +135,7 @@ public interface AsyncStatementRunner
      * Map parameters = new HashMap();
      * parameters.put("myNameParam", "Bob");
      *
-     * CompletionStage cursorStage = session.runAsync(
+     * CompletionStage cursorStage = session.runAsync(
      *             "MATCH (n) WHERE n.name = {myNameParam} RETURN (n)",
      *             parameters);
      * }
@@ -148,7 +148,7 @@ public interface AsyncStatementRunner
      * @return new {@link CompletionStage} that gets completed with a result cursor when query execution is successful.
      * Stage can be completed exceptionally when error happens, e.g. connection can't be acquired from the pool.
      */
-    CompletionStage runAsync( String statementTemplate, Map statementParameters );
+    CompletionStage runAsync(String statementTemplate, Map statementParameters );
 
     /**
      * Run a statement asynchronously and return a {@link CompletionStage} with a
@@ -170,7 +170,7 @@ public interface AsyncStatementRunner
      * @return new {@link CompletionStage} that gets completed with a result cursor when query execution is successful.
      * Stage can be completed exceptionally when error happens, e.g. connection can't be acquired from the pool.
      */
-    CompletionStage runAsync( String statementTemplate, Record statementParameters );
+    CompletionStage runAsync(String statementTemplate, Record statementParameters );
 
     /**
      * Run a statement asynchronously and return a {@link CompletionStage} with a
@@ -183,7 +183,7 @@ public interface AsyncStatementRunner
      * @return new {@link CompletionStage} that gets completed with a result cursor when query execution is successful.
      * Stage can be completed exceptionally when error happens, e.g. connection can't be acquired from the pool.
      */
-    CompletionStage runAsync( String statementTemplate );
+    CompletionStage runAsync(String statementTemplate );
 
     /**
      * Run a statement asynchronously and return a {@link CompletionStage} with a
@@ -192,7 +192,7 @@ public interface AsyncStatementRunner
      * 
      * {@code
      * Statement statement = new Statement( "MATCH (n) WHERE n.name=$myNameParam RETURN n.age" );
-     * CompletionStage cursorStage = session.runAsync(statement);
+     * CompletionStage cursorStage = session.runAsync(statement);
      * }
      * 

      * It is not allowed to chain blocking operations on the returned {@link CompletionStage}. See class javadoc for
@@ -202,5 +202,5 @@ public interface AsyncStatementRunner
      * @return new {@link CompletionStage} that gets completed with a result cursor when query execution is successful.
      * Stage can be completed exceptionally when error happens, e.g. connection can't be acquired from the pool.
      */
-    CompletionStage runAsync( Statement statement );
+    CompletionStage runAsync(Statement statement );
 }
diff --git a/driver/src/main/java/org/neo4j/driver/async/StatementResultCursor.java b/driver/src/main/java/org/neo4j/driver/async/ResultCursor.java
similarity index 97%
rename from driver/src/main/java/org/neo4j/driver/async/StatementResultCursor.java
rename to driver/src/main/java/org/neo4j/driver/async/ResultCursor.java
index 8e8f29ad39..b06ad4c8e0 100644
--- a/driver/src/main/java/org/neo4j/driver/async/StatementResultCursor.java
+++ b/driver/src/main/java/org/neo4j/driver/async/ResultCursor.java
@@ -27,7 +27,7 @@
 
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Records;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.exceptions.NoSuchRecordException;
 import org.neo4j.driver.summary.ResultSummary;
 
@@ -61,7 +61,7 @@
  *
  * @since 1.5
  */
-public interface StatementResultCursor
+public interface ResultCursor
 {
     /**
      * Retrieve the keys of the records this result cursor contains.
@@ -75,7 +75,7 @@ public interface StatementResultCursor
      * 

      * If the records in the result is not fully consumed, then calling this method will exhausts the result.
      * 

-     * If you want to access unconsumed records after summary, you shall use {@link StatementResult#list()} to buffer all records into memory before summary.
+     * If you want to access unconsumed records after summary, you shall use {@link Result#list()} to buffer all records into memory before summary.
      *
      * @return a {@link CompletionStage} completed with a summary for the whole query result. Stage can also be
      * completed exceptionally if query execution fails.
diff --git a/driver/src/main/java/org/neo4j/driver/internal/AbstractStatementRunner.java b/driver/src/main/java/org/neo4j/driver/internal/AbstractStatementRunner.java
index 3400a501a1..0acd3894e5 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/AbstractStatementRunner.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/AbstractStatementRunner.java
@@ -22,37 +22,35 @@
 
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Statement;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.StatementRunner;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.Values;
-import org.neo4j.driver.internal.types.InternalTypeSystem;
 import org.neo4j.driver.internal.util.Extract;
 import org.neo4j.driver.internal.value.MapValue;
-import org.neo4j.driver.types.TypeSystem;
 
 public abstract class AbstractStatementRunner implements StatementRunner
 {
     @Override
-    public final StatementResult run( String statementTemplate, Value parameters )
+    public final Result run(String statementTemplate, Value parameters )
     {
         return run( new Statement( statementTemplate, parameters ) );
     }
 
     @Override
-    public final StatementResult run( String statementTemplate, Map statementParameters )
+    public final Result run(String statementTemplate, Map statementParameters )
     {
         return run( statementTemplate, parameters( statementParameters ) );
     }
 
     @Override
-    public final StatementResult run( String statementTemplate, Record statementParameters )
+    public final Result run(String statementTemplate, Record statementParameters )
     {
         return run( statementTemplate, parameters( statementParameters ) );
     }
 
     @Override
-    public final StatementResult run( String statementText )
+    public final Result run(String statementText )
     {
         return run( statementText, Values.EmptyMap );
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalStatementResult.java b/driver/src/main/java/org/neo4j/driver/internal/InternalResult.java
similarity index 92%
rename from driver/src/main/java/org/neo4j/driver/internal/InternalStatementResult.java
rename to driver/src/main/java/org/neo4j/driver/internal/InternalResult.java
index 3e312721cd..16668c330e 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/InternalStatementResult.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/InternalResult.java
@@ -27,21 +27,21 @@
 import java.util.stream.StreamSupport;
 
 import org.neo4j.driver.Record;
-import org.neo4j.driver.StatementResult;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.Result;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.exceptions.NoSuchRecordException;
 import org.neo4j.driver.internal.spi.Connection;
 import org.neo4j.driver.internal.util.Futures;
 import org.neo4j.driver.summary.ResultSummary;
 
-public class InternalStatementResult implements StatementResult
+public class InternalResult implements Result
 {
     private final Connection connection;
-    private final StatementResultCursor cursor;
+    private final ResultCursor cursor;
     private List keys;
 
-    public InternalStatementResult( Connection connection, StatementResultCursor cursor )
+    public InternalResult(Connection connection, ResultCursor cursor )
     {
         this.connection = connection;
         this.cursor = cursor;
diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java b/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java
index ea861449fe..3fcc63a3cb 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java
@@ -24,12 +24,12 @@
 import org.neo4j.driver.Bookmark;
 import org.neo4j.driver.Session;
 import org.neo4j.driver.Statement;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.TransactionWork;
-import org.neo4j.driver.async.StatementResultCursor;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
+import org.neo4j.driver.async.ResultCursor;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
 import org.neo4j.driver.internal.async.NetworkSession;
 import org.neo4j.driver.internal.spi.Connection;
 import org.neo4j.driver.internal.util.Futures;
@@ -46,32 +46,32 @@ public InternalSession( NetworkSession session )
     }
 
     @Override
-    public StatementResult run( Statement statement )
+    public Result run(Statement statement )
     {
         return run( statement, TransactionConfig.empty() );
     }
 
     @Override
-    public StatementResult run( String statement, TransactionConfig config )
+    public Result run(String statement, TransactionConfig config )
     {
         return run( statement, emptyMap(), config );
     }
 
     @Override
-    public StatementResult run( String statement, Map parameters, TransactionConfig config )
+    public Result run(String statement, Map parameters, TransactionConfig config )
     {
         return run( new Statement( statement, parameters ), config );
     }
 
     @Override
-    public StatementResult run( Statement statement, TransactionConfig config )
+    public Result run(Statement statement, TransactionConfig config )
     {
-        StatementResultCursor cursor = Futures.blockingGet( session.runAsync( statement, config, false ),
+        ResultCursor cursor = Futures.blockingGet( session.runAsync( statement, config, false ),
                 () -> terminateConnectionOnThreadInterrupt( "Thread interrupted while running query in session" ) );
 
         // query executed, it is safe to obtain a connection in a blocking way
         Connection connection = Futures.getNow( session.connectionAsync() );
-        return new InternalStatementResult( connection, cursor );
+        return new InternalResult( connection, cursor );
     }
 
     @Override
@@ -95,7 +95,7 @@ public Transaction beginTransaction()
     @Override
     public Transaction beginTransaction( TransactionConfig config )
     {
-        ExplicitTransaction tx = Futures.blockingGet( session.beginTransactionAsync( config ),
+        UnmanagedTransaction tx = Futures.blockingGet( session.beginTransactionAsync( config ),
                 () -> terminateConnectionOnThreadInterrupt( "Thread interrupted while starting a transaction" ) );
         return new InternalTransaction( tx );
     }
@@ -160,7 +160,7 @@ private  T transaction( AccessMode mode, TransactionWork work, Transaction
 
     private Transaction beginTransaction( AccessMode mode, TransactionConfig config )
     {
-        ExplicitTransaction tx = Futures.blockingGet( session.beginTransactionAsync( mode, config ),
+        UnmanagedTransaction tx = Futures.blockingGet( session.beginTransactionAsync( mode, config ),
                 () -> terminateConnectionOnThreadInterrupt( "Thread interrupted while starting a transaction" ) );
         return new InternalTransaction( tx );
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalTransaction.java b/driver/src/main/java/org/neo4j/driver/internal/InternalTransaction.java
index 6cb12bda67..cd37d832e2 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/InternalTransaction.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/InternalTransaction.java
@@ -19,16 +19,16 @@
 package org.neo4j.driver.internal;
 
 import org.neo4j.driver.Statement;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
-import org.neo4j.driver.async.StatementResultCursor;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
+import org.neo4j.driver.async.ResultCursor;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
 import org.neo4j.driver.internal.util.Futures;
 
 public class InternalTransaction extends AbstractStatementRunner implements Transaction
 {
-    private final ExplicitTransaction tx;
-    public InternalTransaction( ExplicitTransaction tx )
+    private final UnmanagedTransaction tx;
+    public InternalTransaction( UnmanagedTransaction tx )
     {
         this.tx = tx;
     }
@@ -55,11 +55,11 @@ public void close()
     }
 
     @Override
-    public StatementResult run( Statement statement )
+    public Result run(Statement statement )
     {
-        StatementResultCursor cursor = Futures.blockingGet( tx.runAsync( statement, false ),
+        ResultCursor cursor = Futures.blockingGet( tx.runAsync( statement, false ),
                 () -> terminateConnectionOnThreadInterrupt( "Thread interrupted while running query in transaction" ) );
-        return new InternalStatementResult( tx.connection(), cursor );
+        return new InternalResult( tx.connection(), cursor );
     }
 
     @Override
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/AsyncAbstractStatementRunner.java b/driver/src/main/java/org/neo4j/driver/internal/async/AsyncAbstractStatementRunner.java
index d2a7df9ea4..b3a8f5308d 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/AsyncAbstractStatementRunner.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/AsyncAbstractStatementRunner.java
@@ -26,32 +26,32 @@
 import org.neo4j.driver.Value;
 import org.neo4j.driver.Values;
 import org.neo4j.driver.async.AsyncStatementRunner;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 
 import static org.neo4j.driver.internal.AbstractStatementRunner.parameters;
 
 public abstract class AsyncAbstractStatementRunner implements AsyncStatementRunner
 {
     @Override
-    public final CompletionStage runAsync( String statementTemplate, Value parameters )
+    public final CompletionStage runAsync(String statementTemplate, Value parameters )
     {
         return runAsync( new Statement( statementTemplate, parameters ) );
     }
 
     @Override
-    public final CompletionStage runAsync( String statementTemplate, Map statementParameters )
+    public final CompletionStage runAsync(String statementTemplate, Map statementParameters )
     {
         return runAsync( statementTemplate, parameters( statementParameters ) );
     }
 
     @Override
-    public final CompletionStage runAsync( String statementTemplate, Record statementParameters )
+    public final CompletionStage runAsync(String statementTemplate, Record statementParameters )
     {
         return runAsync( statementTemplate, parameters( statementParameters ) );
     }
 
     @Override
-    public final CompletionStage runAsync( String statementText )
+    public final CompletionStage runAsync(String statementText )
     {
         return runAsync( statementText, Values.EmptyMap );
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncSession.java b/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncSession.java
index 1a306c16d7..f7b8a39d11 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncSession.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncSession.java
@@ -28,7 +28,7 @@
 import org.neo4j.driver.async.AsyncSession;
 import org.neo4j.driver.async.AsyncTransaction;
 import org.neo4j.driver.async.AsyncTransactionWork;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.Bookmark;
 import org.neo4j.driver.internal.util.Futures;
 
@@ -46,25 +46,25 @@ public InternalAsyncSession( NetworkSession session )
     }
 
     @Override
-    public CompletionStage runAsync( Statement statement )
+    public CompletionStage runAsync(Statement statement )
     {
         return runAsync( statement, TransactionConfig.empty() );
     }
 
     @Override
-    public CompletionStage runAsync( String statement, TransactionConfig config )
+    public CompletionStage runAsync(String statement, TransactionConfig config )
     {
         return runAsync( statement, emptyMap(), config );
     }
 
     @Override
-    public CompletionStage runAsync( String statement, Map parameters, TransactionConfig config )
+    public CompletionStage runAsync(String statement, Map parameters, TransactionConfig config )
     {
         return runAsync( new Statement( statement, parameters ), config );
     }
 
     @Override
-    public CompletionStage runAsync( Statement statement, TransactionConfig config )
+    public CompletionStage runAsync(Statement statement, TransactionConfig config )
     {
         return session.runAsync( statement, config, true );
     }
@@ -121,7 +121,7 @@ private  CompletionStage transactionAsync( AccessMode mode, AsyncTransacti
     {
         return session.retryLogic().retryAsync( () -> {
             CompletableFuture resultFuture = new CompletableFuture<>();
-            CompletionStage txFuture = session.beginTransactionAsync( mode, config );
+            CompletionStage txFuture = session.beginTransactionAsync( mode, config );
 
             txFuture.whenComplete( ( tx, completionError ) -> {
                 Throwable error = Futures.completionExceptionCause( completionError );
@@ -139,7 +139,7 @@ private  CompletionStage transactionAsync( AccessMode mode, AsyncTransacti
         } );
     }
 
-    private  void executeWork( CompletableFuture resultFuture, ExplicitTransaction tx, AsyncTransactionWork> work )
+    private  void executeWork(CompletableFuture resultFuture, UnmanagedTransaction tx, AsyncTransactionWork> work )
     {
         CompletionStage workFuture = safeExecuteWork( tx, work );
         workFuture.whenComplete( ( result, completionError ) -> {
@@ -155,7 +155,7 @@ private  void executeWork( CompletableFuture resultFuture, ExplicitTransac
         } );
     }
 
-    private  CompletionStage safeExecuteWork( ExplicitTransaction tx, AsyncTransactionWork> work )
+    private  CompletionStage safeExecuteWork(UnmanagedTransaction tx, AsyncTransactionWork> work )
     {
         // given work might fail in both async and sync way
         // async failure will result in a failed future being returned
@@ -174,7 +174,7 @@ private  CompletionStage safeExecuteWork( ExplicitTransaction tx, AsyncTra
         }
     }
 
-    private  void rollbackTxAfterFailedTransactionWork( ExplicitTransaction tx, CompletableFuture resultFuture, Throwable error )
+    private  void rollbackTxAfterFailedTransactionWork(UnmanagedTransaction tx, CompletableFuture resultFuture, Throwable error )
     {
         if ( tx.isOpen() )
         {
@@ -192,7 +192,7 @@ private  void rollbackTxAfterFailedTransactionWork( ExplicitTransaction tx, C
         }
     }
 
-    private  void closeTxAfterSucceededTransactionWork( ExplicitTransaction tx, CompletableFuture resultFuture, T result )
+    private  void closeTxAfterSucceededTransactionWork(UnmanagedTransaction tx, CompletableFuture resultFuture, T result )
     {
         if ( tx.isOpen() )
         {
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncTransaction.java b/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncTransaction.java
index 75582f6bf4..5bf1467b11 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncTransaction.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncTransaction.java
@@ -22,12 +22,12 @@
 
 import org.neo4j.driver.Statement;
 import org.neo4j.driver.async.AsyncTransaction;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 
 public class InternalAsyncTransaction extends AsyncAbstractStatementRunner implements AsyncTransaction
 {
-    private final ExplicitTransaction tx;
-    public InternalAsyncTransaction( ExplicitTransaction tx )
+    private final UnmanagedTransaction tx;
+    public InternalAsyncTransaction( UnmanagedTransaction tx )
     {
         this.tx = tx;
     }
@@ -45,7 +45,7 @@ public CompletionStage rollbackAsync()
     }
 
     @Override
-    public CompletionStage runAsync( Statement statement )
+    public CompletionStage runAsync(Statement statement )
     {
         return tx.runAsync( statement, true );
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/NetworkSession.java b/driver/src/main/java/org/neo4j/driver/internal/async/NetworkSession.java
index fb3b48658f..ac40a8c6bb 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/NetworkSession.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/NetworkSession.java
@@ -28,15 +28,15 @@
 import org.neo4j.driver.Logging;
 import org.neo4j.driver.Statement;
 import org.neo4j.driver.TransactionConfig;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.exceptions.TransactionNestingException;
 import org.neo4j.driver.internal.BookmarkHolder;
 import org.neo4j.driver.internal.DatabaseName;
 import org.neo4j.driver.internal.FailableCursor;
-import org.neo4j.driver.internal.cursor.AsyncStatementResultCursor;
-import org.neo4j.driver.internal.cursor.RxStatementResultCursor;
-import org.neo4j.driver.internal.cursor.StatementResultCursorFactory;
+import org.neo4j.driver.internal.cursor.AsyncResultCursor;
+import org.neo4j.driver.internal.cursor.RxResultCursor;
+import org.neo4j.driver.internal.cursor.ResultCursorFactory;
 import org.neo4j.driver.internal.logging.PrefixedLogger;
 import org.neo4j.driver.internal.retry.RetryLogic;
 import org.neo4j.driver.internal.spi.Connection;
@@ -58,7 +58,7 @@ public class NetworkSession
 
     private final BookmarkHolder bookmarkHolder;
     private final long fetchSize;
-    private volatile CompletionStage transactionStage = completedWithNull();
+    private volatile CompletionStage transactionStage = completedWithNull();
     private volatile CompletionStage connectionStage = completedWithNull();
     private volatile CompletionStage resultCursorStage = completedWithNull();
 
@@ -76,44 +76,44 @@ public NetworkSession( ConnectionProvider connectionProvider, RetryLogic retryLo
         this.fetchSize = fetchSize;
     }
 
-    public CompletionStage runAsync( Statement statement, TransactionConfig config, boolean waitForRunResponse )
+    public CompletionStage runAsync(Statement statement, TransactionConfig config, boolean waitForRunResponse )
     {
-        CompletionStage newResultCursorStage =
-                buildResultCursorFactory( statement, config, waitForRunResponse ).thenCompose( StatementResultCursorFactory::asyncResult );
+        CompletionStage newResultCursorStage =
+                buildResultCursorFactory( statement, config, waitForRunResponse ).thenCompose( ResultCursorFactory::asyncResult );
 
         resultCursorStage = newResultCursorStage.exceptionally( error -> null );
         return newResultCursorStage.thenApply( cursor -> cursor ); // convert the return type
     }
 
-    public CompletionStage runRx( Statement statement, TransactionConfig config )
+    public CompletionStage runRx(Statement statement, TransactionConfig config )
     {
-        CompletionStage newResultCursorStage =
-                buildResultCursorFactory( statement, config, true ).thenCompose( StatementResultCursorFactory::rxResult );
+        CompletionStage newResultCursorStage =
+                buildResultCursorFactory( statement, config, true ).thenCompose( ResultCursorFactory::rxResult );
 
         resultCursorStage = newResultCursorStage.exceptionally( error -> null );
         return newResultCursorStage;
     }
 
-    public CompletionStage beginTransactionAsync( TransactionConfig config )
+    public CompletionStage beginTransactionAsync( TransactionConfig config )
     {
         return this.beginTransactionAsync( mode, config );
     }
 
-    public CompletionStage beginTransactionAsync( AccessMode mode, TransactionConfig config )
+    public CompletionStage beginTransactionAsync( AccessMode mode, TransactionConfig config )
     {
         ensureSessionIsOpen();
 
         // create a chain that acquires connection and starts a transaction
-        CompletionStage newTransactionStage = ensureNoOpenTxBeforeStartingTx()
+        CompletionStage newTransactionStage = ensureNoOpenTxBeforeStartingTx()
                 .thenCompose( ignore -> acquireConnection( mode ) )
                 .thenCompose( connection ->
                 {
-                    ExplicitTransaction tx = new ExplicitTransaction( connection, bookmarkHolder, fetchSize );
+                    UnmanagedTransaction tx = new UnmanagedTransaction( connection, bookmarkHolder, fetchSize );
                     return tx.beginAsync( bookmarkHolder.getBookmark(), config );
                 } );
 
         // update the reference to the only known transaction
-        CompletionStage currentTransactionStage = transactionStage;
+        CompletionStage currentTransactionStage = transactionStage;
 
         transactionStage = newTransactionStage
                 .exceptionally( error -> null ) // ignore errors from starting new transaction
@@ -223,7 +223,7 @@ protected CompletionStage currentConnectionIsOpen()
                 connection.isOpen() ); // and it's still open
     }
 
-    private CompletionStage buildResultCursorFactory( Statement statement, TransactionConfig config, boolean waitForRunResponse )
+    private CompletionStage buildResultCursorFactory(Statement statement, TransactionConfig config, boolean waitForRunResponse )
     {
         ensureSessionIsOpen();
 
@@ -232,7 +232,7 @@ private CompletionStage buildResultCursorFactory(
                 .thenCompose( connection -> {
                     try
                     {
-                        StatementResultCursorFactory factory = connection.protocol()
+                        ResultCursorFactory factory = connection.protocol()
                                 .runInAutoCommitTransaction( connection, statement, bookmarkHolder, config, waitForRunResponse, fetchSize );
                         return completedFuture( factory );
                     }
@@ -328,7 +328,7 @@ private CompletionStage ensureNoOpenTx( String errorMessage )
         } );
     }
 
-    private CompletionStage existingTransactionOrNull()
+    private CompletionStage existingTransactionOrNull()
     {
         return transactionStage
                 .exceptionally( error -> null ) // handle previous connection acquisition and tx begin failures
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/ExplicitTransaction.java b/driver/src/main/java/org/neo4j/driver/internal/async/UnmanagedTransaction.java
similarity index 91%
rename from driver/src/main/java/org/neo4j/driver/internal/async/ExplicitTransaction.java
rename to driver/src/main/java/org/neo4j/driver/internal/async/UnmanagedTransaction.java
index db75352bcf..462cc5a9f8 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/ExplicitTransaction.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/UnmanagedTransaction.java
@@ -26,11 +26,11 @@
 import org.neo4j.driver.Session;
 import org.neo4j.driver.Statement;
 import org.neo4j.driver.TransactionConfig;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.internal.BookmarkHolder;
-import org.neo4j.driver.internal.cursor.AsyncStatementResultCursor;
-import org.neo4j.driver.internal.cursor.RxStatementResultCursor;
+import org.neo4j.driver.internal.cursor.AsyncResultCursor;
+import org.neo4j.driver.internal.cursor.RxResultCursor;
 import org.neo4j.driver.internal.messaging.BoltProtocol;
 import org.neo4j.driver.internal.spi.Connection;
 import org.neo4j.driver.internal.util.Futures;
@@ -38,7 +38,7 @@
 import static org.neo4j.driver.internal.util.Futures.completedWithNull;
 import static org.neo4j.driver.internal.util.Futures.failedFuture;
 
-public class ExplicitTransaction
+public class UnmanagedTransaction
 {
     private enum State
     {
@@ -66,7 +66,7 @@ private enum State
 
     private volatile State state = State.ACTIVE;
 
-    public ExplicitTransaction( Connection connection, BookmarkHolder bookmarkHolder, long fetchSize )
+    public UnmanagedTransaction(Connection connection, BookmarkHolder bookmarkHolder, long fetchSize )
     {
         this.connection = connection;
         this.protocol = connection.protocol();
@@ -75,7 +75,7 @@ public ExplicitTransaction( Connection connection, BookmarkHolder bookmarkHolder
         this.fetchSize = fetchSize;
     }
 
-    public CompletionStage beginAsync( Bookmark initialBookmark, TransactionConfig config )
+    public CompletionStage beginAsync(Bookmark initialBookmark, TransactionConfig config )
     {
         return protocol.beginTransaction( connection, initialBookmark, config )
                 .handle( ( ignore, beginError ) ->
@@ -138,19 +138,19 @@ else if ( state == State.ROLLED_BACK )
         }
     }
 
-    public CompletionStage runAsync( Statement statement, boolean waitForRunResponse )
+    public CompletionStage runAsync(Statement statement, boolean waitForRunResponse )
     {
         ensureCanRunQueries();
-        CompletionStage cursorStage =
+        CompletionStage cursorStage =
                 protocol.runInExplicitTransaction( connection, statement, this, waitForRunResponse, fetchSize ).asyncResult();
         resultCursors.add( cursorStage );
         return cursorStage.thenApply( cursor -> cursor );
     }
 
-    public CompletionStage runRx( Statement statement )
+    public CompletionStage runRx(Statement statement )
     {
         ensureCanRunQueries();
-        CompletionStage cursorStage =
+        CompletionStage cursorStage =
                 protocol.runInExplicitTransaction( connection, statement, this, false, fetchSize ).rxResult();
         resultCursors.add( cursorStage );
         return cursorStage;
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureRunner.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureRunner.java
index 181fc5acff..15ec1a4922 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureRunner.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureRunner.java
@@ -27,7 +27,7 @@
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Statement;
 import org.neo4j.driver.TransactionConfig;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.exceptions.FatalDiscoveryException;
 import org.neo4j.driver.internal.BookmarkHolder;
@@ -88,7 +88,7 @@ CompletionStage> runProcedure( Connection connection, Statement pro
     {
         return connection.protocol()
                 .runInAutoCommitTransaction( connection, procedure, bookmarkHolder, TransactionConfig.empty(), true, UNLIMITED_FETCH_SIZE )
-                .asyncResult().thenCompose( StatementResultCursor::listAsync );
+                .asyncResult().thenCompose( ResultCursor::listAsync );
     }
 
     private CompletionStage> releaseConnection( Connection connection, List records )
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncStatementResultCursor.java b/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursor.java
similarity index 84%
rename from driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncStatementResultCursor.java
rename to driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursor.java
index eefa25a3ee..e1909afcba 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncStatementResultCursor.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursor.java
@@ -19,8 +19,8 @@
 package org.neo4j.driver.internal.cursor;
 
 import org.neo4j.driver.internal.FailableCursor;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 
-public interface AsyncStatementResultCursor extends StatementResultCursor, FailableCursor
+public interface AsyncResultCursor extends ResultCursor, FailableCursor
 {
 }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncStatementResultCursorImpl.java b/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursorImpl.java
similarity index 96%
rename from driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncStatementResultCursorImpl.java
rename to driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursorImpl.java
index 6a0eb7d336..fe33c55795 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncStatementResultCursorImpl.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursorImpl.java
@@ -31,12 +31,12 @@
 import org.neo4j.driver.internal.util.Futures;
 import org.neo4j.driver.summary.ResultSummary;
 
-public class AsyncStatementResultCursorImpl implements AsyncStatementResultCursor
+public class AsyncResultCursorImpl implements AsyncResultCursor
 {
     private final RunResponseHandler runHandler;
     private final PullAllResponseHandler pullAllHandler;
 
-    public AsyncStatementResultCursorImpl( RunResponseHandler runHandler, PullAllResponseHandler pullAllHandler )
+    public AsyncResultCursorImpl(RunResponseHandler runHandler, PullAllResponseHandler pullAllHandler )
     {
         this.runHandler = runHandler;
         this.pullAllHandler = pullAllHandler;
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncStatementResultCursorOnlyFactory.java b/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursorOnlyFactory.java
similarity index 78%
rename from driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncStatementResultCursorOnlyFactory.java
rename to driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursorOnlyFactory.java
index e84313c12f..130c243d44 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncStatementResultCursorOnlyFactory.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursorOnlyFactory.java
@@ -33,7 +33,7 @@
 /**
  * Used by Bolt V1, V2, V3
  */
-public class AsyncStatementResultCursorOnlyFactory implements StatementResultCursorFactory
+public class AsyncResultCursorOnlyFactory implements ResultCursorFactory
 {
     protected final Connection connection;
     protected final Message runMessage;
@@ -41,8 +41,8 @@ public class AsyncStatementResultCursorOnlyFactory implements StatementResultCur
     protected final PullAllResponseHandler pullAllHandler;
     private final boolean waitForRunResponse;
 
-    public AsyncStatementResultCursorOnlyFactory( Connection connection, Message runMessage, RunResponseHandler runHandler,
-            PullAllResponseHandler pullHandler, boolean waitForRunResponse )
+    public AsyncResultCursorOnlyFactory(Connection connection, Message runMessage, RunResponseHandler runHandler,
+                                        PullAllResponseHandler pullHandler, boolean waitForRunResponse )
     {
         requireNonNull( connection );
         requireNonNull( runMessage );
@@ -57,7 +57,7 @@ public AsyncStatementResultCursorOnlyFactory( Connection connection, Message run
         this.waitForRunResponse = waitForRunResponse;
     }
 
-    public CompletionStage asyncResult()
+    public CompletionStage asyncResult()
     {
         // only write and flush messages when async result is wanted.
         connection.write( runMessage, runHandler ); // queues the run message, will be flushed with pull message together
@@ -67,15 +67,15 @@ public CompletionStage asyncResult()
         {
             // wait for response of RUN before proceeding
             return runHandler.runFuture().thenApply( ignore ->
-                    new DisposableAsyncStatementResultCursor( new AsyncStatementResultCursorImpl( runHandler, pullAllHandler ) ) );
+                    new DisposableAsyncResultCursor( new AsyncResultCursorImpl( runHandler, pullAllHandler ) ) );
         }
         else
         {
-            return completedFuture( new DisposableAsyncStatementResultCursor( new AsyncStatementResultCursorImpl( runHandler, pullAllHandler ) ) );
+            return completedFuture( new DisposableAsyncResultCursor( new AsyncResultCursorImpl( runHandler, pullAllHandler ) ) );
         }
     }
 
-    public CompletionStage rxResult()
+    public CompletionStage rxResult()
     {
         return Futures.failedFuture( new ClientException( "Driver is connected to the database that does not support driver reactive API. " +
                 "In order to use the driver reactive API, please upgrade to neo4j 4.0.0 or later." ) );
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/DisposableAsyncStatementResultCursor.java b/driver/src/main/java/org/neo4j/driver/internal/cursor/DisposableAsyncResultCursor.java
similarity index 93%
rename from driver/src/main/java/org/neo4j/driver/internal/cursor/DisposableAsyncStatementResultCursor.java
rename to driver/src/main/java/org/neo4j/driver/internal/cursor/DisposableAsyncResultCursor.java
index 96d9406861..bb4973db18 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cursor/DisposableAsyncStatementResultCursor.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cursor/DisposableAsyncResultCursor.java
@@ -31,12 +31,12 @@
 import static org.neo4j.driver.internal.util.Futures.completedWithNull;
 import static org.neo4j.driver.internal.util.Futures.failedFuture;
 
-public class DisposableAsyncStatementResultCursor implements AsyncStatementResultCursor
+public class DisposableAsyncResultCursor implements AsyncResultCursor
 {
-    private final AsyncStatementResultCursor delegate;
+    private final AsyncResultCursor delegate;
     private boolean isDisposed;
 
-    public DisposableAsyncStatementResultCursor( AsyncStatementResultCursor delegate )
+    public DisposableAsyncResultCursor(AsyncResultCursor delegate )
     {
         this.delegate = delegate;
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/StatementResultCursorFactory.java b/driver/src/main/java/org/neo4j/driver/internal/cursor/ResultCursorFactory.java
similarity index 82%
rename from driver/src/main/java/org/neo4j/driver/internal/cursor/StatementResultCursorFactory.java
rename to driver/src/main/java/org/neo4j/driver/internal/cursor/ResultCursorFactory.java
index 9c0cf01b96..92e9aba4ef 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cursor/StatementResultCursorFactory.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cursor/ResultCursorFactory.java
@@ -20,9 +20,9 @@
 
 import java.util.concurrent.CompletionStage;
 
-public interface StatementResultCursorFactory
+public interface ResultCursorFactory
 {
-    CompletionStage asyncResult();
+    CompletionStage asyncResult();
 
-    CompletionStage rxResult();
+    CompletionStage rxResult();
 }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/StatementResultCursorFactoryImpl.java b/driver/src/main/java/org/neo4j/driver/internal/cursor/ResultCursorFactoryImpl.java
similarity index 74%
rename from driver/src/main/java/org/neo4j/driver/internal/cursor/StatementResultCursorFactoryImpl.java
rename to driver/src/main/java/org/neo4j/driver/internal/cursor/ResultCursorFactoryImpl.java
index fe8a263787..796a8a94db 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cursor/StatementResultCursorFactoryImpl.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cursor/ResultCursorFactoryImpl.java
@@ -32,7 +32,7 @@
 /**
  * Bolt V4
  */
-public class StatementResultCursorFactoryImpl implements StatementResultCursorFactory
+public class ResultCursorFactoryImpl implements ResultCursorFactory
 {
     private final RunResponseHandler runHandler;
     private final Connection connection;
@@ -42,8 +42,8 @@ public class StatementResultCursorFactoryImpl implements StatementResultCursorFa
     private final boolean waitForRunResponse;
     private final Message runMessage;
 
-    public StatementResultCursorFactoryImpl( Connection connection, Message runMessage, RunResponseHandler runHandler, PullResponseHandler pullHandler,
-            PullAllResponseHandler pullAllHandler, boolean waitForRunResponse )
+    public ResultCursorFactoryImpl(Connection connection, Message runMessage, RunResponseHandler runHandler, PullResponseHandler pullHandler,
+                                   PullAllResponseHandler pullAllHandler, boolean waitForRunResponse )
     {
         requireNonNull( connection );
         requireNonNull( runMessage );
@@ -60,7 +60,7 @@ public StatementResultCursorFactoryImpl( Connection connection, Message runMessa
     }
 
     @Override
-    public CompletionStage asyncResult()
+    public CompletionStage asyncResult()
     {
         // only write and flush messages when async result is wanted.
         connection.write( runMessage, runHandler ); // queues the run message, will be flushed with pull message together
@@ -70,24 +70,24 @@ public CompletionStage asyncResult()
         {
             // wait for response of RUN before proceeding
             return runHandler.runFuture().thenApply(
-                    ignore -> new DisposableAsyncStatementResultCursor( new AsyncStatementResultCursorImpl( runHandler, pullAllHandler ) ) );
+                    ignore -> new DisposableAsyncResultCursor( new AsyncResultCursorImpl( runHandler, pullAllHandler ) ) );
         }
         else
         {
-            return completedFuture( new DisposableAsyncStatementResultCursor( new AsyncStatementResultCursorImpl( runHandler, pullAllHandler ) ) );
+            return completedFuture( new DisposableAsyncResultCursor( new AsyncResultCursorImpl( runHandler, pullAllHandler ) ) );
         }
     }
 
     @Override
-    public CompletionStage rxResult()
+    public CompletionStage rxResult()
     {
         connection.writeAndFlush( runMessage, runHandler );
         // we always wait for run reply
         return runHandler.runFuture().thenApply( this::composeRxCursor );
     }
 
-    private RxStatementResultCursor composeRxCursor( Throwable runError )
+    private RxResultCursor composeRxCursor(Throwable runError )
     {
-        return new RxStatementResultCursorImpl( runError, runHandler, pullHandler );
+        return new RxResultCursorImpl( runError, runHandler, pullHandler );
     }
 }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/RxStatementResultCursor.java b/driver/src/main/java/org/neo4j/driver/internal/cursor/RxResultCursor.java
similarity index 93%
rename from driver/src/main/java/org/neo4j/driver/internal/cursor/RxStatementResultCursor.java
rename to driver/src/main/java/org/neo4j/driver/internal/cursor/RxResultCursor.java
index 62bd08daa9..759f6b8a0c 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cursor/RxStatementResultCursor.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cursor/RxResultCursor.java
@@ -28,7 +28,7 @@
 import org.neo4j.driver.internal.FailableCursor;
 import org.neo4j.driver.summary.ResultSummary;
 
-public interface RxStatementResultCursor extends Subscription, FailableCursor
+public interface RxResultCursor extends Subscription, FailableCursor
 {
     List keys();
 
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/RxStatementResultCursorImpl.java b/driver/src/main/java/org/neo4j/driver/internal/cursor/RxResultCursorImpl.java
similarity index 90%
rename from driver/src/main/java/org/neo4j/driver/internal/cursor/RxStatementResultCursorImpl.java
rename to driver/src/main/java/org/neo4j/driver/internal/cursor/RxResultCursorImpl.java
index 5df771f0c6..71d74d4c65 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cursor/RxStatementResultCursorImpl.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cursor/RxResultCursorImpl.java
@@ -30,12 +30,12 @@
 import org.neo4j.driver.internal.handlers.pulln.PullResponseHandler;
 import org.neo4j.driver.summary.ResultSummary;
 
-import static org.neo4j.driver.internal.cursor.RxStatementResultCursorImpl.RecordConsumerStatus.DISCARD_INSTALLED;
-import static org.neo4j.driver.internal.cursor.RxStatementResultCursorImpl.RecordConsumerStatus.INSTALLED;
-import static org.neo4j.driver.internal.cursor.RxStatementResultCursorImpl.RecordConsumerStatus.NOT_INSTALLED;
+import static org.neo4j.driver.internal.cursor.RxResultCursorImpl.RecordConsumerStatus.DISCARD_INSTALLED;
+import static org.neo4j.driver.internal.cursor.RxResultCursorImpl.RecordConsumerStatus.INSTALLED;
+import static org.neo4j.driver.internal.cursor.RxResultCursorImpl.RecordConsumerStatus.NOT_INSTALLED;
 import static org.neo4j.driver.internal.util.ErrorUtil.newResultConsumedError;
 
-public class RxStatementResultCursorImpl implements RxStatementResultCursor
+public class RxResultCursorImpl implements RxResultCursor
 {
     static final BiConsumer DISCARD_RECORD_CONSUMER = ( record, throwable ) -> {/*do nothing*/};
     private final RunResponseHandler runHandler;
@@ -45,12 +45,12 @@ public class RxStatementResultCursorImpl implements RxStatementResultCursor
     private boolean resultConsumed;
     private RecordConsumerStatus consumerStatus = NOT_INSTALLED;
 
-    public RxStatementResultCursorImpl( RunResponseHandler runHandler, PullResponseHandler pullHandler )
+    public RxResultCursorImpl(RunResponseHandler runHandler, PullResponseHandler pullHandler )
     {
         this( null, runHandler, pullHandler );
     }
 
-    public RxStatementResultCursorImpl( Throwable runError, RunResponseHandler runHandler, PullResponseHandler pullHandler )
+    public RxResultCursorImpl(Throwable runError, RunResponseHandler runHandler, PullResponseHandler pullHandler )
     {
         Objects.requireNonNull( runHandler );
         Objects.requireNonNull( pullHandler );
diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/PullHandlers.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/PullHandlers.java
index fbcc22baec..a26b00fcb4 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/handlers/PullHandlers.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/handlers/PullHandlers.java
@@ -20,7 +20,7 @@
 
 import org.neo4j.driver.Statement;
 import org.neo4j.driver.internal.BookmarkHolder;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
 import org.neo4j.driver.internal.handlers.pulln.AutoPullResponseHandler;
 import org.neo4j.driver.internal.handlers.pulln.BasicPullResponseHandler;
 import org.neo4j.driver.internal.handlers.pulln.PullResponseHandler;
@@ -31,7 +31,7 @@
 public class PullHandlers
 {
     public static PullAllResponseHandler newBoltV1PullAllHandler( Statement statement, RunResponseHandler runHandler,
-            Connection connection, ExplicitTransaction tx )
+            Connection connection, UnmanagedTransaction tx )
     {
         PullResponseCompletionListener completionListener = createPullResponseCompletionListener( connection, BookmarkHolder.NO_OP, tx );
 
@@ -39,15 +39,15 @@ public static PullAllResponseHandler newBoltV1PullAllHandler( Statement statemen
     }
 
     public static PullAllResponseHandler newBoltV3PullAllHandler( Statement statement, RunResponseHandler runHandler, Connection connection,
-            BookmarkHolder bookmarkHolder, ExplicitTransaction tx )
+            BookmarkHolder bookmarkHolder, UnmanagedTransaction tx )
     {
         PullResponseCompletionListener completionListener = createPullResponseCompletionListener( connection, bookmarkHolder, tx );
 
         return new LegacyPullAllResponseHandler( statement, runHandler, connection, BoltProtocolV3.METADATA_EXTRACTOR, completionListener );
     }
 
-    public static PullAllResponseHandler newBoltV4AutoPullHandler( Statement statement, RunResponseHandler runHandler, Connection connection,
-            BookmarkHolder bookmarkHolder, ExplicitTransaction tx, long fetchSize )
+    public static PullAllResponseHandler newBoltV4AutoPullHandler(Statement statement, RunResponseHandler runHandler, Connection connection,
+                                                                  BookmarkHolder bookmarkHolder, UnmanagedTransaction tx, long fetchSize )
     {
         PullResponseCompletionListener completionListener = createPullResponseCompletionListener( connection, bookmarkHolder, tx );
 
@@ -56,7 +56,7 @@ public static PullAllResponseHandler newBoltV4AutoPullHandler( Statement stateme
 
 
     public static PullResponseHandler newBoltV4BasicPullHandler( Statement statement, RunResponseHandler runHandler, Connection connection,
-            BookmarkHolder bookmarkHolder, ExplicitTransaction tx )
+            BookmarkHolder bookmarkHolder, UnmanagedTransaction tx )
     {
         PullResponseCompletionListener completionListener = createPullResponseCompletionListener( connection, bookmarkHolder, tx );
 
@@ -64,7 +64,7 @@ public static PullResponseHandler newBoltV4BasicPullHandler( Statement statement
     }
 
     private static PullResponseCompletionListener createPullResponseCompletionListener( Connection connection, BookmarkHolder bookmarkHolder,
-            ExplicitTransaction tx )
+            UnmanagedTransaction tx )
     {
         return tx != null ? new TransactionPullResponseCompletionListener( tx ) : new SessionPullResponseCompletionListener( connection, bookmarkHolder );
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListener.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListener.java
index 73252c3614..76207de61b 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListener.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListener.java
@@ -21,15 +21,15 @@
 import java.util.Map;
 
 import org.neo4j.driver.Value;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
 
 import static java.util.Objects.requireNonNull;
 
 public class TransactionPullResponseCompletionListener implements PullResponseCompletionListener
 {
-    private final ExplicitTransaction tx;
+    private final UnmanagedTransaction tx;
 
-    public TransactionPullResponseCompletionListener( ExplicitTransaction tx )
+    public TransactionPullResponseCompletionListener( UnmanagedTransaction tx )
     {
         this.tx = requireNonNull( tx );
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java
index f3ea75c6cf..01be1df31e 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java
@@ -33,8 +33,8 @@
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.internal.BookmarkHolder;
 import org.neo4j.driver.internal.InternalBookmark;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
-import org.neo4j.driver.internal.cursor.StatementResultCursorFactory;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
+import org.neo4j.driver.internal.cursor.ResultCursorFactory;
 import org.neo4j.driver.internal.messaging.v1.BoltProtocolV1;
 import org.neo4j.driver.internal.messaging.v2.BoltProtocolV2;
 import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3;
@@ -106,8 +106,8 @@ public interface BoltProtocol
      * @param fetchSize the record fetch size for PULL message.
      * @return stage with cursor.
      */
-    StatementResultCursorFactory runInAutoCommitTransaction( Connection connection, Statement statement, BookmarkHolder bookmarkHolder,
-            TransactionConfig config, boolean waitForRunResponse, long fetchSize );
+    ResultCursorFactory runInAutoCommitTransaction(Connection connection, Statement statement, BookmarkHolder bookmarkHolder,
+                                                   TransactionConfig config, boolean waitForRunResponse, long fetchSize );
 
     /**
      * Execute the given statement in a running explicit transaction, i.e. {@link Transaction#run(Statement)}.
@@ -121,8 +121,8 @@ StatementResultCursorFactory runInAutoCommitTransaction( Connection connection,
      * @param fetchSize the record fetch size for PULL message.
      * @return stage with cursor.
      */
-    StatementResultCursorFactory runInExplicitTransaction( Connection connection, Statement statement, ExplicitTransaction tx, boolean waitForRunResponse,
-            long fetchSize );
+    ResultCursorFactory runInExplicitTransaction(Connection connection, Statement statement, UnmanagedTransaction tx, boolean waitForRunResponse,
+                                                 long fetchSize );
 
     /**
      * Returns the protocol version. It can be used for version specific error messages.
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1.java
index 25ea82ce57..43aa1ba40d 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1.java
@@ -33,9 +33,9 @@
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.internal.BookmarkHolder;
 import org.neo4j.driver.internal.DatabaseName;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
-import org.neo4j.driver.internal.cursor.AsyncStatementResultCursorOnlyFactory;
-import org.neo4j.driver.internal.cursor.StatementResultCursorFactory;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
+import org.neo4j.driver.internal.cursor.AsyncResultCursorOnlyFactory;
+import org.neo4j.driver.internal.cursor.ResultCursorFactory;
 import org.neo4j.driver.internal.handlers.BeginTxResponseHandler;
 import org.neo4j.driver.internal.handlers.CommitTxResponseHandler;
 import org.neo4j.driver.internal.handlers.InitResponseHandler;
@@ -159,8 +159,8 @@ public CompletionStage rollbackTransaction( Connection connection )
     }
 
     @Override
-    public StatementResultCursorFactory runInAutoCommitTransaction( Connection connection, Statement statement, BookmarkHolder bookmarkHolder,
-            TransactionConfig config, boolean waitForRunResponse, long ignored )
+    public ResultCursorFactory runInAutoCommitTransaction(Connection connection, Statement statement, BookmarkHolder bookmarkHolder,
+                                                          TransactionConfig config, boolean waitForRunResponse, long ignored )
     {
         // bookmarks are ignored for auto-commit transactions in this version of the protocol
         verifyBeforeTransaction( config, connection.databaseName() );
@@ -168,8 +168,8 @@ public StatementResultCursorFactory runInAutoCommitTransaction( Connection conne
     }
 
     @Override
-    public StatementResultCursorFactory runInExplicitTransaction( Connection connection, Statement statement, ExplicitTransaction tx,
-            boolean waitForRunResponse, long ignored )
+    public ResultCursorFactory runInExplicitTransaction(Connection connection, Statement statement, UnmanagedTransaction tx,
+                                                        boolean waitForRunResponse, long ignored )
     {
         return buildResultCursorFactory( connection, statement, tx, waitForRunResponse );
     }
@@ -180,8 +180,8 @@ public int version()
         return VERSION;
     }
 
-    private static StatementResultCursorFactory buildResultCursorFactory( Connection connection, Statement statement,
-            ExplicitTransaction tx, boolean waitForRunResponse )
+    private static ResultCursorFactory buildResultCursorFactory(Connection connection, Statement statement,
+                                                                UnmanagedTransaction tx, boolean waitForRunResponse )
     {
         String query = statement.text();
         Map params = statement.parameters().asMap( ofValue() );
@@ -190,7 +190,7 @@ private static StatementResultCursorFactory buildResultCursorFactory( Connection
         RunResponseHandler runHandler = new RunResponseHandler( METADATA_EXTRACTOR );
         PullAllResponseHandler pullAllHandler = PullHandlers.newBoltV1PullAllHandler( statement, runHandler, connection, tx );
 
-        return new AsyncStatementResultCursorOnlyFactory( connection, runMessage, runHandler, pullAllHandler, waitForRunResponse );
+        return new AsyncResultCursorOnlyFactory( connection, runMessage, runHandler, pullAllHandler, waitForRunResponse );
     }
 
     private void verifyBeforeTransaction( TransactionConfig config, DatabaseName databaseName )
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java
index 56833c2493..677b3ea3c9 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java
@@ -31,9 +31,9 @@
 import org.neo4j.driver.Value;
 import org.neo4j.driver.internal.BookmarkHolder;
 import org.neo4j.driver.internal.DatabaseName;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
-import org.neo4j.driver.internal.cursor.AsyncStatementResultCursorOnlyFactory;
-import org.neo4j.driver.internal.cursor.StatementResultCursorFactory;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
+import org.neo4j.driver.internal.cursor.AsyncResultCursorOnlyFactory;
+import org.neo4j.driver.internal.cursor.ResultCursorFactory;
 import org.neo4j.driver.internal.handlers.BeginTxResponseHandler;
 import org.neo4j.driver.internal.handlers.CommitTxResponseHandler;
 import org.neo4j.driver.internal.handlers.HelloResponseHandler;
@@ -137,8 +137,8 @@ public CompletionStage rollbackTransaction( Connection connection )
     }
 
     @Override
-    public StatementResultCursorFactory runInAutoCommitTransaction( Connection connection, Statement statement, BookmarkHolder bookmarkHolder,
-            TransactionConfig config, boolean waitForRunResponse, long fetchSize )
+    public ResultCursorFactory runInAutoCommitTransaction(Connection connection, Statement statement, BookmarkHolder bookmarkHolder,
+                                                          TransactionConfig config, boolean waitForRunResponse, long fetchSize )
     {
         verifyDatabaseNameBeforeTransaction( connection.databaseName() );
         RunWithMetadataMessage runMessage =
@@ -147,20 +147,20 @@ public StatementResultCursorFactory runInAutoCommitTransaction( Connection conne
     }
 
     @Override
-    public StatementResultCursorFactory runInExplicitTransaction( Connection connection, Statement statement, ExplicitTransaction tx,
-            boolean waitForRunResponse, long fetchSize )
+    public ResultCursorFactory runInExplicitTransaction(Connection connection, Statement statement, UnmanagedTransaction tx,
+                                                        boolean waitForRunResponse, long fetchSize )
     {
         RunWithMetadataMessage runMessage = explicitTxRunMessage( statement );
         return buildResultCursorFactory( connection, statement, BookmarkHolder.NO_OP, tx, runMessage, waitForRunResponse, fetchSize );
     }
 
-    protected StatementResultCursorFactory buildResultCursorFactory( Connection connection, Statement statement, BookmarkHolder bookmarkHolder,
-            ExplicitTransaction tx, RunWithMetadataMessage runMessage, boolean waitForRunResponse, long ignored )
+    protected ResultCursorFactory buildResultCursorFactory(Connection connection, Statement statement, BookmarkHolder bookmarkHolder,
+                                                           UnmanagedTransaction tx, RunWithMetadataMessage runMessage, boolean waitForRunResponse, long ignored )
     {
         RunResponseHandler runHandler = new RunResponseHandler( METADATA_EXTRACTOR );
         PullAllResponseHandler pullHandler = newBoltV3PullAllHandler( statement, runHandler, connection, bookmarkHolder, tx );
 
-        return new AsyncStatementResultCursorOnlyFactory( connection, runMessage, runHandler, pullHandler, waitForRunResponse );
+        return new AsyncResultCursorOnlyFactory( connection, runMessage, runHandler, pullHandler, waitForRunResponse );
     }
 
     protected void verifyDatabaseNameBeforeTransaction( DatabaseName databaseName )
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4.java
index b00134c460..cd87fe80f2 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4.java
@@ -21,9 +21,9 @@
 import org.neo4j.driver.Statement;
 import org.neo4j.driver.internal.BookmarkHolder;
 import org.neo4j.driver.internal.DatabaseName;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
-import org.neo4j.driver.internal.cursor.StatementResultCursorFactoryImpl;
-import org.neo4j.driver.internal.cursor.StatementResultCursorFactory;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
+import org.neo4j.driver.internal.cursor.ResultCursorFactoryImpl;
+import org.neo4j.driver.internal.cursor.ResultCursorFactory;
 import org.neo4j.driver.internal.handlers.PullAllResponseHandler;
 import org.neo4j.driver.internal.handlers.RunResponseHandler;
 import org.neo4j.driver.internal.handlers.pulln.PullResponseHandler;
@@ -48,15 +48,15 @@ public MessageFormat createMessageFormat()
     }
 
     @Override
-    protected StatementResultCursorFactory buildResultCursorFactory( Connection connection, Statement statement, BookmarkHolder bookmarkHolder,
-            ExplicitTransaction tx, RunWithMetadataMessage runMessage, boolean waitForRunResponse, long fetchSize )
+    protected ResultCursorFactory buildResultCursorFactory(Connection connection, Statement statement, BookmarkHolder bookmarkHolder,
+                                                           UnmanagedTransaction tx, RunWithMetadataMessage runMessage, boolean waitForRunResponse, long fetchSize )
     {
         RunResponseHandler runHandler = new RunResponseHandler( METADATA_EXTRACTOR );
 
         PullAllResponseHandler pullAllHandler = newBoltV4AutoPullHandler( statement, runHandler, connection, bookmarkHolder, tx, fetchSize );
         PullResponseHandler pullHandler = newBoltV4BasicPullHandler( statement, runHandler, connection, bookmarkHolder, tx );
 
-        return new StatementResultCursorFactoryImpl( connection, runMessage, runHandler, pullHandler, pullAllHandler, waitForRunResponse );
+        return new ResultCursorFactoryImpl( connection, runMessage, runHandler, pullHandler, pullAllHandler, waitForRunResponse );
     }
 
     @Override
diff --git a/driver/src/main/java/org/neo4j/driver/internal/reactive/AbstractRxStatementRunner.java b/driver/src/main/java/org/neo4j/driver/internal/reactive/AbstractRxStatementRunner.java
index a8f6b4558b..8aad1bf459 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/reactive/AbstractRxStatementRunner.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/reactive/AbstractRxStatementRunner.java
@@ -20,7 +20,7 @@
 
 import java.util.Map;
 
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.reactive.RxStatementRunner;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Statement;
@@ -31,25 +31,25 @@
 public abstract class AbstractRxStatementRunner implements RxStatementRunner
 {
     @Override
-    public final RxStatementResult run( String statementTemplate, Value parameters )
+    public final RxResult run(String statementTemplate, Value parameters )
     {
         return run( new Statement( statementTemplate, parameters ) );
     }
 
     @Override
-    public final RxStatementResult run( String statementTemplate, Map statementParameters )
+    public final RxResult run(String statementTemplate, Map statementParameters )
     {
         return run( statementTemplate, parameters( statementParameters ) );
     }
 
     @Override
-    public final RxStatementResult run( String statementTemplate, Record statementParameters )
+    public final RxResult run(String statementTemplate, Record statementParameters )
     {
         return run( statementTemplate, parameters( statementParameters ) );
     }
 
     @Override
-    public final RxStatementResult run( String statementTemplate )
+    public final RxResult run(String statementTemplate )
     {
         return run( new Statement( statementTemplate ) );
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxStatementResult.java b/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxResult.java
similarity index 86%
rename from driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxStatementResult.java
rename to driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxResult.java
index 03ebc3f737..de0c244075 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxStatementResult.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxResult.java
@@ -29,20 +29,20 @@
 import java.util.function.Supplier;
 
 import org.neo4j.driver.Record;
-import org.neo4j.driver.internal.cursor.RxStatementResultCursor;
+import org.neo4j.driver.internal.cursor.RxResultCursor;
 import org.neo4j.driver.internal.util.Futures;
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.summary.ResultSummary;
 
 import static org.neo4j.driver.internal.util.ErrorUtil.newResultConsumedError;
 import static reactor.core.publisher.FluxSink.OverflowStrategy.IGNORE;
 
-public class InternalRxStatementResult implements RxStatementResult
+public class InternalRxResult implements RxResult
 {
-    private Supplier> cursorFutureSupplier;
-    private volatile CompletionStage cursorFuture;
+    private Supplier> cursorFutureSupplier;
+    private volatile CompletionStage cursorFuture;
 
-    public InternalRxStatementResult( Supplier> cursorFuture )
+    public InternalRxResult(Supplier> cursorFuture )
     {
         this.cursorFutureSupplier = cursorFuture;
     }
@@ -50,7 +50,7 @@ public InternalRxStatementResult( Supplier> keys()
     {
-        return Mono.defer( () -> Mono.fromCompletionStage( getCursorFuture() ).map( RxStatementResultCursor::keys )
+        return Mono.defer( () -> Mono.fromCompletionStage( getCursorFuture() ).map( RxResultCursor::keys )
                 .onErrorMap( Futures::completionExceptionCause ) );
     }
 
@@ -105,7 +105,7 @@ else if ( e != null )
         };
     }
 
-    private CompletionStage getCursorFuture()
+    private CompletionStage getCursorFuture()
     {
         if ( cursorFuture != null )
         {
@@ -114,7 +114,7 @@ private CompletionStage getCursorFuture()
         return initCursorFuture();
     }
 
-    synchronized CompletionStage initCursorFuture()
+    synchronized CompletionStage initCursorFuture()
     {
         // A quick path to return
         if ( cursorFuture != null )
@@ -155,7 +155,7 @@ public Publisher consume()
     }
 
     // For testing purpose
-    Supplier> cursorFutureSupplier()
+    Supplier> cursorFutureSupplier()
     {
         return this.cursorFutureSupplier;
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxSession.java b/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxSession.java
index 915f51f6fc..8826a8a842 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxSession.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxSession.java
@@ -30,9 +30,9 @@
 import org.neo4j.driver.Bookmark;
 import org.neo4j.driver.exceptions.TransactionNestingException;
 import org.neo4j.driver.internal.async.NetworkSession;
-import org.neo4j.driver.internal.cursor.RxStatementResultCursor;
+import org.neo4j.driver.internal.cursor.RxResultCursor;
 import org.neo4j.driver.internal.util.Futures;
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.reactive.RxSession;
 import org.neo4j.driver.reactive.RxTransaction;
 import org.neo4j.driver.reactive.RxTransactionWork;
@@ -129,28 +129,28 @@ private  Publisher runTransaction( AccessMode mode, RxTransactionWork parameters, TransactionConfig config )
+    public RxResult run(String statement, Map parameters, TransactionConfig config )
     {
         return run( new Statement( statement, parameters ), config );
     }
 
     @Override
-    public RxStatementResult run( Statement statement )
+    public RxResult run(Statement statement )
     {
         return run( statement, TransactionConfig.empty() );
     }
 
     @Override
-    public RxStatementResult run( Statement statement, TransactionConfig config )
+    public RxResult run(Statement statement, TransactionConfig config )
     {
-        return new InternalRxStatementResult( () -> {
-            CompletableFuture resultCursorFuture = new CompletableFuture<>();
+        return new InternalRxResult( () -> {
+            CompletableFuture resultCursorFuture = new CompletableFuture<>();
             session.runRx( statement, config ).whenComplete( ( cursor, completionError ) -> {
                 if ( cursor != null )
                 {
diff --git a/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxTransaction.java b/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxTransaction.java
index 8c7d888e2e..f8b6f2fc07 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxTransaction.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxTransaction.java
@@ -23,28 +23,28 @@
 import java.util.concurrent.CompletableFuture;
 
 import org.neo4j.driver.Statement;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
-import org.neo4j.driver.internal.cursor.RxStatementResultCursor;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
+import org.neo4j.driver.internal.cursor.RxResultCursor;
 import org.neo4j.driver.internal.util.Futures;
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.reactive.RxTransaction;
 
 import static org.neo4j.driver.internal.reactive.RxUtils.createEmptyPublisher;
 
 public class InternalRxTransaction extends AbstractRxStatementRunner implements RxTransaction
 {
-    private final ExplicitTransaction tx;
+    private final UnmanagedTransaction tx;
 
-    public InternalRxTransaction( ExplicitTransaction tx )
+    public InternalRxTransaction( UnmanagedTransaction tx )
     {
         this.tx = tx;
     }
 
     @Override
-    public RxStatementResult run( Statement statement )
+    public RxResult run(Statement statement )
     {
-        return new InternalRxStatementResult( () -> {
-            CompletableFuture cursorFuture = new CompletableFuture<>();
+        return new InternalRxResult( () -> {
+            CompletableFuture cursorFuture = new CompletableFuture<>();
             tx.runRx( statement ).whenComplete( ( cursor, completionError ) -> {
                 if ( cursor != null )
                 {
diff --git a/driver/src/main/java/org/neo4j/driver/reactive/RxStatementResult.java b/driver/src/main/java/org/neo4j/driver/reactive/RxResult.java
similarity index 97%
rename from driver/src/main/java/org/neo4j/driver/reactive/RxStatementResult.java
rename to driver/src/main/java/org/neo4j/driver/reactive/RxResult.java
index 46471611b5..d1fbc85daf 100644
--- a/driver/src/main/java/org/neo4j/driver/reactive/RxStatementResult.java
+++ b/driver/src/main/java/org/neo4j/driver/reactive/RxResult.java
@@ -41,7 +41,7 @@
  * @see Subscription
  * @since 2.0
  */
-public interface RxStatementResult
+public interface RxResult
 {
     /**
      * Returns a cold publisher of keys.
@@ -69,7 +69,7 @@ public interface RxStatementResult
      * Returns a cold unicast publisher of records.
      * 

      * When the record publisher is {@linkplain Publisher#subscribe(Subscriber) subscribed},
-     * the query statement is executed and the statement result is streamed back as a record stream followed by a result summary.
+     * the query statement is executed and the result is streamed back as a record stream followed by a result summary.
      * This record publisher publishes all records in the result and signals the completion.
      * However before completion or error reporting if any, a cleanup of result resources such as network connection will be carried out automatically.
      * 

diff --git a/driver/src/main/java/org/neo4j/driver/reactive/RxSession.java b/driver/src/main/java/org/neo4j/driver/reactive/RxSession.java
index 3753bcb45a..1fce5fd888 100644
--- a/driver/src/main/java/org/neo4j/driver/reactive/RxSession.java
+++ b/driver/src/main/java/org/neo4j/driver/reactive/RxSession.java
@@ -33,7 +33,7 @@
 /**
  * A reactive session is the same as {@link Session} except it provides a reactive API.
  * @see Session
- * @see RxStatementResult
+ * @see RxResult
  * @see RxTransaction
  * @see Publisher
  * @since 2.0
@@ -161,7 +161,7 @@ public interface RxSession extends RxStatementRunner
      * @param config configuration for the new transaction.
      * @return a reactive result.
      */
-    RxStatementResult run( String statement, TransactionConfig config );
+    RxResult run(String statement, TransactionConfig config );
 
     /**
      * Run a statement with parameters in an auto-commit transaction with specified {@link TransactionConfig} and return a reactive result stream.
@@ -199,7 +199,7 @@ public interface RxSession extends RxStatementRunner
      * @param config configuration for the new transaction.
      * @return a reactive result.
      */
-    RxStatementResult run( String statement, Map parameters, TransactionConfig config );
+    RxResult run(String statement, Map parameters, TransactionConfig config );
 
     /**
      * Run a statement in an auto-commit transaction with specified {@link TransactionConfig configuration} and return a reactive result stream.
@@ -225,7 +225,7 @@ public interface RxSession extends RxStatementRunner
      * @param config configuration for the new transaction.
      * @return a reactive result.
      */
-    RxStatementResult run( Statement statement, TransactionConfig config );
+    RxResult run(Statement statement, TransactionConfig config );
 
     /**
      * Return the bookmark received following the last completed statement within this session.
diff --git a/driver/src/main/java/org/neo4j/driver/reactive/RxStatementRunner.java b/driver/src/main/java/org/neo4j/driver/reactive/RxStatementRunner.java
index 85bdfa7730..72a869f949 100644
--- a/driver/src/main/java/org/neo4j/driver/reactive/RxStatementRunner.java
+++ b/driver/src/main/java/org/neo4j/driver/reactive/RxStatementRunner.java
@@ -54,7 +54,7 @@ public interface RxStatementRunner
      * @param parameters input parameters, should be a map Value, see {@link Values#parameters(Object...)}.
      * @return a reactive result.
      */
-    RxStatementResult run( String statementTemplate, Value parameters );
+    RxResult run(String statementTemplate, Value parameters );
 
     /**
      * Register running of a statement and return a reactive result stream.
@@ -74,7 +74,7 @@ public interface RxStatementRunner
      * @param statementParameters input data for the statement
      * @return a reactive result.
      */
-    RxStatementResult run( String statementTemplate, Map statementParameters );
+    RxResult run(String statementTemplate, Map statementParameters );
 
     /**
      * Register running of a statement and return a reactive result stream.
@@ -93,7 +93,7 @@ public interface RxStatementRunner
      * @param statementParameters input data for the statement
      * @return a reactive result.
      */
-    RxStatementResult run( String statementTemplate, Record statementParameters );
+    RxResult run(String statementTemplate, Record statementParameters );
 
     /**
      * Register running of a statement and return a reactive result stream.
@@ -103,7 +103,7 @@ public interface RxStatementRunner
      * @param statementTemplate text of a Neo4j statement
      * @return a reactive result.
      */
-    RxStatementResult run( String statementTemplate );
+    RxResult run(String statementTemplate );
 
     /**
      * Register running of a statement and return a reactive result stream.
@@ -113,5 +113,5 @@ public interface RxStatementRunner
      * @param statement a Neo4j statement
      * @return a reactive result.
      */
-    RxStatementResult run( Statement statement );
+    RxResult run(Statement statement );
 }
diff --git a/driver/src/main/javadoc/overview.html b/driver/src/main/javadoc/overview.html
index d41ca8d23c..20ddf1390a 100644
--- a/driver/src/main/javadoc/overview.html
+++ b/driver/src/main/javadoc/overview.html
@@ -43,7 +43,7 @@ 
Example

         try (Session session = driver.session())
         {
             // Auto-commit transactions are a quick and easy way to wrap a read.
-            StatementResult result = session.run(
+            Result result = session.run(
                     "MATCH (a:Person) WHERE a.name STARTS WITH $x RETURN a.name AS name",
                     parameters("x", initial));
             // Each Cypher execution returns a stream of records.
diff --git a/driver/src/test/java/org/neo4j/driver/integration/ConnectionHandlingIT.java b/driver/src/test/java/org/neo4j/driver/integration/ConnectionHandlingIT.java
index 0dd91e9179..b5308d09de 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/ConnectionHandlingIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/ConnectionHandlingIT.java
@@ -39,7 +39,7 @@
 import org.neo4j.driver.Logging;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.StatementRunner;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.exceptions.ClientException;
@@ -58,7 +58,7 @@
 import org.neo4j.driver.internal.util.Clock;
 import org.neo4j.driver.internal.util.EnabledOnNeo4jWith;
 import org.neo4j.driver.reactive.RxSession;
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.reactive.RxTransaction;
 import org.neo4j.driver.summary.ResultSummary;
 import org.neo4j.driver.util.DatabaseExtension;
@@ -112,7 +112,7 @@ void closeDriver()
     @Test
     void connectionUsedForSessionRunReturnedToThePoolWhenResultConsumed()
     {
-        StatementResult result = createNodesInNewSession( 12 );
+        Result result = createNodesInNewSession( 12 );
 
         Connection connection1 = connectionPool.lastAcquiredConnectionSpy;
         verify( connection1, never() ).release();
@@ -127,7 +127,7 @@ void connectionUsedForSessionRunReturnedToThePoolWhenResultConsumed()
     @Test
     void connectionUsedForSessionRunReturnedToThePoolWhenResultSummaryObtained()
     {
-        StatementResult result = createNodesInNewSession( 5 );
+        Result result = createNodesInNewSession( 5 );
 
         Connection connection1 = connectionPool.lastAcquiredConnectionSpy;
         verify( connection1, never() ).release();
@@ -143,7 +143,7 @@ void connectionUsedForSessionRunReturnedToThePoolWhenResultSummaryObtained()
     @Test
     void connectionUsedForSessionRunReturnedToThePoolWhenResultFetchedInList()
     {
-        StatementResult result = createNodesInNewSession( 2 );
+        Result result = createNodesInNewSession( 2 );
 
         Connection connection1 = connectionPool.lastAcquiredConnectionSpy;
         verify( connection1, never() ).release();
@@ -159,7 +159,7 @@ void connectionUsedForSessionRunReturnedToThePoolWhenResultFetchedInList()
     @Test
     void connectionUsedForSessionRunReturnedToThePoolWhenSingleRecordFetched()
     {
-        StatementResult result = createNodesInNewSession( 1 );
+        Result result = createNodesInNewSession( 1 );
 
         Connection connection1 = connectionPool.lastAcquiredConnectionSpy;
         verify( connection1, never() ).release();
@@ -174,7 +174,7 @@ void connectionUsedForSessionRunReturnedToThePoolWhenSingleRecordFetched()
     @Test
     void connectionUsedForSessionRunReturnedToThePoolWhenResultFetchedAsIterator()
     {
-        StatementResult result = createNodesInNewSession( 6 );
+        Result result = createNodesInNewSession( 6 );
 
         Connection connection1 = connectionPool.lastAcquiredConnectionSpy;
         verify( connection1, never() ).release();
@@ -197,7 +197,7 @@ void connectionUsedForSessionRunReturnedToThePoolWhenServerErrorDuringResultFetc
     {
         Session session = driver.session();
         // provoke division by zero
-        StatementResult result = session.run( "UNWIND range(10, 0, -1) AS i CREATE (n {index: 10/i}) RETURN n" );
+        Result result = session.run( "UNWIND range(10, 0, -1) AS i CREATE (n {index: 10/i}) RETURN n" );
 
         Connection connection1 = connectionPool.lastAcquiredConnectionSpy;
         verify( connection1, never() ).release();
@@ -219,7 +219,7 @@ void connectionUsedForTransactionReturnedToThePoolWhenTransactionCommitted()
         Connection connection1 = connectionPool.lastAcquiredConnectionSpy;
         verify( connection1, never() ).release();
 
-        StatementResult result = createNodes( 5, tx );
+        Result result = createNodes( 5, tx );
         int size = result.list().size();
         tx.commit();
         tx.close();
@@ -241,7 +241,7 @@ void connectionUsedForTransactionReturnedToThePoolWhenTransactionRolledBack()
         Connection connection1 = connectionPool.lastAcquiredConnectionSpy;
         verify( connection1, never() ).release();
 
-        StatementResult result = createNodes( 8, tx );
+        Result result = createNodes( 8, tx );
         int size = result.list().size();
         tx.rollback();
         tx.close();
@@ -282,7 +282,7 @@ void connectionUsedForTransactionReturnedToThePoolWhenTransactionFailsToCommitte
     void connectionUsedForSessionRunReturnedToThePoolWhenSessionClose()
     {
         Session session = driver.session();
-        StatementResult result = createNodes( 12, session );
+        Result result = createNodes( 12, session );
 
         Connection connection1 = connectionPool.lastAcquiredConnectionSpy;
         verify( connection1, never() ).release();
@@ -315,7 +315,7 @@ void connectionUsedForBeginTxReturnedToThePoolWhenSessionClose()
     void sessionCloseShouldReleaseConnectionUsedBySessionRun() throws Throwable
     {
         RxSession session = driver.rxSession();
-        RxStatementResult res = session.run( "UNWIND [1,2,3,4] AS a RETURN a" );
+        RxResult res = session.run( "UNWIND [1,2,3,4] AS a RETURN a" );
 
         // When we only run but not pull
         StepVerifier.create( Flux.from( res.keys() ) ).expectNext( singletonList( "a" ) ).verifyComplete();
@@ -334,7 +334,7 @@ void sessionCloseShouldReleaseConnectionUsedBySessionRun() throws Throwable
     void resultRecordsShouldReleaseConnectionUsedBySessionRun() throws Throwable
     {
         RxSession session = driver.rxSession();
-        RxStatementResult res = session.run( "UNWIND [1,2,3,4] AS a RETURN a" );
+        RxResult res = session.run( "UNWIND [1,2,3,4] AS a RETURN a" );
         Connection connection1 = connectionPool.lastAcquiredConnectionSpy;
         assertNull( connection1 );
 
@@ -352,7 +352,7 @@ void resultRecordsShouldReleaseConnectionUsedBySessionRun() throws Throwable
     void resultSummaryShouldReleaseConnectionUsedBySessionRun() throws Throwable
     {
         RxSession session = driver.rxSession();
-        RxStatementResult res = session.run( "UNWIND [1,2,3,4] AS a RETURN a" );
+        RxResult res = session.run( "UNWIND [1,2,3,4] AS a RETURN a" );
         Connection connection1 = connectionPool.lastAcquiredConnectionSpy;
         assertNull( connection1 );
 
@@ -373,7 +373,7 @@ void txCommitShouldReleaseConnectionUsedByBeginTx() throws Throwable
             Connection connection1 = connectionPool.lastAcquiredConnectionSpy;
             verify( connection1, never() ).release();
 
-            RxStatementResult result = tx.run( "UNWIND [1,2,3,4] AS a RETURN a" );
+            RxResult result = tx.run( "UNWIND [1,2,3,4] AS a RETURN a" );
             StepVerifier.create( Flux.from( result.records() ).map( record -> record.get( "a" ).asInt() ) )
                     .expectNext( 1, 2, 3, 4 ).verifyComplete();
 
@@ -395,7 +395,7 @@ void txRollbackShouldReleaseConnectionUsedByBeginTx() throws Throwable
             Connection connection1 = connectionPool.lastAcquiredConnectionSpy;
             verify( connection1, never() ).release();
 
-            RxStatementResult result = tx.run( "UNWIND [1,2,3,4] AS a RETURN a" );
+            RxResult result = tx.run( "UNWIND [1,2,3,4] AS a RETURN a" );
             StepVerifier.create( Flux.from( result.records() ).map( record -> record.get( "a" ).asInt() ) )
                     .expectNext( 1, 2, 3, 4 ).verifyComplete();
 
@@ -427,12 +427,12 @@ void sessionCloseShouldReleaseConnectionUsedByBeginTx() throws Throwable
         verify( connection1, times( 2 ) ).release();
     }
 
-    private StatementResult createNodesInNewSession( int nodesToCreate )
+    private Result createNodesInNewSession(int nodesToCreate )
     {
         return createNodes( nodesToCreate, driver.session() );
     }
 
-    private StatementResult createNodes( int nodesToCreate, StatementRunner statementRunner )
+    private Result createNodes(int nodesToCreate, StatementRunner statementRunner )
     {
         return statementRunner.run( "UNWIND range(1, $nodesToCreate) AS i CREATE (n {index: i}) RETURN n",
                 parameters( "nodesToCreate", nodesToCreate ) );
diff --git a/driver/src/test/java/org/neo4j/driver/integration/ConnectionPoolIT.java b/driver/src/test/java/org/neo4j/driver/integration/ConnectionPoolIT.java
index 5bfae403b8..81b1704523 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/ConnectionPoolIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/ConnectionPoolIT.java
@@ -36,7 +36,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.GraphDatabase;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.util.DatabaseExtension;
@@ -154,7 +154,7 @@ private static void startAndCloseTransactions( Driver driver, int txCount )
     {
         List sessions = new ArrayList<>( txCount );
         List transactions = new ArrayList<>( txCount );
-        List results = new ArrayList<>( txCount );
+        List results = new ArrayList<>( txCount );
         try
         {
             for ( int i = 0; i < txCount; i++ )
@@ -165,13 +165,13 @@ private static void startAndCloseTransactions( Driver driver, int txCount )
                 Transaction tx = session.beginTransaction();
                 transactions.add( tx );
 
-                StatementResult result = tx.run( "RETURN 1" );
+                Result result = tx.run( "RETURN 1" );
                 results.add( result );
             }
         }
         finally
         {
-            for ( StatementResult result : results )
+            for ( Result result : results )
             {
                 result.consume();
             }
diff --git a/driver/src/test/java/org/neo4j/driver/integration/DirectDriverIT.java b/driver/src/test/java/org/neo4j/driver/integration/DirectDriverIT.java
index 3ab384701b..3b8593f72c 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/DirectDriverIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/DirectDriverIT.java
@@ -28,7 +28,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.GraphDatabase;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.internal.BoltServerAddress;
 import org.neo4j.driver.util.DatabaseExtension;
 import org.neo4j.driver.util.ParallelizableIT;
@@ -103,7 +103,7 @@ void shouldConnectIPv6Uri()
               Session session = driver.session() )
         {
             // When
-            StatementResult result = session.run( "RETURN 1" );
+            Result result = session.run( "RETURN 1" );
 
             // Then
             assertThat( result.single().get( 0 ).asInt(), CoreMatchers.equalTo( 1 ) );
diff --git a/driver/src/test/java/org/neo4j/driver/integration/EncryptionIT.java b/driver/src/test/java/org/neo4j/driver/integration/EncryptionIT.java
index 1364c497f5..15dba5a9e0 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/EncryptionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/EncryptionIT.java
@@ -26,7 +26,7 @@
 import org.neo4j.driver.GraphDatabase;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
 import org.neo4j.driver.util.DatabaseExtension;
 import org.neo4j.driver.util.Neo4jSettings;
@@ -93,7 +93,7 @@ private void testMatchingEncryption( BoltTlsLevel tlsLevel, boolean driverEncryp
 
             try ( Session session = driver.session() )
             {
-                StatementResult result = session.run( "RETURN 1" );
+                Result result = session.run( "RETURN 1" );
 
                 Record record = result.next();
                 int value = record.get( 0 ).asInt();
diff --git a/driver/src/test/java/org/neo4j/driver/integration/EntityTypeIT.java b/driver/src/test/java/org/neo4j/driver/integration/EntityTypeIT.java
index 4359705ea9..2ea0bd6b91 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/EntityTypeIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/EntityTypeIT.java
@@ -21,7 +21,7 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.types.Node;
 import org.neo4j.driver.types.Path;
 import org.neo4j.driver.types.Relationship;
@@ -41,7 +41,7 @@ class EntityTypeIT
     void shouldReturnIdentitiesOfNodes()
     {
         // When
-        StatementResult cursor = session.run( "CREATE (n) RETURN n" );
+        Result cursor = session.run( "CREATE (n) RETURN n" );
         Node node = cursor.single().get( "n" ).asNode();
 
         // Then
@@ -52,7 +52,7 @@ void shouldReturnIdentitiesOfNodes()
     void shouldReturnIdentitiesOfRelationships()
     {
         // When
-        StatementResult cursor = session.run( "CREATE ()-[r:T]->() RETURN r" );
+        Result cursor = session.run( "CREATE ()-[r:T]->() RETURN r" );
         Relationship rel = cursor.single().get( "r" ).asRelationship();
 
         // Then
@@ -65,7 +65,7 @@ void shouldReturnIdentitiesOfRelationships()
     void shouldReturnIdentitiesOfPaths()
     {
         // When
-        StatementResult cursor = session.run( "CREATE p=()-[r:T]->() RETURN p" );
+        Result cursor = session.run( "CREATE p=()-[r:T]->() RETURN p" );
         Path path = cursor.single().get( "p" ).asPath();
 
         // Then
diff --git a/driver/src/test/java/org/neo4j/driver/integration/ErrorIT.java b/driver/src/test/java/org/neo4j/driver/integration/ErrorIT.java
index a47f6e9d47..59af0ad000 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/ErrorIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/ErrorIT.java
@@ -38,7 +38,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.GraphDatabase;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
@@ -80,7 +80,7 @@ void shouldThrowHelpfulSyntaxError()
     {
         ClientException e = assertThrows( ClientException.class, () ->
         {
-            StatementResult result = session.run( "invalid statement" );
+            Result result = session.run( "invalid statement" );
             result.consume();
         } );
 
@@ -99,7 +99,7 @@ void shouldNotAllowMoreTxAfterClientException()
         // Expect
         ClientException e = assertThrows( ClientException.class, () ->
         {
-            StatementResult cursor = tx.run( "RETURN 1" );
+            Result cursor = tx.run( "RETURN 1" );
             cursor.single().get( "1" ).asInt();
         } );
         assertThat( e.getMessage(), startsWith( "Cannot run more statements in this transaction" ) );
@@ -112,7 +112,7 @@ void shouldAllowNewStatementAfterRecoverableError()
         try { session.run( "invalid" ).consume(); } catch ( ClientException e ) {/*empty*/}
 
         // When
-        StatementResult cursor = session.run( "RETURN 1" );
+        Result cursor = session.run( "RETURN 1" );
         int val = cursor.single().get( "1" ).asInt();
 
         // Then
@@ -132,7 +132,7 @@ void shouldAllowNewTransactionAfterRecoverableError()
         // When
         try ( Transaction tx = session.beginTransaction() )
         {
-            StatementResult cursor = tx.run( "RETURN 1" );
+            Result cursor = tx.run( "RETURN 1" );
             int val = cursor.single().get( "1" ).asInt();
 
             // Then
diff --git a/driver/src/test/java/org/neo4j/driver/integration/LoadCSVIT.java b/driver/src/test/java/org/neo4j/driver/integration/LoadCSVIT.java
index 40294f708d..669d594d98 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/LoadCSVIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/LoadCSVIT.java
@@ -26,7 +26,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.GraphDatabase;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.util.DatabaseExtension;
 import org.neo4j.driver.util.Neo4jSettings;
 import org.neo4j.driver.util.ParallelizableIT;
@@ -51,7 +51,7 @@ void shouldLoadCSV() throws Throwable
             String csvFileUrl = createLocalIrisData( session );
 
             // When
-            StatementResult result = session.run(
+            Result result = session.run(
                     "USING PERIODIC COMMIT 40\n" +
                     "LOAD CSV WITH HEADERS FROM $csvFileUrl AS l\n" +
                     "MATCH (c:Class {name: l.class_name})\n" +
diff --git a/driver/src/test/java/org/neo4j/driver/integration/NestedQueries.java b/driver/src/test/java/org/neo4j/driver/integration/NestedQueries.java
index 0cc5f86d11..4b5315129b 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/NestedQueries.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/NestedQueries.java
@@ -25,7 +25,7 @@
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.StatementRunner;
 import org.neo4j.driver.Transaction;
 
@@ -101,7 +101,7 @@ default void testNestedQueriesConsumedAsIterators( StatementRunner statementRunn
     {
         int recordsSeen = 0;
 
-        StatementResult result1 = statementRunner.run( OUTER_QUERY );
+        Result result1 = statementRunner.run( OUTER_QUERY );
         Thread.sleep( 1000 ); // allow some result records to arrive and be buffered
 
         while ( result1.hasNext() )
@@ -110,7 +110,7 @@ default void testNestedQueriesConsumedAsIterators( StatementRunner statementRunn
             assertFalse( record1.get( "x" ).isNull() );
             recordsSeen++;
 
-            StatementResult result2 = statementRunner.run( INNER_QUERY );
+            Result result2 = statementRunner.run( INNER_QUERY );
             while ( result2.hasNext() )
             {
                 Record record2 = result2.next();
@@ -126,7 +126,7 @@ default void testNestedQueriesConsumedAsLists( StatementRunner statementRunner )
     {
         int recordsSeen = 0;
 
-        StatementResult result1 = statementRunner.run( OUTER_QUERY );
+        Result result1 = statementRunner.run( OUTER_QUERY );
         Thread.sleep( 1000 ); // allow some result records to arrive and be buffered
 
         List records1 = result1.list();
@@ -135,7 +135,7 @@ default void testNestedQueriesConsumedAsLists( StatementRunner statementRunner )
             assertFalse( record1.get( "x" ).isNull() );
             recordsSeen++;
 
-            StatementResult result2 = statementRunner.run( "UNWIND range(1, 10) AS y RETURN y" );
+            Result result2 = statementRunner.run( "UNWIND range(1, 10) AS y RETURN y" );
             List records2 = result2.list();
             for ( Record record2 : records2 )
             {
@@ -151,7 +151,7 @@ default void testNestedQueriesConsumedAsIteratorAndList( StatementRunner stateme
     {
         int recordsSeen = 0;
 
-        StatementResult result1 = statementRunner.run( OUTER_QUERY );
+        Result result1 = statementRunner.run( OUTER_QUERY );
         Thread.sleep( 1000 ); // allow some result records to arrive and be buffered
 
         while ( result1.hasNext() )
@@ -160,7 +160,7 @@ default void testNestedQueriesConsumedAsIteratorAndList( StatementRunner stateme
             assertFalse( record1.get( "x" ).isNull() );
             recordsSeen++;
 
-            StatementResult result2 = statementRunner.run( "UNWIND range(1, 10) AS y RETURN y" );
+            Result result2 = statementRunner.run( "UNWIND range(1, 10) AS y RETURN y" );
             List records2 = result2.list();
             for ( Record record2 : records2 )
             {
diff --git a/driver/src/test/java/org/neo4j/driver/integration/ParametersIT.java b/driver/src/test/java/org/neo4j/driver/integration/ParametersIT.java
index 85be734b78..4485499eee 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/ParametersIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/ParametersIT.java
@@ -29,7 +29,7 @@
 import java.util.stream.Stream;
 
 import org.neo4j.driver.Record;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
@@ -66,7 +66,7 @@ class ParametersIT
     void shouldBeAbleToSetAndReturnBooleanProperty()
     {
         // When
-        StatementResult result = session.run(
+        Result result = session.run(
                 "CREATE (a {value:$value}) RETURN a.value", parameters( "value", true ) );
 
         // Then
@@ -82,7 +82,7 @@ void shouldBeAbleToSetAndReturnBooleanProperty()
     void shouldBeAbleToSetAndReturnByteProperty()
     {
         // When
-        StatementResult result = session.run(
+        Result result = session.run(
                 "CREATE (a {value:$value}) RETURN a.value", parameters( "value", (byte) 1 ) );
 
         // Then
@@ -98,7 +98,7 @@ void shouldBeAbleToSetAndReturnByteProperty()
     void shouldBeAbleToSetAndReturnShortProperty()
     {
         // When
-        StatementResult result = session.run(
+        Result result = session.run(
                 "CREATE (a {value:$value}) RETURN a.value", parameters( "value", (short) 1 ) );
 
         // Then
@@ -114,7 +114,7 @@ void shouldBeAbleToSetAndReturnShortProperty()
     void shouldBeAbleToSetAndReturnIntegerProperty()
     {
         // When
-        StatementResult result = session.run(
+        Result result = session.run(
                 "CREATE (a {value:$value}) RETURN a.value", parameters( "value", 1 ) );
 
         // Then
@@ -131,7 +131,7 @@ void shouldBeAbleToSetAndReturnIntegerProperty()
     void shouldBeAbleToSetAndReturnLongProperty()
     {
         // When
-        StatementResult result = session.run(
+        Result result = session.run(
                 "CREATE (a {value:$value}) RETURN a.value", parameters( "value", 1L ) );
 
         // Then
@@ -148,7 +148,7 @@ void shouldBeAbleToSetAndReturnLongProperty()
     void shouldBeAbleToSetAndReturnDoubleProperty()
     {
         // When
-        StatementResult result = session.run(
+        Result result = session.run(
                 "CREATE (a {value:$value}) RETURN a.value", parameters( "value", 6.28 ) );
 
         // Then
@@ -186,7 +186,7 @@ void shouldBeAbleToSetAndReturnBooleanArrayProperty()
     {
         // When
         boolean[] arrayValue = new boolean[]{true, true, true};
-        StatementResult result = session.run(
+        Result result = session.run(
                 "CREATE (a {value:$value}) RETURN a.value", parameters( "value", arrayValue ) );
 
         // Then
@@ -209,7 +209,7 @@ void shouldBeAbleToSetAndReturnIntegerArrayProperty()
     {
         // When
         int[] arrayValue = new int[]{42, 42, 42};
-        StatementResult result = session.run(
+        Result result = session.run(
                 "CREATE (a {value:$value}) RETURN a.value", parameters( "value", arrayValue ) );
 
         // Then
@@ -232,7 +232,7 @@ void shouldBeAbleToSetAndReturnDoubleArrayProperty()
     {
         // When
         double[] arrayValue = new double[]{6.28, 6.28, 6.28};
-        StatementResult result = session.run(
+        Result result = session.run(
                 "CREATE (a {value:$value}) RETURN a.value", parameters( "value", arrayValue ) );
 
         // Then
@@ -260,7 +260,7 @@ private static void testStringArrayContaining( String str )
     {
         String[] arrayValue = new String[]{str, str, str};
 
-        StatementResult result = session.run(
+        Result result = session.run(
                 "CREATE (a {value:$value}) RETURN a.value", parameters( "value", arrayValue ) );
 
         // Then
@@ -303,7 +303,7 @@ void shouldHandleLargeString()
     void shouldBeAbleToSetAndReturnBooleanPropertyWithinMap()
     {
         // When
-        StatementResult result = session.run(
+        Result result = session.run(
                 "CREATE (a {value:$value.v}) RETURN a.value",
                 parameters( "value", parameters( "v", true ) ) );
 
@@ -321,7 +321,7 @@ void shouldBeAbleToSetAndReturnBooleanPropertyWithinMap()
     void shouldBeAbleToSetAndReturnIntegerPropertyWithinMap()
     {
         // When
-        StatementResult result = session.run(
+        Result result = session.run(
                 "CREATE (a {value:$value.v}) RETURN a.value",
                 parameters( "value", parameters( "v", 42 ) ) );
 
@@ -339,7 +339,7 @@ void shouldBeAbleToSetAndReturnIntegerPropertyWithinMap()
     void shouldBeAbleToSetAndReturnDoublePropertyWithinMap()
     {
         // When
-        StatementResult result = session.run(
+        Result result = session.run(
                 "CREATE (a {value:$value.v}) RETURN a.value",
                 parameters( "value", parameters( "v", 6.28 ) ) );
 
@@ -357,7 +357,7 @@ void shouldBeAbleToSetAndReturnDoublePropertyWithinMap()
     void shouldBeAbleToSetAndReturnStringPropertyWithinMap()
     {
         // When
-        StatementResult result = session.run(
+        Result result = session.run(
                 "CREATE (a {value:$value.v}) RETURN a.value",
                 parameters( "value", parameters( "v", "Mjölnir" ) ) );
 
@@ -455,7 +455,7 @@ void shouldAcceptStreamsAsQueryParameters()
     {
         Stream stream = Stream.of( 1, 2, 3, 4, 5, 42 );
 
-        StatementResult result = session.run( "RETURN $value", singletonMap( "value", stream ) );
+        Result result = session.run( "RETURN $value", singletonMap( "value", stream ) );
         Value receivedValue = result.single().get( 0 );
 
         assertEquals( asList( 1, 2, 3, 4, 5, 42 ), receivedValue.asList( ofInteger() ) );
@@ -463,7 +463,7 @@ void shouldAcceptStreamsAsQueryParameters()
 
     private static void testBytesProperty( byte[] array )
     {
-        StatementResult result = session.run( "CREATE (a {value:$value}) RETURN a.value", parameters( "value", array ) );
+        Result result = session.run( "CREATE (a {value:$value}) RETURN a.value", parameters( "value", array ) );
 
         for ( Record record : result.list() )
         {
@@ -475,7 +475,7 @@ private static void testBytesProperty( byte[] array )
 
     private static void testStringProperty( String string )
     {
-        StatementResult result = session.run(
+        Result result = session.run(
                 "CREATE (a {value:$value}) RETURN a.value", parameters( "value", string ) );
 
         for ( Record record : result.list() )
@@ -503,7 +503,7 @@ private static void expectIOExceptionWithMessage( Value value, String message )
 
     private static void testSendAndReceiveValue( Object value )
     {
-        StatementResult result = session.run( "RETURN $value", singletonMap( "value", value ) );
+        Result result = session.run( "RETURN $value", singletonMap( "value", value ) );
         Object receivedValue = result.single().get( 0 ).asObject();
         assertArrayEquals( new Object[]{value}, new Object[]{receivedValue} );
     }
diff --git a/driver/src/test/java/org/neo4j/driver/integration/ResultStreamIT.java b/driver/src/test/java/org/neo4j/driver/integration/ResultStreamIT.java
index ef100da112..72e0633194 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/ResultStreamIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/ResultStreamIT.java
@@ -28,7 +28,7 @@
 import java.util.stream.IntStream;
 
 import org.neo4j.driver.Record;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.exceptions.ClientException;
@@ -61,7 +61,7 @@ class ResultStreamIT
     void shouldAllowIteratingOverResultStream()
     {
         // When
-        StatementResult res = session.run( "UNWIND [1,2,3,4] AS a RETURN a" );
+        Result res = session.run( "UNWIND [1,2,3,4] AS a RETURN a" );
 
         // Then I should be able to iterate over the result
         int idx = 1;
@@ -75,7 +75,7 @@ void shouldAllowIteratingOverResultStream()
     void shouldHaveFieldNamesInResult()
     {
         // When
-        StatementResult res = session.run( "CREATE (n:TestNode {name:'test'}) RETURN n" );
+        Result res = session.run( "CREATE (n:TestNode {name:'test'}) RETURN n" );
 
         // Then
         assertEquals( "[n]", res.keys().toString() );
@@ -87,7 +87,7 @@ void shouldHaveFieldNamesInResult()
     void shouldGiveHelpfulFailureMessageWhenAccessNonExistingField()
     {
         // Given
-        StatementResult rs =
+        Result rs =
                 session.run( "CREATE (n:Person {name:$name}) RETURN n", parameters( "name", "Tom Hanks" ) );
 
         // When
@@ -101,7 +101,7 @@ void shouldGiveHelpfulFailureMessageWhenAccessNonExistingField()
     void shouldGiveHelpfulFailureMessageWhenAccessNonExistingPropertyOnNode()
     {
         // Given
-        StatementResult rs =
+        Result rs =
                 session.run( "CREATE (n:Person {name:$name}) RETURN n", parameters( "name", "Tom Hanks" ) );
 
         // When
@@ -115,7 +115,7 @@ void shouldGiveHelpfulFailureMessageWhenAccessNonExistingPropertyOnNode()
     void shouldNotReturnNullKeysOnEmptyResult()
     {
         // Given
-        StatementResult rs = session.run( "CREATE (n:Person {name:$name})", parameters( "name", "Tom Hanks" ) );
+        Result rs = session.run( "CREATE (n:Person {name:$name})", parameters( "name", "Tom Hanks" ) );
 
         // THEN
         assertNotNull( rs.keys() );
@@ -125,11 +125,11 @@ void shouldNotReturnNullKeysOnEmptyResult()
     void shouldBeAbleToReuseSessionAfterFailure()
     {
         // Given
-        StatementResult res1 = session.run( "INVALID" );
+        Result res1 = session.run( "INVALID" );
         assertThrows( Exception.class, res1::consume );
 
         // When
-        StatementResult res2 = session.run( "RETURN 1" );
+        Result res2 = session.run( "RETURN 1" );
 
         // Then
         assertTrue( res2.hasNext() );
@@ -140,7 +140,7 @@ void shouldBeAbleToReuseSessionAfterFailure()
     void shouldBeAbleToAccessSummaryAfterFailure()
     {
         // Given
-        StatementResult res1 = session.run( "INVALID" );
+        Result res1 = session.run( "INVALID" );
         ResultSummary summary;
 
         // When
@@ -157,19 +157,19 @@ void shouldBeAbleToAccessSummaryAfterFailure()
     @Test
     void shouldBeAbleToAccessSummaryAfterTransactionFailure()
     {
-        AtomicReference resultRef = new AtomicReference<>();
+        AtomicReference resultRef = new AtomicReference<>();
 
         assertThrows( ClientException.class, () ->
         {
             try ( Transaction tx = session.beginTransaction() )
             {
-                StatementResult result = tx.run( "UNWIND [1,2,0] AS x RETURN 10/x" );
+                Result result = tx.run( "UNWIND [1,2,0] AS x RETURN 10/x" );
                 resultRef.set( result );
                 tx.commit();
             }
         } );
 
-        StatementResult result = resultRef.get();
+        Result result = resultRef.get();
         assertNotNull( result );
         assertEquals( 0, result.consume().counters().nodesCreated() );
     }
@@ -177,7 +177,7 @@ void shouldBeAbleToAccessSummaryAfterTransactionFailure()
     @Test
     void shouldHasNoElementsAfterFailure()
     {
-        StatementResult result = session.run( "INVALID" );
+        Result result = session.run( "INVALID" );
 
         assertThrows( ClientException.class, result::hasNext );
         assertFalse( result.hasNext() );
@@ -186,14 +186,14 @@ void shouldHasNoElementsAfterFailure()
     @Test
     void shouldBeAnEmptyLitAfterFailure()
     {
-        StatementResult result = session.run( "UNWIND (0, 1) as i RETURN 10 / i" );
+        Result result = session.run( "UNWIND (0, 1) as i RETURN 10 / i" );
 
         assertThrows( ClientException.class, result::list );
         assertTrue( result.list().isEmpty() );
     }
 
     @Test
-    void shouldConvertEmptyStatementResultToStream()
+    void shouldConvertEmptyResultToStream()
     {
         long count = session.run( "MATCH (n:WrongLabel) RETURN n" )
                 .stream()
@@ -209,7 +209,7 @@ void shouldConvertEmptyStatementResultToStream()
     }
 
     @Test
-    void shouldConvertStatementResultToStream()
+    void shouldConvertResultToStream()
     {
         List receivedList = session.run( "UNWIND range(1, 10) AS x RETURN x" )
                 .stream()
@@ -221,7 +221,7 @@ void shouldConvertStatementResultToStream()
     }
 
     @Test
-    void shouldConvertImmediatelyFailingStatementResultToStream()
+    void shouldConvertImmediatelyFailingResultToStream()
     {
         List seen = new ArrayList<>();
 
@@ -236,7 +236,7 @@ void shouldConvertImmediatelyFailingStatementResultToStream()
     }
 
     @Test
-    void shouldConvertEventuallyFailingStatementResultToStream()
+    void shouldConvertEventuallyFailingResultToStream()
     {
         List seen = new ArrayList<>();
 
@@ -254,7 +254,7 @@ void shouldConvertEventuallyFailingStatementResultToStream()
     @Test
     void shouldEmptyResultWhenConvertedToStream()
     {
-        StatementResult result = session.run( "UNWIND range(1, 10) AS x RETURN x" );
+        Result result = session.run( "UNWIND range(1, 10) AS x RETURN x" );
 
         assertTrue( result.hasNext() );
         assertEquals( 1, result.next().get( 0 ).asInt() );
diff --git a/driver/src/test/java/org/neo4j/driver/integration/RoutingDriverBoltKitTest.java b/driver/src/test/java/org/neo4j/driver/integration/RoutingDriverBoltKitTest.java
index 6405ac0662..8003012d45 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/RoutingDriverBoltKitTest.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/RoutingDriverBoltKitTest.java
@@ -40,7 +40,7 @@
 import org.neo4j.driver.Logger;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.TransactionWork;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
@@ -933,7 +933,7 @@ void shouldAcceptRoutingTableWithoutWritersAndThenRediscover() throws Exception
 
                 assertEquals( asList( "Bob", "Alice", "Tina" ), readStrings( "MATCH (n) RETURN n.name", session ) );
 
-                StatementResult createResult = session.run( "CREATE (n {name:'Bob'})" );
+                Result createResult = session.run( "CREATE (n {name:'Bob'})" );
                 assertFalse( createResult.hasNext() );
             }
         }
@@ -960,11 +960,11 @@ void shouldTreatRoutingTableWithSingleRouterAsValid() throws Exception
             // returned routing table contains only one router, this should be fine and we should be able to
             // read multiple times without additional rediscovery
 
-            StatementResult readResult1 = session.run( "MATCH (n) RETURN n.name" );
+            Result readResult1 = session.run( "MATCH (n) RETURN n.name" );
             assertEquals( 3, readResult1.list().size() );
             assertEquals( "127.0.0.1:9003", readResult1.consume().server().address() );
 
-            StatementResult readResult2 = session.run( "MATCH (n) RETURN n.name" );
+            Result readResult2 = session.run( "MATCH (n) RETURN n.name" );
             assertEquals( 3, readResult2.list().size() );
             assertEquals( "127.0.0.1:9004", readResult2.consume().server().address() );
         }
diff --git a/driver/src/test/java/org/neo4j/driver/integration/RoutingDriverIT.java b/driver/src/test/java/org/neo4j/driver/integration/RoutingDriverIT.java
index 67a21964ce..81afb78a6e 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/RoutingDriverIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/RoutingDriverIT.java
@@ -27,7 +27,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.GraphDatabase;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.internal.util.EnabledOnNeo4jWith;
 import org.neo4j.driver.internal.util.Neo4jFeature;
 import org.neo4j.driver.util.DatabaseExtension;
@@ -55,7 +55,7 @@ void shouldBeAbleToConnectSingleInstanceWithNeo4jScheme() throws Throwable
         {
             assertThat( driver, is( clusterDriver() ) );
 
-            StatementResult result = session.run( "RETURN 1" );
+            Result result = session.run( "RETURN 1" );
             assertThat( result.single().get( 0 ).asInt(), CoreMatchers.equalTo( 1 ) );
         }
     }
@@ -69,7 +69,7 @@ void shouldBeAbleToRunQueryOnNeo4j() throws Throwable
         {
             assertThat( driver, is( clusterDriver() ) );
 
-            StatementResult result = session.run( "RETURN 1" );
+            Result result = session.run( "RETURN 1" );
             assertThat( result.single().get( 0 ).asInt(), CoreMatchers.equalTo( 1 ) );
         }
     }
diff --git a/driver/src/test/java/org/neo4j/driver/integration/ScalarTypeIT.java b/driver/src/test/java/org/neo4j/driver/integration/ScalarTypeIT.java
index 2ea6de42df..e62ea598b8 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/ScalarTypeIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/ScalarTypeIT.java
@@ -36,7 +36,7 @@
 import org.neo4j.driver.internal.value.MapValue;
 import org.neo4j.driver.internal.value.NullValue;
 import org.neo4j.driver.internal.value.StringValue;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.Values;
 import org.neo4j.driver.util.ParallelizableIT;
@@ -74,7 +74,7 @@ static Stream typesToTest()
     void shouldHandleType( String statement, Value expectedValue )
     {
         // When
-        StatementResult cursor = session.run( statement );
+        Result cursor = session.run( statement );
 
         // Then
         assertThat( cursor.single().get( "v" ), equalTo( expectedValue ) );
@@ -245,7 +245,7 @@ private Stream toValueStream( Stream arguments )
     private void verifyCanEncodeAndDecode( Value input )
     {
         // When
-        StatementResult cursor = session.run( "RETURN $x as y", parameters( "x", input ) );
+        Result cursor = session.run( "RETURN $x as y", parameters( "x", input ) );
 
         // Then
         assertThat( cursor.single().get( "y" ), equalTo( input ) );
diff --git a/driver/src/test/java/org/neo4j/driver/integration/SessionBoltV3IT.java b/driver/src/test/java/org/neo4j/driver/integration/SessionBoltV3IT.java
index f3343f6748..8d18312d5c 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/SessionBoltV3IT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/SessionBoltV3IT.java
@@ -34,11 +34,11 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.async.AsyncSession;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.TransientException;
 import org.neo4j.driver.internal.cluster.RoutingSettings;
 import org.neo4j.driver.internal.messaging.Message;
@@ -87,7 +87,7 @@ void shouldSetTransactionMetadata()
                 .build();
 
         // call listTransactions procedure that should list itself with the specified metadata
-        StatementResult result = driver.session().run( "CALL dbms.listTransactions()", config );
+        Result result = driver.session().run( "CALL dbms.listTransactions()", config );
         Map receivedMetadata = result.single().get( "metaData" ).asMap();
 
         assertEquals( metadata, receivedMetadata );
@@ -107,7 +107,7 @@ void shouldSetTransactionMetadataAsync()
         // call listTransactions procedure that should list itself with the specified metadata
         CompletionStage> metadataFuture = driver.asyncSession()
                 .runAsync( "CALL dbms.listTransactions()", config )
-                .thenCompose( StatementResultCursor::singleAsync )
+                .thenCompose( ResultCursor::singleAsync )
                 .thenApply( record -> record.get( "metaData" ).asMap() );
 
         assertEquals( metadata, await( metadataFuture ) );
@@ -160,7 +160,7 @@ void shouldSetTransactionTimeoutAsync()
 
                     // run a query in an auto-commit transaction with timeout and try to update the locked dummy node
                     CompletionStage resultFuture = asyncSession.runAsync( "MATCH (n:Node) SET n.prop = 2", config )
-                            .thenCompose( StatementResultCursor::consumeAsync );
+                            .thenCompose( ResultCursor::consumeAsync );
 
                     TransientException error = assertThrows( TransientException.class, () -> await( resultFuture ) );
 
@@ -331,8 +331,8 @@ private static void testTransactionMetadataWithAsyncTransactionFunctions( boolea
 
         // call listTransactions procedure that should list itself with the specified metadata
         CompletionStage singleFuture =
-                read ? asyncSession.readTransactionAsync( tx -> tx.runAsync( "CALL dbms.listTransactions()" ).thenCompose( StatementResultCursor::singleAsync ), config )
-                     : asyncSession.writeTransactionAsync( tx -> tx.runAsync( "CALL dbms.listTransactions()" ).thenCompose( StatementResultCursor::singleAsync ), config );
+                read ? asyncSession.readTransactionAsync( tx -> tx.runAsync( "CALL dbms.listTransactions()" ).thenCompose( ResultCursor::singleAsync ), config )
+                     : asyncSession.writeTransactionAsync( tx -> tx.runAsync( "CALL dbms.listTransactions()" ).thenCompose( ResultCursor::singleAsync ), config );
 
         CompletionStage> metadataFuture = singleFuture.thenApply( record -> record.get( "metaData" ).asMap() );
 
diff --git a/driver/src/test/java/org/neo4j/driver/integration/SessionIT.java b/driver/src/test/java/org/neo4j/driver/integration/SessionIT.java
index 6f3a0a38d1..62ada8e703 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/SessionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/SessionIT.java
@@ -43,7 +43,7 @@
 import org.neo4j.driver.GraphDatabase;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.StatementRunner;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.TransactionWork;
@@ -60,7 +60,7 @@
 import org.neo4j.driver.internal.util.DriverFactoryWithOneEventLoopThread;
 import org.neo4j.driver.internal.util.EnabledOnNeo4jWith;
 import org.neo4j.driver.reactive.RxSession;
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.summary.ResultSummary;
 import org.neo4j.driver.summary.StatementType;
 import org.neo4j.driver.util.DatabaseExtension;
@@ -276,7 +276,7 @@ void writeTxRetriedUntilFailure()
 
             try ( Session session = driver.session() )
             {
-                StatementResult result = session.run( "MATCH (p:Person {name: 'Ronan'}) RETURN count(p)" );
+                Result result = session.run( "MATCH (p:Person {name: 'Ronan'}) RETURN count(p)" );
                 assertEquals( 0, result.single().get( 0 ).asInt() );
             }
 
@@ -300,7 +300,7 @@ void writeTxRetryErrorsAreCollected()
 
             try ( Session session = driver.session() )
             {
-                StatementResult result = session.run( "MATCH (p:Person {name: 'Ronan'}) RETURN count(p)" );
+                Result result = session.run( "MATCH (p:Person {name: 'Ronan'}) RETURN count(p)" );
                 assertEquals( 0, result.single().get( 0 ).asInt() );
             }
 
@@ -356,7 +356,7 @@ void writeTxCommittedWithoutTxSuccess()
 
             try ( Session session = driver.session() )
             {
-                StatementResult result = session.run( "MATCH (p:Person {name: 'Thor Odinson'}) RETURN count(p)" );
+                Result result = session.run( "MATCH (p:Person {name: 'Thor Odinson'}) RETURN count(p)" );
                 assertEquals( 1, result.single().get( 0 ).asInt() );
             }
         }
@@ -372,7 +372,7 @@ void readTxRolledBackWithTxFailure()
 
             long answer = session.readTransaction( tx ->
             {
-                StatementResult result = tx.run( "RETURN 42" );
+                Result result = tx.run( "RETURN 42" );
                 long single = result.single().get( 0 ).asLong();
                 tx.rollback();
                 return single;
@@ -403,7 +403,7 @@ void writeTxRolledBackWithTxFailure()
 
             try ( Session session = driver.session() )
             {
-                StatementResult result = session.run( "MATCH (p:Person {name: 'Natasha Romanoff'}) RETURN count(p)" );
+                Result result = session.run( "MATCH (p:Person {name: 'Natasha Romanoff'}) RETURN count(p)" );
                 assertEquals( 0, result.single().get( 0 ).asInt() );
             }
         }
@@ -420,7 +420,7 @@ void readTxRolledBackWhenExceptionIsThrown()
             assertThrows( IllegalStateException.class, () ->
                     session.readTransaction( tx ->
                     {
-                        StatementResult result = tx.run( "RETURN 42" );
+                        Result result = tx.run( "RETURN 42" );
                         if ( result.single().get( 0 ).asLong() == 42 )
                         {
                             throw new IllegalStateException();
@@ -450,7 +450,7 @@ void writeTxRolledBackWhenExceptionIsThrown()
 
             try ( Session session = driver.session() )
             {
-                StatementResult result = session.run( "MATCH (p:Person {name: 'Natasha Romanoff'}) RETURN count(p)" );
+                Result result = session.run( "MATCH (p:Person {name: 'Natasha Romanoff'}) RETURN count(p)" );
                 assertEquals( 0, result.single().get( 0 ).asInt() );
             }
         }
@@ -463,7 +463,7 @@ void readTxRolledBackWhenMarkedBothSuccessAndFailure()
               Session session = driver.session() )
         {
             ClientException error = assertThrows( ClientException.class, () -> session.readTransaction( tx -> {
-                StatementResult result = tx.run( "RETURN 42" );
+                Result result = tx.run( "RETURN 42" );
                 tx.commit();
                 tx.rollback();
                 return result.single().get( 0 ).asLong();
@@ -530,7 +530,7 @@ void writeTxCommittedWhenCommitAndThrowsException()
 
             try ( Session session = driver.session() )
             {
-                StatementResult result = session.run( "MATCH (p:Person {name: 'Natasha Romanoff'}) RETURN count(p)" );
+                Result result = session.run( "MATCH (p:Person {name: 'Natasha Romanoff'}) RETURN count(p)" );
                 assertEquals( 1, result.single().get( 0 ).asInt() );
             }
         }
@@ -575,7 +575,7 @@ void writeTxRolledBackWhenRollbackAndThrowsException()
 
             try ( Session session = driver.session() )
             {
-                StatementResult result = session.run( "MATCH (p:Person {name: 'Natasha Romanoff'}) RETURN count(p)" );
+                Result result = session.run( "MATCH (p:Person {name: 'Natasha Romanoff'}) RETURN count(p)" );
                 assertEquals( 0, result.single().get( 0 ).asInt() );
             }
         }
@@ -788,7 +788,7 @@ void shouldNotPropagateFailureWhenStreamingIsCancelled()
     @Test
     void shouldNotBePossibleToConsumeResultAfterSessionIsClosed()
     {
-        StatementResult result;
+        Result result;
         try ( Session session = neo4j.driver().session() )
         {
             result = session.run( "UNWIND range(1, 20000) AS x RETURN x" );
@@ -802,7 +802,7 @@ void shouldPropagateFailureFromSummary()
     {
         try ( Session session = neo4j.driver().session() )
         {
-            StatementResult result = session.run( "RETURN Wrong" );
+            Result result = session.run( "RETURN Wrong" );
 
             ClientException e = assertThrows( ClientException.class, result::consume );
             assertThat( e.code(), containsString( "SyntaxError" ) );
@@ -902,7 +902,7 @@ void shouldReportFailureInClose()
     {
         Session session = neo4j.driver().session();
 
-        StatementResult result = session.run( "CYPHER runtime=interpreted UNWIND [2, 4, 8, 0] AS x RETURN 32 / x" );
+        Result result = session.run( "CYPHER runtime=interpreted UNWIND [2, 4, 8, 0] AS x RETURN 32 / x" );
 
         ClientException e = assertThrows( ClientException.class, session::close );
         assertThat( e, is( arithmeticError() ) );
@@ -916,7 +916,7 @@ void shouldNotAllowAccessingRecordsAfterSummary()
 
         try ( Session session = neo4j.driver().session() )
         {
-            StatementResult result = session.run( query );
+            Result result = session.run( query );
 
             ResultSummary summary = result.consume();
             assertEquals( query, summary.statement().text() );
@@ -932,7 +932,7 @@ void shouldNotAllowAccessingRecordsAfterSessionClosed()
         int recordCount = 11_333;
         String query = "UNWIND range(1, " + recordCount + ") AS x RETURN 'Result-' + x";
 
-        StatementResult result;
+        Result result;
         try ( Session session = neo4j.driver().session() )
         {
             result = session.run( query );
@@ -946,7 +946,7 @@ void shouldAllowToConsumeRecordsSlowlyAndCloseSession() throws InterruptedExcept
     {
         Session session = neo4j.driver().session();
 
-        StatementResult result = session.run( "UNWIND range(10000, 0, -1) AS x RETURN 10 / x" );
+        Result result = session.run( "UNWIND range(10000, 0, -1) AS x RETURN 10 / x" );
 
         // summary couple records slowly with a sleep in-between
         for ( int i = 0; i < 10; i++ )
@@ -965,7 +965,7 @@ void shouldAllowToConsumeRecordsSlowlyAndRetrieveSummary() throws InterruptedExc
     {
         try ( Session session = neo4j.driver().session() )
         {
-            StatementResult result = session.run( "UNWIND range(8000, 1, -1) AS x RETURN 42 / x" );
+            Result result = session.run( "UNWIND range(8000, 1, -1) AS x RETURN 42 / x" );
 
             // summary couple records slowly with a sleep in-between
             for ( int i = 0; i < 12; i++ )
@@ -1068,7 +1068,7 @@ void shouldAllowIteratingOverEmptyResult()
     {
         try ( Session session = neo4j.driver().session() )
         {
-            StatementResult result = session.run( "UNWIND [] AS x RETURN x" );
+            Result result = session.run( "UNWIND [] AS x RETURN x" );
             assertFalse( result.hasNext() );
 
             assertThrows( NoSuchElementException.class, result::next );
@@ -1080,7 +1080,7 @@ void shouldAllowConsumingEmptyResult()
     {
         try ( Session session = neo4j.driver().session() )
         {
-            StatementResult result = session.run( "UNWIND [] AS x RETURN x" );
+            Result result = session.run( "UNWIND [] AS x RETURN x" );
             ResultSummary summary = result.consume();
             assertNotNull( summary );
             assertEquals( StatementType.READ_ONLY, summary.statementType() );
@@ -1092,7 +1092,7 @@ void shouldAllowListEmptyResult()
     {
         try ( Session session = neo4j.driver().session() )
         {
-            StatementResult result = session.run( "UNWIND [] AS x RETURN x" );
+            Result result = session.run( "UNWIND [] AS x RETURN x" );
             assertEquals( emptyList(), result.list() );
         }
     }
@@ -1103,7 +1103,7 @@ void shouldReportFailureInSummary()
         try ( Session session = neo4j.driver().session() )
         {
             String query = "UNWIND [1, 2, 3, 4, 0] AS x RETURN 10 / x";
-            StatementResult result = session.run( query );
+            Result result = session.run( query );
 
             ClientException e = assertThrows( ClientException.class, result::consume );
             assertThat( e, is( arithmeticError() ) );
@@ -1179,13 +1179,13 @@ void shouldSupportNestedQueries()
             int seenResources = 0;
 
             // read properties and resources using a single session
-            StatementResult properties = session.run( "MATCH (p:Property) RETURN p" );
+            Result properties = session.run( "MATCH (p:Property) RETURN p" );
             while ( properties.hasNext() )
             {
                 assertNotNull( properties.next() );
                 seenProperties++;
 
-                StatementResult resources = session.run( "MATCH (r:Resource) RETURN r" );
+                Result resources = session.run( "MATCH (r:Resource) RETURN r" );
                 while ( resources.hasNext() )
                 {
                     assertNotNull( resources.next() );
@@ -1204,7 +1204,7 @@ void shouldErrorWhenTryingToUseRxAPIWithoutBoltV4() throws Throwable
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult result = session.run( "RETURN 1" );
+        RxResult result = session.run( "RETURN 1" );
 
         // When trying to run the query on a server that is using a protocol that is lower than V4
         StepVerifier.create( result.records() ).expectErrorSatisfies( error -> {
@@ -1247,7 +1247,7 @@ void shouldAllowDatabaseName() throws Throwable
         // Given
         try( Session session = neo4j.driver().session( forDatabase( "neo4j" ) ) )
         {
-            StatementResult result = session.run( "RETURN 1" );
+            Result result = session.run( "RETURN 1" );
             assertThat( result.single().get( 0 ).asInt(), equalTo( 1 ) );
         }
     }
@@ -1259,7 +1259,7 @@ void shouldAllowDatabaseNameUsingTx() throws Throwable
         try ( Session session = neo4j.driver().session( forDatabase( "neo4j" ) );
               Transaction transaction = session.beginTransaction() )
         {
-            StatementResult result = transaction.run( "RETURN 1" );
+            Result result = transaction.run( "RETURN 1" );
             assertThat( result.single().get( 0 ).asInt(), equalTo( 1 ) );
         }
     }
@@ -1282,7 +1282,7 @@ void shouldErrorDatabaseWhenDatabaseIsAbsent() throws Throwable
         Session session = neo4j.driver().session( forDatabase( "foo" ) );
 
         ClientException error = assertThrows( ClientException.class, () -> {
-            StatementResult result = session.run( "RETURN 1" );
+            Result result = session.run( "RETURN 1" );
             result.consume();
         } );
 
@@ -1300,7 +1300,7 @@ void shouldErrorDatabaseNameUsingTxWhenDatabaseIsAbsent() throws Throwable
         // When trying to run the query on a server that is using a protocol that is lower than V4
         ClientException error = assertThrows( ClientException.class, () -> {
             Transaction transaction = session.beginTransaction();
-            StatementResult result = transaction.run( "RETURN 1" );
+            Result result = transaction.run( "RETURN 1" );
             result.consume();
         });
         assertThat( error.getMessage(), containsString( "Database does not exist. Database name: 'foo'" ) );
@@ -1360,7 +1360,7 @@ private void testExecuteWriteTx( AccessMode sessionMode )
         {
             String material = session.writeTransaction( tx ->
             {
-                StatementResult result = tx.run( "CREATE (s:Shield {material: 'Vibranium'}) RETURN s" );
+                Result result = tx.run( "CREATE (s:Shield {material: 'Vibranium'}) RETURN s" );
                 Record record = result.single();
                 tx.commit();
                 return record.get( 0 ).asNode().get( "material" ).asString();
@@ -1438,7 +1438,7 @@ private int countNodesWithId( int id )
     {
         try ( Session session = neo4j.driver().session() )
         {
-            StatementResult result = session.run( "MATCH (n {id: $id}) RETURN count(n)", parameters( "id", id ) );
+            Result result = session.run( "MATCH (n {id: $id}) RETURN count(n)", parameters( "id", id ) );
             return result.single().get( 0 ).asInt();
         }
     }
@@ -1451,7 +1451,7 @@ private void createNodeWithId( int id )
         }
     }
 
-    private static StatementResult updateNodeId( StatementRunner statementRunner, int currentId, int newId )
+    private static Result updateNodeId(StatementRunner statementRunner, int currentId, int newId )
     {
         return statementRunner.run( "MATCH (n {id: $currentId}) SET n.id = $newId",
                 parameters( "currentId", currentId, "newId", newId ) );
@@ -1528,7 +1528,7 @@ private static class ThrowingWork implements TransactionWork
         @Override
         public Record execute( Transaction tx )
         {
-            StatementResult result = tx.run( query );
+            Result result = tx.run( query );
             if ( invoked++ < failures )
             {
                 throw new ServiceUnavailableException( "" );
diff --git a/driver/src/test/java/org/neo4j/driver/integration/SessionMixIT.java b/driver/src/test/java/org/neo4j/driver/integration/SessionMixIT.java
index 70274c759f..aa072a41be 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/SessionMixIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/SessionMixIT.java
@@ -30,12 +30,12 @@
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
 import org.neo4j.driver.Statement;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.async.AsyncSession;
 import org.neo4j.driver.async.AsyncTransaction;
 import org.neo4j.driver.async.AsyncTransactionWork;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.internal.async.connection.EventLoopGroupFactory;
 import org.neo4j.driver.internal.util.Futures;
 import org.neo4j.driver.types.Node;
@@ -144,7 +144,7 @@ void shouldFailToExecuteBlockingRunInAsyncTransactionFunction()
     @Test
     void shouldFailToExecuteBlockingRunChainedWithAsyncRun()
     {
-        CompletionStage result = asyncSession.runAsync( "RETURN 1" ).thenCompose( StatementResultCursor::singleAsync ).thenApply( record -> {
+        CompletionStage result = asyncSession.runAsync( "RETURN 1" ).thenCompose( ResultCursor::singleAsync ).thenApply(record -> {
             if ( EventLoopGroupFactory.isEventLoopThread( Thread.currentThread() ) )
             {
                 IllegalStateException e =
@@ -161,10 +161,10 @@ void shouldFailToExecuteBlockingRunChainedWithAsyncRun()
     @Test
     void shouldAllowBlockingOperationInCommonPoolWhenChaining()
     {
-        CompletionStage nodeStage = asyncSession.runAsync( "RETURN 42 AS value" ).thenCompose( StatementResultCursor::singleAsync )
+        CompletionStage nodeStage = asyncSession.runAsync( "RETURN 42 AS value" ).thenCompose( ResultCursor::singleAsync )
                 // move execution to ForkJoinPool.commonPool()
                 .thenApplyAsync( record -> session.run( "CREATE (n:Node {value: $value}) RETURN n", record ) )
-                .thenApply( StatementResult::single )
+                .thenApply( Result::single )
                 .thenApply( record -> record.get( 0 ).asNode() );
 
         Node node = await( nodeStage );
@@ -173,8 +173,8 @@ void shouldAllowBlockingOperationInCommonPoolWhenChaining()
         assertEquals( 1, countNodesByLabel( "Node" ) );
     }
 
-    private void runNestedQueries( StatementResultCursor inputCursor, List> stages,
-            CompletableFuture>> resultFuture )
+    private void runNestedQueries(ResultCursor inputCursor, List> stages,
+                                  CompletableFuture>> resultFuture )
     {
         final CompletionStage recordResponse = inputCursor.nextAsync();
         stages.add( recordResponse );
@@ -195,14 +195,14 @@ else if ( record != null )
         } );
     }
 
-    private void runNestedQuery( StatementResultCursor inputCursor, Record record, List> stages,
-            CompletableFuture>> resultFuture )
+    private void runNestedQuery(ResultCursor inputCursor, Record record, List> stages,
+                                CompletableFuture>> resultFuture )
     {
         Node node = record.get( 0 ).asNode();
         long id = node.get( "id" ).asLong();
         long age = id * 10;
 
-        CompletionStage response =
+        CompletionStage response =
                 asyncSession.runAsync( "MATCH (p:Person {id: $id}) SET p.age = $age RETURN p", parameters( "id", id, "age", age ) );
 
         response.whenComplete( ( cursor, error ) -> {
@@ -221,7 +221,7 @@ private void runNestedQuery( StatementResultCursor inputCursor, Record record, L
     private long countNodesByLabel( String label )
     {
         CompletionStage countStage =
-                asyncSession.runAsync( "MATCH (n:" + label + ") RETURN count(n)" ).thenCompose( StatementResultCursor::singleAsync ).thenApply(
+                asyncSession.runAsync( "MATCH (n:" + label + ") RETURN count(n)" ).thenCompose( ResultCursor::singleAsync ).thenApply(
                         record -> record.get( 0 ).asLong() );
 
         return await( countStage );
diff --git a/driver/src/test/java/org/neo4j/driver/integration/SessionResetIT.java b/driver/src/test/java/org/neo4j/driver/integration/SessionResetIT.java
index 0cc5eafe47..6ae9a1a75e 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/SessionResetIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/SessionResetIT.java
@@ -51,7 +51,7 @@
 
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.StatementRunner;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.exceptions.ClientException;
@@ -179,7 +179,7 @@ void shouldNotAllowBeginTxIfResetFailureIsNotConsumed() throws Throwable
         {
             Transaction tx1 = session.beginTransaction();
 
-            StatementResult result = tx1.run( "CALL test.driver.longRunningStatement({seconds})", parameters( "seconds", 10 ) );
+            Result result = tx1.run( "CALL test.driver.longRunningStatement({seconds})", parameters( "seconds", 10 ) );
 
             awaitActiveQueriesToContain( "CALL test.driver.longRunningStatement" );
             session.reset();
@@ -221,7 +221,7 @@ void shouldBeAbleToBeginTxAfterResetFailureIsConsumed() throws Throwable
         {
             Transaction tx1 = session.beginTransaction();
 
-            StatementResult procedureResult = tx1.run( "CALL test.driver.longRunningStatement({seconds})",
+            Result procedureResult = tx1.run( "CALL test.driver.longRunningStatement({seconds})",
                     parameters( "seconds", 10 ) );
 
             awaitActiveQueriesToContain( "CALL test.driver.longRunningStatement" );
@@ -237,7 +237,7 @@ void shouldBeAbleToBeginTxAfterResetFailureIsConsumed() throws Throwable
                 tx2.commit();
             }
 
-            StatementResult result = session.run( "MATCH (n) RETURN count(n)" );
+            Result result = session.run( "MATCH (n) RETURN count(n)" );
             long nodes = result.single().get( "count(n)" ).asLong();
             MatcherAssert.assertThat( nodes, equalTo( 1L ) );
         }
@@ -257,7 +257,7 @@ void shouldKillLongRunningStatement() throws Throwable
         {
             try ( Session session = neo4j.driver().session() )
             {
-                StatementResult result = session.run( "CALL test.driver.longRunningStatement({seconds})",
+                Result result = session.run( "CALL test.driver.longRunningStatement({seconds})",
                         parameters( "seconds", executionTimeout ) );
 
                 resetSessionAfterTimeout( session, killTimeout );
@@ -289,7 +289,7 @@ void shouldKillLongStreamingResult() throws Throwable
         {
             try ( Session session = neo4j.driver().session() )
             {
-                StatementResult result = session.run( "CALL test.driver.longStreamingResult({seconds})",
+                Result result = session.run( "CALL test.driver.longStreamingResult({seconds})",
                         parameters( "seconds", executionTimeout ) );
 
                 resetSessionAfterTimeout( session, killTimeout );
@@ -426,7 +426,7 @@ void performUpdate( Driver driver, int nodeId, int newNodeId,
                 {
                     usedSessionRef.set( session );
                     latchToWait.await();
-                    StatementResult result = updateNodeId( session, nodeId, newNodeId );
+                    Result result = updateNodeId( session, nodeId, newNodeId );
                     result.consume();
                 }
             }
@@ -447,7 +447,7 @@ public void performUpdate( Driver driver, int nodeId, int newNodeId,
                 {
                     usedSessionRef.set( session );
                     latchToWait.await();
-                    StatementResult result = updateNodeId( tx, nodeId, newNodeId );
+                    Result result = updateNodeId( tx, nodeId, newNodeId );
                     result.consume();
                 }
             }
@@ -473,7 +473,7 @@ public void performUpdate( Driver driver, int nodeId, int newNodeId,
                     session.writeTransaction( tx ->
                     {
                         invocationsOfWork.incrementAndGet();
-                        StatementResult result = updateNodeId( tx, nodeId, newNodeId );
+                        Result result = updateNodeId( tx, nodeId, newNodeId );
                         result.consume();
                         return null;
                     } );
@@ -498,7 +498,7 @@ void shouldBeAbleToRunMoreStatementsAfterResetOnNoErrorState()
             tx.commit();
 
             // Then the outcome of both statements should be visible
-            StatementResult result = session.run( "MATCH (n) RETURN count(n)" );
+            Result result = session.run( "MATCH (n) RETURN count(n)" );
             long nodes = result.single().get( "count(n)" ).asLong();
             assertThat( nodes, equalTo( 1L ) );
         }
@@ -584,7 +584,7 @@ private void testResetOfQueryWaitingForLock( NodeIdUpdater nodeIdUpdater ) throw
         {
             Future txResult = nodeIdUpdater.update( nodeId, newNodeId1, otherSessionRef, nodeLocked );
 
-            StatementResult result = updateNodeId( tx, nodeId, newNodeId2 );
+            Result result = updateNodeId( tx, nodeId, newNodeId2 );
             result.consume();
 
             nodeLocked.countDown();
@@ -598,7 +598,7 @@ private void testResetOfQueryWaitingForLock( NodeIdUpdater nodeIdUpdater ) throw
 
         try ( Session session = neo4j.driver().session() )
         {
-            StatementResult result = session.run( "MATCH (n) RETURN n.id AS id" );
+            Result result = session.run( "MATCH (n) RETURN n.id AS id" );
             int value = result.single().get( "id" ).asInt();
             assertEquals( newNodeId2, value );
         }
@@ -612,7 +612,7 @@ private void createNodeWithId( int id )
         }
     }
 
-    private static StatementResult updateNodeId( StatementRunner statementRunner, int currentId, int newId )
+    private static Result updateNodeId(StatementRunner statementRunner, int currentId, int newId )
     {
         return statementRunner.run( "MATCH (n {id: $currentId}) SET n.id = $newId",
                 parameters( "currentId", currentId, "newId", newId ) );
@@ -753,7 +753,7 @@ private long countNodes( String label )
     {
         try ( Session session = neo4j.driver().session() )
         {
-            StatementResult result = session.run( "MATCH (n" + (label == null ? "" : ":" + label) + ") RETURN count(n) AS result" );
+            Result result = session.run( "MATCH (n" + (label == null ? "" : ":" + label) + ") RETURN count(n) AS result" );
             return result.single().get( 0 ).asLong();
         }
     }
diff --git a/driver/src/test/java/org/neo4j/driver/integration/StatementIT.java b/driver/src/test/java/org/neo4j/driver/integration/StatementIT.java
index def969378f..449a9406d1 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/StatementIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/StatementIT.java
@@ -27,7 +27,7 @@
 import java.util.Map;
 
 import org.neo4j.driver.Record;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.Values;
 import org.neo4j.driver.util.ParallelizableIT;
@@ -164,7 +164,7 @@ void shouldRunSimpleStatement()
         session.run( "CREATE (a {name:'Adam'})" );
 
         // And I run a read statement
-        StatementResult result2 = session.run( "MATCH (a) RETURN a.name" );
+        Result result2 = session.run( "MATCH (a) RETURN a.name" );
 
         // Then I expect to get the name back
         Value name = null;
diff --git a/driver/src/test/java/org/neo4j/driver/integration/StatementRunnerCloseIT.java b/driver/src/test/java/org/neo4j/driver/integration/StatementRunnerCloseIT.java
index 62b1809094..e0c0b5e8b7 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/StatementRunnerCloseIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/StatementRunnerCloseIT.java
@@ -27,9 +27,9 @@
 
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.async.AsyncSession;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ResultConsumedException;
 import org.neo4j.driver.summary.ResultSummary;
 import org.neo4j.driver.util.DatabaseExtension;
@@ -65,7 +65,7 @@ void tearDown()
     void shouldErrorToAccessRecordsAfterConsume()
     {
         // Given
-        StatementResult result = neo4j.driver().session().run("UNWIND [1,2] AS a RETURN a");
+        Result result = neo4j.driver().session().run("UNWIND [1,2] AS a RETURN a");
 
         // When
         result.consume();
@@ -86,7 +86,7 @@ void shouldErrorToAccessRecordsAfterClose()
     {
         // Given
         Session session = neo4j.driver().session();
-        StatementResult result = session.run("UNWIND [1,2] AS a RETURN a");
+        Result result = session.run("UNWIND [1,2] AS a RETURN a");
 
         // When
         session.close();
@@ -106,7 +106,7 @@ void shouldErrorToAccessRecordsAfterClose()
     void shouldAllowConsumeAndKeysAfterConsume()
     {
         // Given
-        StatementResult result = neo4j.driver().session().run("UNWIND [1,2] AS a RETURN a");
+        Result result = neo4j.driver().session().run("UNWIND [1,2] AS a RETURN a");
         List keys = result.keys();
 
         // When
@@ -125,7 +125,7 @@ void shouldAllowSummaryAndKeysAfterClose()
     {
         // Given
         Session session = neo4j.driver().session();
-        StatementResult result = session.run("UNWIND [1,2] AS a RETURN a");
+        Result result = session.run("UNWIND [1,2] AS a RETURN a");
         List keys = result.keys();
         ResultSummary summary = result.consume();
 
@@ -145,7 +145,7 @@ void shouldErrorToAccessRecordsAfterConsumeAsync()
     {
         // Given
         AsyncSession session = neo4j.driver().asyncSession();
-        StatementResultCursor result = await( session.runAsync( "UNWIND [1,2] AS a RETURN a" ) );
+        ResultCursor result = await( session.runAsync( "UNWIND [1,2] AS a RETURN a" ) );
 
         // When
         await( result.consumeAsync() );
@@ -164,7 +164,7 @@ void shouldErrorToAccessRecordsAfterCloseAsync()
     {
         // Given
         AsyncSession session = neo4j.driver().asyncSession();
-        StatementResultCursor result = await( session.runAsync( "UNWIND [1,2] AS a RETURN a" ) );
+        ResultCursor result = await( session.runAsync( "UNWIND [1,2] AS a RETURN a" ) );
 
         // When
         await( session.closeAsync() );
@@ -182,7 +182,7 @@ void shouldAllowConsumeAndKeysAfterConsumeAsync()
     {
         // Given
         AsyncSession session = neo4j.driver().asyncSession();
-        StatementResultCursor result = await( session.runAsync( "UNWIND [1,2] AS a RETURN a" ) );
+        ResultCursor result = await( session.runAsync( "UNWIND [1,2] AS a RETURN a" ) );
 
         List keys = result.keys();
 
@@ -202,7 +202,7 @@ void shouldAllowConsumeAndKeysAfterCloseAsync()
     {
         // Given
         AsyncSession session = neo4j.driver().asyncSession();
-        StatementResultCursor result = await( session.runAsync( "UNWIND [1,2] AS a RETURN a" ) );
+        ResultCursor result = await( session.runAsync( "UNWIND [1,2] AS a RETURN a" ) );
         List keys = result.keys();
         ResultSummary summary = await( result.consumeAsync() );
 
diff --git a/driver/src/test/java/org/neo4j/driver/integration/SummaryIT.java b/driver/src/test/java/org/neo4j/driver/integration/SummaryIT.java
index 90bf0d8788..0135e0b7b2 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/SummaryIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/SummaryIT.java
@@ -27,7 +27,7 @@
 import java.util.concurrent.TimeUnit;
 
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.Values;
 import org.neo4j.driver.internal.util.EnabledOnNeo4jWith;
@@ -82,7 +82,7 @@ void shouldContainBasicMetadata()
         String statementText = "UNWIND [1, 2, 3, 4] AS n RETURN n AS number LIMIT $limit";
 
         // When
-        StatementResult result = session.run( statementText, statementParameters );
+        Result result = session.run( statementText, statementParameters );
 
         // Then
         assertTrue( result.hasNext() );
@@ -140,7 +140,7 @@ void shouldGetSystemUpdates() throws Throwable
     {
         try ( Session session = neo4j.driver().session( forDatabase( "system" ) ) )
         {
-            StatementResult result = session.run( "CREATE USER foo SET PASSWORD 'bar'" );
+            Result result = session.run( "CREATE USER foo SET PASSWORD 'bar'" );
             assertThat( result.consume().counters().containsUpdates(), equalTo( false ) );
             assertThat( result.consume().counters().containsSystemUpdates(), equalTo( true ) );
         }
diff --git a/driver/src/test/java/org/neo4j/driver/integration/TemporalTypesIT.java b/driver/src/test/java/org/neo4j/driver/integration/TemporalTypesIT.java
index 5b95288c29..e7c4d0b32b 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/TemporalTypesIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/TemporalTypesIT.java
@@ -36,7 +36,7 @@
 
 import org.neo4j.driver.internal.util.EnabledOnNeo4jWith;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.types.IsoDuration;
 import java.util.function.Function;
@@ -410,7 +410,7 @@ private static  void testSendAndReceiveValue( T value, Function conv
 
     private static void testDurationToString( long seconds, int nanoseconds, String expectedValue )
     {
-        StatementResult result = session.run( "RETURN duration({seconds: $s, nanoseconds: $n})", parameters( "s", seconds, "n", nanoseconds ) );
+        Result result = session.run( "RETURN duration({seconds: $s, nanoseconds: $n})", parameters( "s", seconds, "n", nanoseconds ) );
         IsoDuration duration = result.single().get( 0 ).asIsoDuration();
         assertEquals( expectedValue, duration.toString() );
     }
diff --git a/driver/src/test/java/org/neo4j/driver/integration/TransactionBoltV3IT.java b/driver/src/test/java/org/neo4j/driver/integration/TransactionBoltV3IT.java
index cf95b19885..fd7744a17d 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/TransactionBoltV3IT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/TransactionBoltV3IT.java
@@ -27,13 +27,13 @@
 import java.util.concurrent.CompletionStage;
 
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.async.AsyncSession;
 import org.neo4j.driver.async.AsyncTransaction;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.TransientException;
 import org.neo4j.driver.internal.util.EnabledOnNeo4jWith;
 import org.neo4j.driver.util.DriverExtension;
@@ -89,7 +89,7 @@ void shouldSetTransactionMetadataAsync()
 
         CompletionStage txFuture = driver.asyncSession().beginTransactionAsync( config )
                 .thenCompose( tx -> tx.runAsync( "RETURN 1" )
-                        .thenCompose( StatementResultCursor::consumeAsync )
+                        .thenCompose( ResultCursor::consumeAsync )
                         .thenApply( ignore -> tx ) );
 
         AsyncTransaction transaction = await( txFuture );
@@ -175,7 +175,7 @@ private static void verifyTransactionMetadata( Map metadata )
     {
         try ( Session session = driver.driver().session() )
         {
-            StatementResult result = session.run( "CALL dbms.listTransactions()" );
+            Result result = session.run( "CALL dbms.listTransactions()" );
 
             Map receivedMetadata = result.list()
                     .stream()
diff --git a/driver/src/test/java/org/neo4j/driver/integration/TransactionIT.java b/driver/src/test/java/org/neo4j/driver/integration/TransactionIT.java
index ca4eaa3468..58234d5fe1 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/TransactionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/TransactionIT.java
@@ -30,7 +30,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.exceptions.ClientException;
@@ -92,7 +92,7 @@ void shouldRunAndRollbackByDefault()
         }
 
         // Then there should be no visible effect of the transaction
-        StatementResult cursor = session.run( "MATCH (n) RETURN count(n)" );
+        Result cursor = session.run( "MATCH (n) RETURN count(n)" );
         long nodes = cursor.single().get( "count(n)" ).asLong();
         assertThat( nodes, equalTo( 0L ) );
     }
@@ -106,7 +106,7 @@ void shouldRetrieveResults()
         // When
         try ( Transaction tx = session.beginTransaction() )
         {
-            StatementResult res = tx.run( "MATCH (n) RETURN n.name" );
+            Result res = tx.run( "MATCH (n) RETURN n.name" );
 
             // Then
             assertThat( res.single().get( "n.name" ).asString(), equalTo( "Steve Brook" ) );
@@ -229,7 +229,7 @@ void shouldHandleFailureAfterClosingTransaction()
     {
         // GIVEN a successful query in a transaction
         Transaction tx = session.beginTransaction();
-        StatementResult result = tx.run( "CREATE (n) RETURN n" );
+        Result result = tx.run( "CREATE (n) RETURN n" );
         result.consume();
         tx.commit();
         tx.close();
@@ -294,7 +294,7 @@ void shouldRollBackTxIfErrorWithoutConsume()
 
         try ( Transaction anotherTx = session.beginTransaction() )
         {
-            StatementResult cursor = anotherTx.run( "RETURN 1" );
+            Result cursor = anotherTx.run( "RETURN 1" );
             int val = cursor.single().get( "1" ).asInt();
             assertThat( val, equalTo( 1 ) );
         }
@@ -307,14 +307,14 @@ void shouldRollBackTxIfErrorWithConsume()
         {
             try ( Transaction tx = session.beginTransaction() )
             {
-                StatementResult result = tx.run( "invalid" );
+                Result result = tx.run( "invalid" );
                 result.consume();
             }
         } );
 
         try ( Transaction tx = session.beginTransaction() )
         {
-            StatementResult cursor = tx.run( "RETURN 1" );
+            Result cursor = tx.run( "RETURN 1" );
             int val = cursor.single().get( "1" ).asInt();
             assertThat( val, equalTo( 1 ) );
         }
@@ -325,7 +325,7 @@ void shouldPropagateFailureFromSummary()
     {
         try ( Transaction tx = session.beginTransaction() )
         {
-            StatementResult result = tx.run( "RETURN Wrong" );
+            Result result = tx.run( "RETURN Wrong" );
 
             ClientException e = assertThrows( ClientException.class, result::consume );
             assertThat( e.code(), containsString( "SyntaxError" ) );
@@ -503,7 +503,7 @@ private void shouldRunAndCloseAfterAction( Consumer txConsumer, boo
         }
 
         // Then the outcome of both statements should be visible
-        StatementResult result = session.run( "MATCH (n) RETURN count(n)" );
+        Result result = session.run( "MATCH (n) RETURN count(n)" );
         long nodes = result.single().get( "count(n)" ).asLong();
         if (isCommit)
         {
diff --git a/driver/src/test/java/org/neo4j/driver/integration/TrustCustomCertificateIT.java b/driver/src/test/java/org/neo4j/driver/integration/TrustCustomCertificateIT.java
index a7a2a95a99..20521a5398 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/TrustCustomCertificateIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/TrustCustomCertificateIT.java
@@ -28,7 +28,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.GraphDatabase;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.exceptions.SecurityException;
 import org.neo4j.driver.util.CertificateExtension;
 import org.neo4j.driver.util.CertificateUtil.CertificateKeyPair;
@@ -83,7 +83,7 @@ private void shouldBeAbleToRunCypher( Supplier driverSupplier )
     {
         try ( Driver driver = driverSupplier.get(); Session session = driver.session() )
         {
-            StatementResult result = session.run( "RETURN 1 as n" );
+            Result result = session.run( "RETURN 1 as n" );
             assertThat( result.single().get( "n" ).asInt(), equalTo( 1 ) );
         }
     }
diff --git a/driver/src/test/java/org/neo4j/driver/integration/ExplicitTransactionIT.java b/driver/src/test/java/org/neo4j/driver/integration/UnmanagedTransactionIT.java
similarity index 87%
rename from driver/src/test/java/org/neo4j/driver/integration/ExplicitTransactionIT.java
rename to driver/src/test/java/org/neo4j/driver/integration/UnmanagedTransactionIT.java
index 6c70ce0c21..e8d36e15cf 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/ExplicitTransactionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/UnmanagedTransactionIT.java
@@ -33,12 +33,12 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Statement;
 import org.neo4j.driver.TransactionConfig;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
 import org.neo4j.driver.internal.InternalDriver;
 import org.neo4j.driver.SessionConfig;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
 import org.neo4j.driver.internal.async.NetworkSession;
 import org.neo4j.driver.internal.cluster.RoutingSettings;
 import org.neo4j.driver.internal.retry.RetrySettings;
@@ -60,7 +60,7 @@
 
 
 @ParallelizableIT
-class ExplicitTransactionIT
+class UnmanagedTransactionIT
 {
     @RegisterExtension
     static final DatabaseExtension neo4j = new DatabaseExtension();
@@ -79,22 +79,22 @@ void tearDown()
         session.closeAsync();
     }
 
-    private ExplicitTransaction beginTransaction()
+    private UnmanagedTransaction beginTransaction()
     {
         return beginTransaction( session );
     }
 
-    private ExplicitTransaction beginTransaction( NetworkSession session )
+    private UnmanagedTransaction beginTransaction(NetworkSession session )
     {
         return await( session.beginTransactionAsync( TransactionConfig.empty() ) );
     }
 
-    private StatementResultCursor sessionRun( NetworkSession session, Statement statement )
+    private ResultCursor sessionRun(NetworkSession session, Statement statement )
     {
         return await( session.runAsync( statement, TransactionConfig.empty(), true ) );
     }
 
-    private StatementResultCursor txRun( ExplicitTransaction tx, String statement )
+    private ResultCursor txRun(UnmanagedTransaction tx, String statement )
     {
         return await( tx.runAsync( new Statement( statement ), true ) );
     }
@@ -102,7 +102,7 @@ private StatementResultCursor txRun( ExplicitTransaction tx, String statement )
     @Test
     void shouldDoNothingWhenCommittedSecondTime()
     {
-        ExplicitTransaction tx = beginTransaction();
+        UnmanagedTransaction tx = beginTransaction();
 
         assertNull( await( tx.commitAsync() ) );
 
@@ -113,7 +113,7 @@ void shouldDoNothingWhenCommittedSecondTime()
     @Test
     void shouldFailToCommitAfterRollback()
     {
-        ExplicitTransaction tx = beginTransaction();
+        UnmanagedTransaction tx = beginTransaction();
 
         assertNull( await( tx.rollbackAsync() ) );
 
@@ -125,7 +125,7 @@ void shouldFailToCommitAfterRollback()
     @Test
     void shouldFailToCommitAfterTermination()
     {
-        ExplicitTransaction tx = beginTransaction();
+        UnmanagedTransaction tx = beginTransaction();
 
         tx.markTerminated();
 
@@ -136,7 +136,7 @@ void shouldFailToCommitAfterTermination()
     @Test
     void shouldDoNothingWhenRolledBackSecondTime()
     {
-        ExplicitTransaction tx = beginTransaction();
+        UnmanagedTransaction tx = beginTransaction();
 
         assertNull( await( tx.rollbackAsync() ) );
 
@@ -147,7 +147,7 @@ void shouldDoNothingWhenRolledBackSecondTime()
     @Test
     void shouldFailToRollbackAfterCommit()
     {
-        ExplicitTransaction tx = beginTransaction();
+        UnmanagedTransaction tx = beginTransaction();
 
         assertNull( await( tx.commitAsync() ) );
 
@@ -159,7 +159,7 @@ void shouldFailToRollbackAfterCommit()
     @Test
     void shouldRollbackAfterTermination()
     {
-        ExplicitTransaction tx = beginTransaction();
+        UnmanagedTransaction tx = beginTransaction();
 
         tx.markTerminated();
 
@@ -170,7 +170,7 @@ void shouldRollbackAfterTermination()
     @Test
     void shouldFailToRunQueryWhenTerminated()
     {
-        ExplicitTransaction tx = beginTransaction();
+        UnmanagedTransaction tx = beginTransaction();
         txRun( tx, "CREATE (:MyLabel)" );
         tx.markTerminated();
 
@@ -181,7 +181,7 @@ void shouldFailToRunQueryWhenTerminated()
     @Test
     void shouldBePossibleToRunMoreTransactionsAfterOneIsTerminated()
     {
-        ExplicitTransaction tx1 = beginTransaction();
+        UnmanagedTransaction tx1 = beginTransaction();
         tx1.markTerminated();
 
         // commit should fail, make session forget about this transaction and release the connection to the pool
@@ -190,9 +190,9 @@ void shouldBePossibleToRunMoreTransactionsAfterOneIsTerminated()
 
         await( session.beginTransactionAsync( TransactionConfig.empty() )
                 .thenCompose( tx -> tx.runAsync( new Statement( "CREATE (:Node {id: 42})" ), true )
-                        .thenCompose( StatementResultCursor::consumeAsync )
+                        .thenCompose( ResultCursor::consumeAsync )
                         .thenApply( ignore -> tx )
-                ).thenCompose( ExplicitTransaction::commitAsync ) );
+                ).thenCompose( UnmanagedTransaction::commitAsync ) );
 
         assertEquals( 1, countNodes( 42 ) );
     }
@@ -212,7 +212,7 @@ void shouldPropagateRollbackFailureAfterFatalError()
     private int countNodes( Object id )
     {
         Statement statement = new Statement( "MATCH (n:Node {id: $id}) RETURN count(n)", parameters( "id", id ) );
-        StatementResultCursor cursor = sessionRun( session, statement );
+        ResultCursor cursor = sessionRun( session, statement );
         return await( cursor.singleAsync() ).get( 0 ).asInt();
     }
 
@@ -225,7 +225,7 @@ private void testCommitAndRollbackFailurePropagation( boolean commit )
         {
             NetworkSession session = ((InternalDriver) driver).newSession( SessionConfig.defaultConfig() );
             {
-                ExplicitTransaction tx = beginTransaction( session );
+                UnmanagedTransaction tx = beginTransaction( session );
 
                 // run query but do not consume the result
                 txRun( tx, "UNWIND range(0, 10000) AS x RETURN x + 1" );
diff --git a/driver/src/test/java/org/neo4j/driver/integration/async/AsyncSessionIT.java b/driver/src/test/java/org/neo4j/driver/integration/async/AsyncSessionIT.java
index 4c1ee8e33e..eb62d7915c 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/async/AsyncSessionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/async/AsyncSessionIT.java
@@ -42,7 +42,7 @@
 import org.neo4j.driver.async.AsyncSession;
 import org.neo4j.driver.async.AsyncTransaction;
 import org.neo4j.driver.async.AsyncTransactionWork;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.exceptions.DatabaseException;
 import org.neo4j.driver.exceptions.NoSuchRecordException;
@@ -109,7 +109,7 @@ void tearDown()
     @Test
     void shouldRunQueryWithEmptyResult()
     {
-        StatementResultCursor cursor = await( session.runAsync( "CREATE (:Person)" ) );
+        ResultCursor cursor = await( session.runAsync( "CREATE (:Person)" ) );
 
         assertNull( await( cursor.nextAsync() ) );
     }
@@ -117,7 +117,7 @@ void shouldRunQueryWithEmptyResult()
     @Test
     void shouldRunQueryWithSingleResult()
     {
-        StatementResultCursor cursor = await( session.runAsync( "CREATE (p:Person {name: 'Nick Fury'}) RETURN p" ) );
+        ResultCursor cursor = await( session.runAsync( "CREATE (p:Person {name: 'Nick Fury'}) RETURN p" ) );
 
         Record record = await( cursor.nextAsync() );
         assertNotNull( record );
@@ -131,7 +131,7 @@ void shouldRunQueryWithSingleResult()
     @Test
     void shouldRunQueryWithMultipleResults()
     {
-        StatementResultCursor cursor = await( session.runAsync( "UNWIND [1,2,3] AS x RETURN x" ) );
+        ResultCursor cursor = await( session.runAsync( "UNWIND [1,2,3] AS x RETURN x" ) );
 
         Record record1 = await( cursor.nextAsync() );
         assertNotNull( record1 );
@@ -151,7 +151,7 @@ void shouldRunQueryWithMultipleResults()
     @Test
     void shouldFailForIncorrectQuery()
     {
-        StatementResultCursor cursor = await( session.runAsync( "RETURN" ) );
+        ResultCursor cursor = await( session.runAsync( "RETURN" ) );
 
         Exception e = assertThrows( Exception.class, () -> await( cursor.nextAsync() ) );
         assertThat( e, is( syntaxError( "Unexpected end of input" ) ) );
@@ -160,7 +160,7 @@ void shouldFailForIncorrectQuery()
     @Test
     void shouldFailWhenQueryFailsAtRuntime()
     {
-        StatementResultCursor cursor = await( session.runAsync( "CYPHER runtime=interpreted UNWIND [1, 2, 0] AS x RETURN 10 / x" ) );
+        ResultCursor cursor = await( session.runAsync( "CYPHER runtime=interpreted UNWIND [1, 2, 0] AS x RETURN 10 / x" ) );
 
         Record record1 = await( cursor.nextAsync() );
         assertNotNull( record1 );
@@ -188,7 +188,7 @@ void shouldFailWhenServerIsRestarted()
         {
             for ( int i = 0; i < queryCount; i++ )
             {
-                StatementResultCursor cursor = await( session.runAsync( query ) );
+                ResultCursor cursor = await( session.runAsync( query ) );
 
                 if ( i == 0 )
                 {
@@ -204,7 +204,7 @@ void shouldFailWhenServerIsRestarted()
     @Test
     void shouldAllowNestedQueries()
     {
-        StatementResultCursor cursor =
+        ResultCursor cursor =
                 await( session.runAsync( "UNWIND [1, 2, 3] AS x CREATE (p:Person {id: x}) RETURN p" ) );
 
         Future>> queriesExecuted = runNestedQueries( cursor );
@@ -213,7 +213,7 @@ void shouldAllowNestedQueries()
         List futureResults = awaitAll( futures );
         assertEquals( 7, futureResults.size() );
 
-        StatementResultCursor personCursor = await( session.runAsync( "MATCH (p:Person) RETURN p ORDER BY p.id" ) );
+        ResultCursor personCursor = await( session.runAsync( "MATCH (p:Person) RETURN p ORDER BY p.id" ) );
 
         List personNodes = new ArrayList<>();
         Record record;
@@ -240,14 +240,14 @@ void shouldAllowNestedQueries()
     void shouldAllowMultipleAsyncRunsWithoutConsumingResults()
     {
         int queryCount = 13;
-        List> cursors = new ArrayList<>();
+        List> cursors = new ArrayList<>();
         for ( int i = 0; i < queryCount; i++ )
         {
             cursors.add( session.runAsync( "CREATE (:Person)" ) );
         }
 
         List> records = new ArrayList<>();
-        for ( StatementResultCursor cursor : awaitAll( cursors ) )
+        for ( ResultCursor cursor : awaitAll( cursors ) )
         {
             records.add( cursor.nextAsync() );
         }
@@ -257,7 +257,7 @@ void shouldAllowMultipleAsyncRunsWithoutConsumingResults()
         await( session.closeAsync() );
         session = neo4j.driver().asyncSession();
 
-        StatementResultCursor cursor = await( session.runAsync( "MATCH (p:Person) RETURN count(p)" ) );
+        ResultCursor cursor = await( session.runAsync( "MATCH (p:Person) RETURN count(p)" ) );
         Record record = await( cursor.nextAsync() );
         assertNotNull( record );
         assertEquals( queryCount, record.get( 0 ).asInt() );
@@ -266,7 +266,7 @@ void shouldAllowMultipleAsyncRunsWithoutConsumingResults()
     @Test
     void shouldExposeStatementKeysForColumnsWithAliases()
     {
-        StatementResultCursor cursor = await( session.runAsync( "RETURN 1 AS one, 2 AS two, 3 AS three, 4 AS five" ) );
+        ResultCursor cursor = await( session.runAsync( "RETURN 1 AS one, 2 AS two, 3 AS three, 4 AS five" ) );
 
         assertEquals( Arrays.asList( "one", "two", "three", "five" ), cursor.keys() );
     }
@@ -274,7 +274,7 @@ void shouldExposeStatementKeysForColumnsWithAliases()
     @Test
     void shouldExposeStatementKeysForColumnsWithoutAliases()
     {
-        StatementResultCursor cursor = await( session.runAsync( "RETURN 1, 2, 3, 5" ) );
+        ResultCursor cursor = await( session.runAsync( "RETURN 1, 2, 3, 5" ) );
 
         assertEquals( Arrays.asList( "1", "2", "3", "5" ), cursor.keys() );
     }
@@ -285,7 +285,7 @@ void shouldExposeResultSummaryForSimpleQuery()
         String query = "CREATE (:Node {id: $id, name: $name})";
         Value params = parameters( "id", 1, "name", "TheNode" );
 
-        StatementResultCursor cursor = await( session.runAsync( query, params ) );
+        ResultCursor cursor = await( session.runAsync( query, params ) );
         ResultSummary summary = await( cursor.consumeAsync() );
 
         assertEquals( new Statement( query, params ), summary.statement() );
@@ -307,7 +307,7 @@ void shouldExposeResultSummaryForExplainQuery()
     {
         String query = "EXPLAIN CREATE (),() WITH * MATCH (n)-->(m) CREATE (n)-[:HI {id: 'id'}]->(m) RETURN n, m";
 
-        StatementResultCursor cursor = await( session.runAsync( query ) );
+        ResultCursor cursor = await( session.runAsync( query ) );
         ResultSummary summary = await( cursor.consumeAsync() );
 
         assertEquals( new Statement( query ), summary.statement() );
@@ -333,7 +333,7 @@ void shouldExposeResultSummaryForProfileQuery()
     {
         String query = "PROFILE CREATE (:Node)-[:KNOWS]->(:Node) WITH * MATCH (n) RETURN n";
 
-        StatementResultCursor cursor = await( session.runAsync( query ) );
+        ResultCursor cursor = await( session.runAsync( query ) );
         ResultSummary summary = await( cursor.consumeAsync() );
 
         assertEquals( new Statement( query ), summary.statement() );
@@ -434,7 +434,7 @@ void shouldRunAsyncTransactionThatCanNotBeRetriedAfterATransientFailure()
     @Test
     void shouldPeekRecordFromCursor()
     {
-        StatementResultCursor cursor = await( session.runAsync( "UNWIND [1, 2, 42] AS x RETURN x" ) );
+        ResultCursor cursor = await( session.runAsync( "UNWIND [1, 2, 42] AS x RETURN x" ) );
 
         assertEquals( 1, await( cursor.peekAsync() ).get( 0 ).asInt() );
         assertEquals( 1, await( cursor.peekAsync() ).get( 0 ).asInt() );
@@ -468,7 +468,7 @@ void shouldForEachWithNonEmptyCursor()
     @Test
     void shouldFailForEachWhenActionFails()
     {
-        StatementResultCursor cursor = await( session.runAsync( "RETURN 42" ) );
+        ResultCursor cursor = await( session.runAsync( "RETURN 42" ) );
         IOException error = new IOException( "Hi" );
 
         IOException e = assertThrows( IOException.class, () ->
@@ -495,7 +495,7 @@ void shouldConvertToListWithNonEmptyCursor()
     @Test
     void shouldConvertToTransformedListWithEmptyCursor()
     {
-        StatementResultCursor cursor = await( session.runAsync( "CREATE ()" ) );
+        ResultCursor cursor = await( session.runAsync( "CREATE ()" ) );
         List strings = await( cursor.listAsync( record -> "Hi!" ) );
         assertEquals( 0, strings.size() );
     }
@@ -503,7 +503,7 @@ void shouldConvertToTransformedListWithEmptyCursor()
     @Test
     void shouldConvertToTransformedListWithNonEmptyCursor()
     {
-        StatementResultCursor cursor = await( session.runAsync( "UNWIND [1,2,3] AS x RETURN x" ) );
+        ResultCursor cursor = await( session.runAsync( "UNWIND [1,2,3] AS x RETURN x" ) );
         List ints = await( cursor.listAsync( record -> record.get( 0 ).asInt() + 1 ) );
         assertEquals( Arrays.asList( 2, 3, 4 ), ints );
     }
@@ -511,7 +511,7 @@ void shouldConvertToTransformedListWithNonEmptyCursor()
     @Test
     void shouldFailWhenListTransformationFunctionFails()
     {
-        StatementResultCursor cursor = await( session.runAsync( "RETURN 42" ) );
+        ResultCursor cursor = await( session.runAsync( "RETURN 42" ) );
         RuntimeException error = new RuntimeException( "Hi!" );
 
         RuntimeException e = assertThrows( RuntimeException.class, () ->
@@ -525,7 +525,7 @@ void shouldFailWhenListTransformationFunctionFails()
     @Test
     void shouldFailSingleWithEmptyCursor()
     {
-        StatementResultCursor cursor = await( session.runAsync( "CREATE ()" ) );
+        ResultCursor cursor = await( session.runAsync( "CREATE ()" ) );
 
         NoSuchRecordException e = assertThrows( NoSuchRecordException.class, () -> await( cursor.singleAsync() ) );
         assertThat( e.getMessage(), containsString( "result is empty" ) );
@@ -534,7 +534,7 @@ void shouldFailSingleWithEmptyCursor()
     @Test
     void shouldFailSingleWithMultiRecordCursor()
     {
-        StatementResultCursor cursor = await( session.runAsync( "UNWIND [1, 2, 3] AS x RETURN x" ) );
+        ResultCursor cursor = await( session.runAsync( "UNWIND [1, 2, 3] AS x RETURN x" ) );
 
         NoSuchRecordException e = assertThrows( NoSuchRecordException.class, () -> await( cursor.singleAsync() ) );
         assertThat( e.getMessage(), startsWith( "Expected a result with a single record" ) );
@@ -543,7 +543,7 @@ void shouldFailSingleWithMultiRecordCursor()
     @Test
     void shouldReturnSingleWithSingleRecordCursor()
     {
-        StatementResultCursor cursor = await( session.runAsync( "RETURN 42" ) );
+        ResultCursor cursor = await( session.runAsync( "RETURN 42" ) );
 
         Record record = await( cursor.singleAsync() );
 
@@ -553,7 +553,7 @@ void shouldReturnSingleWithSingleRecordCursor()
     @Test
     void shouldPropagateFailureFromFirstRecordInSingleAsync()
     {
-        StatementResultCursor cursor = await( session.runAsync( "UNWIND [0] AS x RETURN 10 / x" ) );
+        ResultCursor cursor = await( session.runAsync( "UNWIND [0] AS x RETURN 10 / x" ) );
 
         ClientException e = assertThrows( ClientException.class, () -> await( cursor.singleAsync() ) );
         assertThat( e.getMessage(), containsString( "/ by zero" ) );
@@ -562,7 +562,7 @@ void shouldPropagateFailureFromFirstRecordInSingleAsync()
     @Test
     void shouldNotPropagateFailureFromSecondRecordInSingleAsync()
     {
-        StatementResultCursor cursor = await( session.runAsync( "UNWIND [1, 0] AS x RETURN 10 / x" ) );
+        ResultCursor cursor = await( session.runAsync( "UNWIND [1, 0] AS x RETURN 10 / x" ) );
 
         ClientException e = assertThrows( ClientException.class, () -> await( cursor.singleAsync() ) );
         assertThat( e.getMessage(), containsString( "/ by zero" ) );
@@ -587,13 +587,13 @@ void shouldRunAfterRunFailureToAcquireConnection()
 
         assertThrows( ServiceUnavailableException.class, () ->
         {
-            StatementResultCursor cursor = await( session.runAsync( "RETURN 42" ) );
+            ResultCursor cursor = await( session.runAsync( "RETURN 42" ) );
             await( cursor.nextAsync() );
         } );
 
         neo4j.startDb();
 
-        StatementResultCursor cursor2 = await( session.runAsync( "RETURN 42" ) );
+        ResultCursor cursor2 = await( session.runAsync( "RETURN 42" ) );
         Record record = await( cursor2.singleAsync() );
         assertEquals( 42, record.get( 0 ).asInt() );
     }
@@ -607,7 +607,7 @@ void shouldRunAfterBeginTxFailureOnBookmark()
 
         assertThrows( ClientException.class, () -> await( session.beginTransactionAsync() ) );
 
-        StatementResultCursor cursor = await( session.runAsync( "RETURN 'Hello!'" ) );
+        ResultCursor cursor = await( session.runAsync( "RETURN 'Hello!'" ) );
         Record record = await( cursor.singleAsync() );
         assertEquals( "Hello!", record.get( 0 ).asString() );
     }
@@ -628,7 +628,7 @@ void shouldNotRunAfterBeginTxFailureOnBookmark()
         Bookmark illegalBookmark = InternalBookmark.parse( "Illegal Bookmark" );
         session = neo4j.driver().asyncSession( builder().withBookmarks( illegalBookmark ).build() );
         assertThrows( ClientException.class, () -> await( session.beginTransactionAsync() ) );
-        StatementResultCursor cursor = await( session.runAsync( "RETURN 'Hello!'" ) );
+        ResultCursor cursor = await( session.runAsync( "RETURN 'Hello!'" ) );
         assertThrows( ClientException.class, () -> await( cursor.singleAsync() ) );
     }
 
@@ -639,14 +639,14 @@ void shouldBeginTxAfterRunFailureToAcquireConnection()
 
         assertThrows( ServiceUnavailableException.class, () ->
         {
-            StatementResultCursor cursor = await( session.runAsync( "RETURN 42" ) );
+            ResultCursor cursor = await( session.runAsync( "RETURN 42" ) );
             await( cursor.consumeAsync() );
         } );
 
         neo4j.startDb();
 
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor2 = await( tx.runAsync( "RETURN 42" ) );
+        ResultCursor cursor2 = await( tx.runAsync( "RETURN 42" ) );
         Record record = await( cursor2.singleAsync() );
         assertEquals( 42, record.get( 0 ).asInt() );
         assertNull( await( tx.rollbackAsync() ) );
@@ -669,7 +669,7 @@ public CompletionStage execute( AsyncTransaction tx )
                     throw new SessionExpiredException( "Oh!" );
                 }
                 return tx.runAsync( "UNWIND range(1, 10) AS x RETURN count(x)" )
-                        .thenCompose( StatementResultCursor::singleAsync )
+                        .thenCompose( ResultCursor::singleAsync )
                         .thenApply( record -> record.get( 0 ).asInt() );
             }
         } );
@@ -694,7 +694,7 @@ public CompletionStage execute( AsyncTransaction tx )
                     throw new ServiceUnavailableException( "Oh!" );
                 }
                 return tx.runAsync( "CREATE (n1:TestNode), (n2:TestNode) RETURN 2" )
-                        .thenCompose( StatementResultCursor::singleAsync )
+                        .thenCompose( ResultCursor::singleAsync )
                         .thenApply( record -> record.get( 0 ).asInt() );
             }
         } );
@@ -716,7 +716,7 @@ void shouldExecuteReadTransactionUntilSuccessWhenWorkFails()
             public CompletionStage execute( AsyncTransaction tx )
             {
                 return tx.runAsync( "RETURN 42" )
-                        .thenCompose( StatementResultCursor::singleAsync )
+                        .thenCompose( ResultCursor::singleAsync )
                         .thenApply( record -> record.get( 0 ).asInt() )
                         .thenCompose( result ->
                         {
@@ -745,7 +745,7 @@ void shouldExecuteWriteTransactionUntilSuccessWhenWorkFails()
             public CompletionStage execute( AsyncTransaction tx )
             {
                 return tx.runAsync( "CREATE (:MyNode) RETURN 'Hello'" )
-                        .thenCompose( StatementResultCursor::singleAsync )
+                        .thenCompose( ResultCursor::singleAsync )
                         .thenApply( record -> record.get( 0 ).asString() )
                         .thenCompose( result ->
                         {
@@ -801,7 +801,7 @@ void shouldNotPropagateBlockedPullAllFailureWhenClosed()
     @Test
     void shouldCloseCleanlyWhenRunErrorConsumed()
     {
-        StatementResultCursor cursor = await( session.runAsync( "SomeWrongQuery" ) );
+        ResultCursor cursor = await( session.runAsync( "SomeWrongQuery" ) );
 
         ClientException e = assertThrows( ClientException.class, () -> await( cursor.consumeAsync() ) );
         assertThat( e.getMessage(), startsWith( "Invalid input" ) );
@@ -811,7 +811,7 @@ void shouldCloseCleanlyWhenRunErrorConsumed()
     @Test
     void shouldCloseCleanlyWhenPullAllErrorConsumed()
     {
-        StatementResultCursor cursor = await( session.runAsync( "UNWIND range(10, 0, -1) AS x RETURN 1 / x" ) );
+        ResultCursor cursor = await( session.runAsync( "UNWIND range(10, 0, -1) AS x RETURN 1 / x" ) );
 
         ClientException e = assertThrows( ClientException.class, () -> await( cursor.consumeAsync() ) );
         assertThat( e.getMessage(), containsString( "/ by zero" ) );
@@ -821,7 +821,7 @@ void shouldCloseCleanlyWhenPullAllErrorConsumed()
     @Test
     void shouldPropagateFailureFromSummary()
     {
-        StatementResultCursor cursor = await( session.runAsync( "RETURN Something" ) );
+        ResultCursor cursor = await( session.runAsync( "RETURN Something" ) );
 
         ClientException e = assertThrows( ClientException.class, () -> await( cursor.consumeAsync() ) );
         assertThat( e.code(), containsString( "SyntaxError" ) );
@@ -843,7 +843,7 @@ void shouldPropagateFailureInCloseFromPreviousRun()
     @Test
     void shouldCloseCleanlyAfterFailure()
     {
-        CompletionStage runWithOpenTx = session.beginTransactionAsync()
+        CompletionStage runWithOpenTx = session.beginTransactionAsync()
                 .thenCompose( tx -> session.runAsync( "RETURN 1" ) );
 
         ClientException e = assertThrows( ClientException.class, () -> await( runWithOpenTx ) );
@@ -855,7 +855,7 @@ void shouldCloseCleanlyAfterFailure()
     @Test
     void shouldPropagateFailureFromFirstIllegalQuery()
     {
-        CompletionStage allStatements = session.runAsync( "CREATE (:Node1)" )
+        CompletionStage allStatements = session.runAsync( "CREATE (:Node1)" )
                 .thenCompose( ignore -> session.runAsync( "CREATE (:Node2)" ) )
                 .thenCompose( ignore -> session.runAsync( "RETURN invalid" ) )
                 .thenCompose( ignore -> session.runAsync( "CREATE (:Node3)" ) );
@@ -878,15 +878,15 @@ void shouldAllowReturningNullFromAsyncTransactionFunction()
         assertNull( await( writeResult ) );
     }
 
-    private Future>> runNestedQueries( StatementResultCursor inputCursor )
+    private Future>> runNestedQueries( ResultCursor inputCursor )
     {
         CompletableFuture>> resultFuture = new CompletableFuture<>();
         runNestedQueries( inputCursor, new ArrayList<>(), resultFuture );
         return resultFuture;
     }
 
-    private void runNestedQueries( StatementResultCursor inputCursor, List> stages,
-            CompletableFuture>> resultFuture )
+    private void runNestedQueries(ResultCursor inputCursor, List> stages,
+                                  CompletableFuture>> resultFuture )
     {
         final CompletionStage recordResponse = inputCursor.nextAsync();
         stages.add( recordResponse );
@@ -908,14 +908,14 @@ else if ( record != null )
         } );
     }
 
-    private void runNestedQuery( StatementResultCursor inputCursor, Record record,
-            List> stages, CompletableFuture>> resultFuture )
+    private void runNestedQuery(ResultCursor inputCursor, Record record,
+                                List> stages, CompletableFuture>> resultFuture )
     {
         Node node = record.get( 0 ).asNode();
         long id = node.get( "id" ).asLong();
         long age = id * 10;
 
-        CompletionStage response =
+        CompletionStage response =
                 session.runAsync( "MATCH (p:Person {id: $id}) SET p.age = $age RETURN p",
                         parameters( "id", id, "age", age ) );
 
@@ -936,7 +936,7 @@ private void runNestedQuery( StatementResultCursor inputCursor, Record record,
     private long countNodesByLabel( String label )
     {
         CompletionStage countStage = session.runAsync( "MATCH (n:" + label + ") RETURN count(n)" )
-                .thenCompose( StatementResultCursor::singleAsync )
+                .thenCompose( ResultCursor::singleAsync )
                 .thenApply( record -> record.get( 0 ).asLong() );
 
         return await( countStage );
@@ -944,7 +944,7 @@ private long countNodesByLabel( String label )
 
     private void testForEach( String query, int expectedSeenRecords )
     {
-        StatementResultCursor cursor = await( session.runAsync( query ) );
+        ResultCursor cursor = await( session.runAsync( query ) );
 
         AtomicInteger recordsSeen = new AtomicInteger();
         CompletionStage forEachDone = cursor.forEachAsync( record -> recordsSeen.incrementAndGet() );
@@ -958,7 +958,7 @@ private void testForEach( String query, int expectedSeenRecords )
 
     private  void testList( String query, List expectedList )
     {
-        StatementResultCursor cursor = await( session.runAsync( query ) );
+        ResultCursor cursor = await( session.runAsync( query ) );
         List records = await( cursor.listAsync() );
         List actualList = new ArrayList<>();
         for ( Record record : records )
@@ -970,7 +970,7 @@ private  void testList( String query, List expectedList )
 
     private void testConsume( String query )
     {
-        StatementResultCursor cursor = await( session.runAsync( query ) );
+        ResultCursor cursor = await( session.runAsync( query ) );
         ResultSummary summary = await( cursor.consumeAsync() );
 
         assertNotNull( summary );
@@ -1030,8 +1030,8 @@ public CompletionStage execute( AsyncTransaction tx )
             return resultFuture;
         }
 
-        private void processQueryResult( StatementResultCursor cursor, Throwable error,
-                CompletableFuture resultFuture )
+        private void processQueryResult(ResultCursor cursor, Throwable error,
+                                        CompletableFuture resultFuture )
         {
             if ( error != null )
             {
diff --git a/driver/src/test/java/org/neo4j/driver/integration/async/AsyncTransactionIT.java b/driver/src/test/java/org/neo4j/driver/integration/async/AsyncTransactionIT.java
index 55ed04db74..e783b2304c 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/async/AsyncTransactionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/async/AsyncTransactionIT.java
@@ -38,7 +38,7 @@
 import org.neo4j.driver.Value;
 import org.neo4j.driver.async.AsyncSession;
 import org.neo4j.driver.async.AsyncTransaction;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.exceptions.NoSuchRecordException;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
@@ -122,7 +122,7 @@ void shouldBePossibleToRunSingleStatementAndCommit()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
-        StatementResultCursor cursor = await( tx.runAsync( "CREATE (n:Node {id: 42}) RETURN n" ) );
+        ResultCursor cursor = await( tx.runAsync( "CREATE (n:Node {id: 42}) RETURN n" ) );
 
         Record record = await( cursor.nextAsync() );
         assertNotNull( record );
@@ -140,7 +140,7 @@ void shouldBePossibleToRunSingleStatementAndRollback()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
-        StatementResultCursor cursor = await( tx.runAsync( "CREATE (n:Node {id: 4242}) RETURN n" ) );
+        ResultCursor cursor = await( tx.runAsync( "CREATE (n:Node {id: 4242}) RETURN n" ) );
         Record record = await( cursor.nextAsync() );
         assertNotNull( record );
         Node node = record.get( 0 ).asNode();
@@ -157,13 +157,13 @@ void shouldBePossibleToRunMultipleStatementsAndCommit()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
-        StatementResultCursor cursor1 = await( tx.runAsync( "CREATE (n:Node {id: 1})" ) );
+        ResultCursor cursor1 = await( tx.runAsync( "CREATE (n:Node {id: 1})" ) );
         assertNull( await( cursor1.nextAsync() ) );
 
-        StatementResultCursor cursor2 = await( tx.runAsync( "CREATE (n:Node {id: 2})" ) );
+        ResultCursor cursor2 = await( tx.runAsync( "CREATE (n:Node {id: 2})" ) );
         assertNull( await( cursor2.nextAsync() ) );
 
-        StatementResultCursor cursor3 = await( tx.runAsync( "CREATE (n:Node {id: 2})" ) );
+        ResultCursor cursor3 = await( tx.runAsync( "CREATE (n:Node {id: 2})" ) );
         assertNull( await( cursor3.nextAsync() ) );
 
         assertNull( await( tx.commitAsync() ) );
@@ -190,10 +190,10 @@ void shouldBePossibleToRunMultipleStatementsAndRollback()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
-        StatementResultCursor cursor1 = await( tx.runAsync( "CREATE (n:Node {id: 1})" ) );
+        ResultCursor cursor1 = await( tx.runAsync( "CREATE (n:Node {id: 1})" ) );
         assertNull( await( cursor1.nextAsync() ) );
 
-        StatementResultCursor cursor2 = await( tx.runAsync( "CREATE (n:Node {id: 42})" ) );
+        ResultCursor cursor2 = await( tx.runAsync( "CREATE (n:Node {id: 42})" ) );
         assertNull( await( cursor2.nextAsync() ) );
 
         assertNull( await( tx.rollbackAsync() ) );
@@ -219,7 +219,7 @@ void shouldFailToCommitAfterSingleWrongStatement()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
-        StatementResultCursor cursor = await( tx.runAsync( "RETURN" ) );
+        ResultCursor cursor = await( tx.runAsync( "RETURN" ) );
 
         Exception e = assertThrows( Exception.class, () -> await( cursor.consumeAsync() ) );
         assertThat( e, is( syntaxError( "Unexpected end of input" ) ) );
@@ -232,7 +232,7 @@ void shouldAllowRollbackAfterSingleWrongStatement()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
-        StatementResultCursor cursor = await( tx.runAsync( "RETURN" ) );
+        ResultCursor cursor = await( tx.runAsync( "RETURN" ) );
 
         Exception e = assertThrows( Exception.class, () -> await( cursor.nextAsync() ) );
         assertThat( e, is( syntaxError( "Unexpected end of input" ) ) );
@@ -244,17 +244,17 @@ void shouldFailToCommitAfterCoupleCorrectAndSingleWrongStatement()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
-        StatementResultCursor cursor1 = await( tx.runAsync( "CREATE (n:Node) RETURN n" ) );
+        ResultCursor cursor1 = await( tx.runAsync( "CREATE (n:Node) RETURN n" ) );
         Record record1 = await( cursor1.nextAsync() );
         assertNotNull( record1 );
         assertTrue( record1.get( 0 ).asNode().hasLabel( "Node" ) );
 
-        StatementResultCursor cursor2 = await( tx.runAsync( "RETURN 42" ) );
+        ResultCursor cursor2 = await( tx.runAsync( "RETURN 42" ) );
         Record record2 = await( cursor2.nextAsync() );
         assertNotNull( record2 );
         assertEquals( 42, record2.get( 0 ).asInt() );
 
-        StatementResultCursor cursor3 = await( tx.runAsync( "RETURN" ) );
+        ResultCursor cursor3 = await( tx.runAsync( "RETURN" ) );
 
         Exception e = assertThrows( Exception.class, () -> await( cursor3.consumeAsync() ) );
         assertThat( e, is( syntaxError( "Unexpected end of input" ) ) );
@@ -267,17 +267,17 @@ void shouldAllowRollbackAfterCoupleCorrectAndSingleWrongStatement()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
-        StatementResultCursor cursor1 = await( tx.runAsync( "RETURN 4242" ) );
+        ResultCursor cursor1 = await( tx.runAsync( "RETURN 4242" ) );
         Record record1 = await( cursor1.nextAsync() );
         assertNotNull( record1 );
         assertEquals( 4242, record1.get( 0 ).asInt() );
 
-        StatementResultCursor cursor2 = await( tx.runAsync( "CREATE (n:Node) DELETE n RETURN 42" ) );
+        ResultCursor cursor2 = await( tx.runAsync( "CREATE (n:Node) DELETE n RETURN 42" ) );
         Record record2 = await( cursor2.nextAsync() );
         assertNotNull( record2 );
         assertEquals( 42, record2.get( 0 ).asInt() );
 
-        StatementResultCursor cursor3 = await( tx.runAsync( "RETURN" ) );
+        ResultCursor cursor3 = await( tx.runAsync( "RETURN" ) );
 
         Exception e = assertThrows( Exception.class, () -> await( cursor3.consumeAsync() ) );
         assertThat( e, is( syntaxError( "Unexpected end of input" ) ) );
@@ -289,7 +289,7 @@ void shouldNotAllowNewStatementsAfterAnIncorrectStatement()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
-        StatementResultCursor cursor = await( tx.runAsync( "RETURN" ) );
+        ResultCursor cursor = await( tx.runAsync( "RETURN" ) );
 
         Exception e1 = assertThrows( Exception.class, () -> await( cursor.nextAsync() ) );
         assertThat( e1, is( syntaxError( "Unexpected end of input" ) ) );
@@ -358,7 +358,7 @@ void shouldFailToRollbackWhenCommitted()
     void shouldExposeStatementKeysForColumnsWithAliases()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( "RETURN 1 AS one, 2 AS two, 3 AS three, 4 AS five" ) );
+        ResultCursor cursor = await( tx.runAsync( "RETURN 1 AS one, 2 AS two, 3 AS three, 4 AS five" ) );
 
         assertEquals( Arrays.asList( "one", "two", "three", "five" ), cursor.keys() );
     }
@@ -367,7 +367,7 @@ void shouldExposeStatementKeysForColumnsWithAliases()
     void shouldExposeStatementKeysForColumnsWithoutAliases()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( "RETURN 1, 2, 3, 5" ) );
+        ResultCursor cursor = await( tx.runAsync( "RETURN 1, 2, 3, 5" ) );
 
         assertEquals( Arrays.asList( "1", "2", "3", "5" ), cursor.keys() );
     }
@@ -379,7 +379,7 @@ void shouldExposeResultSummaryForSimpleQuery()
         Value params = parameters( "name1", "Bob", "name2", "John" );
 
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( query, params ) );
+        ResultCursor cursor = await( tx.runAsync( query, params ) );
         ResultSummary summary = await( cursor.consumeAsync() );
 
         assertEquals( new Statement( query, params ), summary.statement() );
@@ -402,7 +402,7 @@ void shouldExposeResultSummaryForExplainQuery()
         String query = "EXPLAIN MATCH (n) RETURN n";
 
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( query ) );
+        ResultCursor cursor = await( tx.runAsync( query ) );
         ResultSummary summary = await( cursor.consumeAsync() );
 
         assertEquals( new Statement( query ), summary.statement() );
@@ -430,7 +430,7 @@ void shouldExposeResultSummaryForProfileQuery()
         Value params = parameters( "name", "Bob" );
 
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( query, params ) );
+        ResultCursor cursor = await( tx.runAsync( query, params ) );
         ResultSummary summary = await( cursor.consumeAsync() );
 
         assertEquals( new Statement( query, params ), summary.statement() );
@@ -454,7 +454,7 @@ void shouldExposeResultSummaryForProfileQuery()
     void shouldPeekRecordFromCursor()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( "UNWIND ['a', 'b', 'c'] AS x RETURN x" ) );
+        ResultCursor cursor = await( tx.runAsync( "UNWIND ['a', 'b', 'c'] AS x RETURN x" ) );
 
         assertEquals( "a", await( cursor.peekAsync() ).get( 0 ).asString() );
         assertEquals( "a", await( cursor.peekAsync() ).get( 0 ).asString() );
@@ -490,7 +490,7 @@ void shouldForEachWithNonEmptyCursor()
     void shouldFailForEachWhenActionFails()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( "RETURN 'Hi!'" ) );
+        ResultCursor cursor = await( tx.runAsync( "RETURN 'Hi!'" ) );
         RuntimeException error = new RuntimeException();
 
         RuntimeException e = assertThrows( RuntimeException.class, () ->
@@ -519,7 +519,7 @@ void shouldConvertToListWithNonEmptyCursor()
     void shouldConvertToTransformedListWithEmptyCursor()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( "CREATE ()" ) );
+        ResultCursor cursor = await( tx.runAsync( "CREATE ()" ) );
         List> maps = await( cursor.listAsync( record -> record.get( 0 ).asMap() ) );
         assertEquals( 0, maps.size() );
     }
@@ -528,7 +528,7 @@ void shouldConvertToTransformedListWithEmptyCursor()
     void shouldConvertToTransformedListWithNonEmptyCursor()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( "UNWIND ['a', 'b', 'c'] AS x RETURN x" ) );
+        ResultCursor cursor = await( tx.runAsync( "UNWIND ['a', 'b', 'c'] AS x RETURN x" ) );
         List strings = await( cursor.listAsync( record -> record.get( 0 ).asString() + "!" ) );
         assertEquals( Arrays.asList( "a!", "b!", "c!" ), strings );
     }
@@ -537,7 +537,7 @@ void shouldConvertToTransformedListWithNonEmptyCursor()
     void shouldFailWhenListTransformationFunctionFails()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( "RETURN 'Hello'" ) );
+        ResultCursor cursor = await( tx.runAsync( "RETURN 'Hello'" ) );
         IOException error = new IOException( "World" );
 
         Exception e = assertThrows( Exception.class, () ->
@@ -564,7 +564,7 @@ void shouldFailToCommitWhenServerIsRestarted()
     void shouldFailSingleWithEmptyCursor()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( "MATCH (n:NoSuchLabel) RETURN n" ) );
+        ResultCursor cursor = await( tx.runAsync( "MATCH (n:NoSuchLabel) RETURN n" ) );
 
         NoSuchRecordException e = assertThrows( NoSuchRecordException.class, () -> await( cursor.singleAsync() ) );
         assertThat( e.getMessage(), containsString( "result is empty" ) );
@@ -574,7 +574,7 @@ void shouldFailSingleWithEmptyCursor()
     void shouldFailSingleWithMultiRecordCursor()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( "UNWIND ['a', 'b'] AS x RETURN x" ) );
+        ResultCursor cursor = await( tx.runAsync( "UNWIND ['a', 'b'] AS x RETURN x" ) );
 
         NoSuchRecordException e = assertThrows( NoSuchRecordException.class, () -> await( cursor.singleAsync() ) );
         assertThat( e.getMessage(), startsWith( "Expected a result with a single record" ) );
@@ -584,7 +584,7 @@ void shouldFailSingleWithMultiRecordCursor()
     void shouldReturnSingleWithSingleRecordCursor()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( "RETURN 'Hello!'" ) );
+        ResultCursor cursor = await( tx.runAsync( "RETURN 'Hello!'" ) );
 
         Record record = await( cursor.singleAsync() );
 
@@ -595,7 +595,7 @@ void shouldReturnSingleWithSingleRecordCursor()
     void shouldPropagateFailureFromFirstRecordInSingleAsync()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( "UNWIND [0] AS x RETURN 10 / x" ) );
+        ResultCursor cursor = await( tx.runAsync( "UNWIND [0] AS x RETURN 10 / x" ) );
 
         ClientException e = assertThrows( ClientException.class, () -> await( cursor.singleAsync() ) );
         assertThat( e.getMessage(), containsString( "/ by zero" ) );
@@ -605,7 +605,7 @@ void shouldPropagateFailureFromFirstRecordInSingleAsync()
     void shouldNotPropagateFailureFromSecondRecordInSingleAsync()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( "UNWIND [1, 0] AS x RETURN 10 / x" ) );
+        ResultCursor cursor = await( tx.runAsync( "UNWIND [1, 0] AS x RETURN 10 / x" ) );
 
         ClientException e = assertThrows( ClientException.class, () -> await( cursor.singleAsync() ) );
         assertThat( e.getMessage(), containsString( "/ by zero" ) );
@@ -630,7 +630,7 @@ void shouldFailToRunQueryAfterCommit()
         tx.runAsync( "CREATE (:MyLabel)" );
         assertNull( await( tx.commitAsync() ) );
 
-        StatementResultCursor cursor = await( session.runAsync( "MATCH (n:MyLabel) RETURN count(n)" ) );
+        ResultCursor cursor = await( session.runAsync( "MATCH (n:MyLabel) RETURN count(n)" ) );
         assertEquals( 1, await( cursor.singleAsync() ).get( 0 ).asInt() );
 
         ClientException e = assertThrows( ClientException.class, () -> await( tx.runAsync( "CREATE (:MyOtherLabel)" ) ) );
@@ -644,7 +644,7 @@ void shouldFailToRunQueryAfterRollback()
         tx.runAsync( "CREATE (:MyLabel)" );
         assertNull( await( tx.rollbackAsync() ) );
 
-        StatementResultCursor cursor = await( session.runAsync( "MATCH (n:MyLabel) RETURN count(n)" ) );
+        ResultCursor cursor = await( session.runAsync( "MATCH (n:MyLabel) RETURN count(n)" ) );
         assertEquals( 0, await( cursor.singleAsync() ).get( 0 ).asInt() );
 
         ClientException e = assertThrows( ClientException.class, () -> await( tx.runAsync( "CREATE (:MyOtherLabel)" ) ) );
@@ -772,7 +772,7 @@ void shouldPropagateBlockedPullAllFailureFromRollback()
     void shouldFailToCommitWhenRunFailureIsConsumed()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( "RETURN Wrong" ) );
+        ResultCursor cursor = await( tx.runAsync( "RETURN Wrong" ) );
 
         ClientException e1 = assertThrows( ClientException.class, () -> await( cursor.consumeAsync() ) );
         assertThat( e1.code(), containsString( "SyntaxError" ) );
@@ -785,7 +785,7 @@ void shouldFailToCommitWhenRunFailureIsConsumed()
     void shouldFailToCommitWhenPullAllFailureIsConsumed()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync(
+        ResultCursor cursor = await( tx.runAsync(
                 "FOREACH (value IN [1,2, 'aaa'] | CREATE (:Person {name: 10 / value}))" ) );
 
         ClientException e1 = assertThrows( ClientException.class, () -> await( cursor.consumeAsync() ) );
@@ -799,7 +799,7 @@ void shouldFailToCommitWhenPullAllFailureIsConsumed()
     void shouldRollbackWhenRunFailureIsConsumed()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( "RETURN Wrong" ) );
+        ResultCursor cursor = await( tx.runAsync( "RETURN Wrong" ) );
 
         ClientException e = assertThrows( ClientException.class, () -> await( cursor.consumeAsync() ) );
         assertThat( e.code(), containsString( "SyntaxError" ) );
@@ -810,7 +810,7 @@ void shouldRollbackWhenRunFailureIsConsumed()
     void shouldRollbackWhenPullAllFailureIsConsumed()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( "UNWIND [1, 0] AS x RETURN 5 / x" ) );
+        ResultCursor cursor = await( tx.runAsync( "UNWIND [1, 0] AS x RETURN 5 / x" ) );
 
         ClientException e = assertThrows( ClientException.class, () -> await( cursor.consumeAsync() ) );
         assertThat( e.getMessage(), containsString( "/ by zero" ) );
@@ -822,7 +822,7 @@ void shouldPropagateFailureFromSummary()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
-        StatementResultCursor cursor = await( tx.runAsync( "RETURN Wrong" ) );
+        ResultCursor cursor = await( tx.runAsync( "RETURN Wrong" ) );
 
         ClientException e = assertThrows( ClientException.class, () -> await( cursor.consumeAsync() ) );
         assertThat( e.code(), containsString( "SyntaxError" ) );
@@ -831,14 +831,14 @@ void shouldPropagateFailureFromSummary()
 
     private int countNodes( Object id )
     {
-        StatementResultCursor cursor = await( session.runAsync( "MATCH (n:Node {id: $id}) RETURN count(n)", parameters( "id", id ) ) );
+        ResultCursor cursor = await( session.runAsync( "MATCH (n:Node {id: $id}) RETURN count(n)", parameters( "id", id ) ) );
         return await( cursor.singleAsync() ).get( 0 ).asInt();
     }
 
     private void testForEach( String query, int expectedSeenRecords )
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( query ) );
+        ResultCursor cursor = await( tx.runAsync( query ) );
 
         AtomicInteger recordsSeen = new AtomicInteger();
         CompletionStage forEachDone = cursor.forEachAsync( record -> recordsSeen.incrementAndGet() );
@@ -853,7 +853,7 @@ private void testForEach( String query, int expectedSeenRecords )
     private  void testList( String query, List expectedList )
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( query ) );
+        ResultCursor cursor = await( tx.runAsync( query ) );
         List records = await( cursor.listAsync() );
         List actualList = new ArrayList<>();
         for ( Record record : records )
@@ -866,7 +866,7 @@ private  void testList( String query, List expectedList )
     private void testConsume( String query )
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
-        StatementResultCursor cursor = await( tx.runAsync( query ) );
+        ResultCursor cursor = await( tx.runAsync( query ) );
         ResultSummary summary = await( cursor.consumeAsync() );
 
         assertNotNull( summary );
diff --git a/driver/src/test/java/org/neo4j/driver/integration/reactive/RxNestedQueriesIT.java b/driver/src/test/java/org/neo4j/driver/integration/reactive/RxNestedQueriesIT.java
index 8af9a051ed..2080323758 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/reactive/RxNestedQueriesIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/reactive/RxNestedQueriesIT.java
@@ -29,7 +29,7 @@
 import org.neo4j.driver.exceptions.TransactionNestingException;
 import org.neo4j.driver.internal.util.EnabledOnNeo4jWith;
 import org.neo4j.driver.reactive.RxSession;
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.reactive.RxTransaction;
 import org.neo4j.driver.util.DatabaseExtension;
 import org.neo4j.driver.util.ParallelizableIT;
@@ -53,7 +53,7 @@ void shouldErrorForNestingQueriesAmongSessionRuns()
                 session -> Flux.from( session.run( "UNWIND range(1, $size) AS x RETURN x", Collections.singletonMap( "size", size ) ).records() )
                         .limitRate( 20 ).flatMap( record -> {
                             int x = record.get( "x" ).asInt();
-                            RxStatementResult innerResult = session.run( "CREATE (n:Node {id: $x}) RETURN n.id", Collections.singletonMap( "x", x ) );
+                            RxResult innerResult = session.run( "CREATE (n:Node {id: $x}) RETURN n.id", Collections.singletonMap( "x", x ) );
                             return innerResult.records();
                         } ).map( r -> r.get( 0 ).asInt() ),
                 RxSession::close );
@@ -131,11 +131,11 @@ void shouldHandleNestedQueriesInTheSameTransaction() throws Throwable
         Flux nodeIds = Flux.usingWhen(
                 session.beginTransaction(),
                 tx -> {
-                    RxStatementResult result = tx.run( "UNWIND range(1, $size) AS x RETURN x",
+                    RxResult result = tx.run( "UNWIND range(1, $size) AS x RETURN x",
                             Collections.singletonMap( "size", size ) );
                     return Flux.from( result.records() ).limitRate( 20 ).flatMap( record -> {
                         int x = record.get( "x" ).asInt();
-                        RxStatementResult innerResult = tx.run( "CREATE (n:Node {id: $x}) RETURN n.id",
+                        RxResult innerResult = tx.run( "CREATE (n:Node {id: $x}) RETURN n.id",
                                 Collections.singletonMap( "x", x ) );
                         return innerResult.records();
                     } ).map( record -> record.get( 0 ).asInt() );
diff --git a/driver/src/test/java/org/neo4j/driver/integration/reactive/RxStatementResultIT.java b/driver/src/test/java/org/neo4j/driver/integration/reactive/RxResultIT.java
similarity index 87%
rename from driver/src/test/java/org/neo4j/driver/integration/reactive/RxStatementResultIT.java
rename to driver/src/test/java/org/neo4j/driver/integration/reactive/RxResultIT.java
index fd60adabec..03bdb9f36e 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/reactive/RxStatementResultIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/reactive/RxResultIT.java
@@ -30,7 +30,7 @@
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.internal.util.EnabledOnNeo4jWith;
 import org.neo4j.driver.reactive.RxSession;
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.summary.ResultSummary;
 import org.neo4j.driver.summary.StatementType;
 import org.neo4j.driver.util.DatabaseExtension;
@@ -52,7 +52,7 @@
 
 @EnabledOnNeo4jWith( BOLT_V4 )
 @ParallelizableIT
-class RxStatementResultIT
+class RxResultIT
 {
     @RegisterExtension
     static final DatabaseExtension neo4j = new DatabaseExtension();
@@ -61,7 +61,7 @@ class RxStatementResultIT
     void shouldAllowIteratingOverResultStream()
     {
         // When
-        RxStatementResult res = sessionRunUnwind();
+        RxResult res = sessionRunUnwind();
 
         // Then I should be able to iterate over the result
         verifyCanAccessFullRecords( res );
@@ -73,7 +73,7 @@ void shouldAllowIteratingOverLargeResultStream()
         // When
         int size = 100000;
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult res = session.run( "UNWIND range(1, $size) AS x RETURN x", parameters( "size", size ) );
+        RxResult res = session.run( "UNWIND range(1, $size) AS x RETURN x", parameters( "size", size ) );
 
         // Then I should be able to iterate over the result
         StepVerifier.FirstStep step = StepVerifier.create( Flux.from( res.records() ).limitRate( 100 ).map( r -> r.get( "x" ).asInt() ) );
@@ -89,7 +89,7 @@ void shouldAllowIteratingOverLargeResultStream()
     void shouldReturnKeysRecordsAndSummaryInOrder()
     {
         // When
-        RxStatementResult res = sessionRunUnwind();
+        RxResult res = sessionRunUnwind();
 
         // Then I should be able to iterate over the result
         verifyCanAccessKeys( res );
@@ -101,7 +101,7 @@ void shouldReturnKeysRecordsAndSummaryInOrder()
     void shouldSecondVisitOfRecordReceiveEmptyRecordStream() throws Throwable
     {
         // When
-        RxStatementResult res = sessionRunUnwind();
+        RxResult res = sessionRunUnwind();
 
         // Then I should be able to iterate over the result
         verifyCanAccessFullRecords( res );
@@ -113,7 +113,7 @@ void shouldSecondVisitOfRecordReceiveEmptyRecordStream() throws Throwable
     void shouldReturnKeysSummaryAndDiscardRecords()
     {
         // When
-        RxStatementResult res = sessionRunUnwind();
+        RxResult res = sessionRunUnwind();
 
         verifyCanAccessKeys( res );
         verifyCanAccessSummary( res );
@@ -124,7 +124,7 @@ void shouldReturnKeysSummaryAndDiscardRecords()
     void shouldAllowOnlySummary()
     {
         // When
-        RxStatementResult res = sessionRunUnwind();
+        RxResult res = sessionRunUnwind();
 
         verifyCanAccessSummary( res );
     }
@@ -133,7 +133,7 @@ void shouldAllowOnlySummary()
     void shouldAllowAccessKeysAndSummaryAfterRecord() throws Throwable
     {
         // Given
-        RxStatementResult res = sessionRunUnwind();
+        RxResult res = sessionRunUnwind();
 
         // Then I should be able to iterate over the result
         verifyCanAccessFullRecords( res );
@@ -152,7 +152,7 @@ void shouldGiveHelpfulFailureMessageWhenAccessNonExistingField()
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult rs =
+        RxResult rs =
                 session.run( "CREATE (n:Person {name:$name}) RETURN n", parameters( "name", "Tom Hanks" ) );
 
         // When
@@ -167,7 +167,7 @@ void shouldGiveHelpfulFailureMessageWhenAccessNonExistingPropertyOnNode()
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult rs =
+        RxResult rs =
                 session.run( "CREATE (n:Person {name:$name}) RETURN n", parameters( "name", "Tom Hanks" ) );
 
         // When
@@ -182,7 +182,7 @@ void shouldHaveFieldNamesInResult()
     {
         // When
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult res = session.run( "CREATE (n:TestNode {name:'test'}) RETURN n" );
+        RxResult res = session.run( "CREATE (n:TestNode {name:'test'}) RETURN n" );
 
         // Then
         StepVerifier.create( res.keys() ).expectNext( singletonList( "n" ) ).expectComplete().verify();
@@ -199,7 +199,7 @@ void shouldReturnEmptyKeyAndRecordOnEmptyResult()
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult rs = session.run( "CREATE (n:Person {name:$name})", parameters( "name", "Tom Hanks" ) );
+        RxResult rs = session.run( "CREATE (n:Person {name:$name})", parameters( "name", "Tom Hanks" ) );
 
         // Then
         StepVerifier.create( rs.keys() ).expectNext( emptyList() ).expectComplete().verify();
@@ -211,7 +211,7 @@ void shouldOnlyErrorRecordAfterFailure()
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult result = session.run( "INVALID" );
+        RxResult result = session.run( "INVALID" );
 
         // When
         Flux> keys = Flux.from( result.keys() );
@@ -240,7 +240,7 @@ void shouldErrorOnSummaryIfNoRecord() throws Throwable
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult result = session.run( "INVALID" );
+        RxResult result = session.run( "INVALID" );
 
         // When
         Flux> keys = Flux.from( result.keys() );
@@ -266,7 +266,7 @@ void shouldDiscardRecords()
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult result = session.run("UNWIND [1,2] AS a RETURN a");
+        RxResult result = session.run("UNWIND [1,2] AS a RETURN a");
 
         // When
         StepVerifier.create( Flux.from( result.records() )
@@ -290,7 +290,7 @@ void shouldStreamCorrectRecordsBackBeforeError()
     {
         RxSession session = neo4j.driver().rxSession();
 
-        RxStatementResult result = session.run( "CYPHER runtime=interpreted UNWIND range(5, 0, -1) AS x RETURN x / x" );
+        RxResult result = session.run( "CYPHER runtime=interpreted UNWIND range(5, 0, -1) AS x RETURN x / x" );
         StepVerifier.create( Flux.from( result.records() ).map( record -> record.get( 0 ).asInt() ) )
                 .expectNext( 1 )
                 .expectNext( 1 )
@@ -308,7 +308,7 @@ void shouldErrorToAccessRecordAfterSessionClose()
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult result = session.run( "UNWIND [1,2] AS a RETURN a" );
+        RxResult result = session.run( "UNWIND [1,2] AS a RETURN a" );
 
         // When
         StepVerifier.create( Flux.from( session.close() ).thenMany( result.records() ) ).expectErrorSatisfies( error -> {
@@ -321,7 +321,7 @@ void shouldErrorToAccessKeysAfterSessionClose()
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult result = session.run( "UNWIND [1,2] AS a RETURN a" );
+        RxResult result = session.run( "UNWIND [1,2] AS a RETURN a" );
 
         // When
         StepVerifier.create( Flux.from( session.close() ).thenMany( result.keys() ) ).expectErrorSatisfies( error -> {
@@ -334,7 +334,7 @@ void shouldErrorToAccessSummaryAfterSessionClose()
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult result = session.run( "UNWIND [1,2] AS a RETURN a" );
+        RxResult result = session.run( "UNWIND [1,2] AS a RETURN a" );
 
         // When
         StepVerifier.create( Flux.from( session.close() ).thenMany( result.consume() ) ).expectErrorSatisfies( error -> {
@@ -347,7 +347,7 @@ void shouldErrorToAccessRecordAfterTxClose()
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult result = session.run( "UNWIND [1,2] AS a RETURN a" );
+        RxResult result = session.run( "UNWIND [1,2] AS a RETURN a" );
 
         // When
         StepVerifier.create(
@@ -363,7 +363,7 @@ void shouldErrorToAccessKeysAfterTxClose()
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult result = session.run( "UNWIND [1,2] AS a RETURN a" );
+        RxResult result = session.run( "UNWIND [1,2] AS a RETURN a" );
 
         // When
         StepVerifier.create(
@@ -379,7 +379,7 @@ void shouldErrorToAccessSummaryAfterTxClose()
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult result = session.run( "UNWIND [1,2] AS a RETURN a" );
+        RxResult result = session.run( "UNWIND [1,2] AS a RETURN a" );
 
         // When
         StepVerifier.create(
@@ -395,7 +395,7 @@ void throwErrorAfterKeys()
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult result = session.run( "UNWIND [1,2] AS a RETURN a" );
+        RxResult result = session.run( "UNWIND [1,2] AS a RETURN a" );
 
         // When
         StepVerifier.create(
@@ -411,7 +411,7 @@ void throwTheSameErrorWhenCallingConsumeMultipleTimes()
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult result = session.run( "Invalid" );
+        RxResult result = session.run( "Invalid" );
 
         // When
         StepVerifier.create( Flux.from( result.consume() ) )
@@ -428,7 +428,7 @@ void keysShouldNotReportRunError()
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult result = session.run( "Invalid" );
+        RxResult result = session.run( "Invalid" );
 
         // When
         StepVerifier.create( Flux.from( result.keys() ) ).expectNext( EMPTY_LIST ).verifyComplete();
@@ -440,7 +440,7 @@ void throwResultConsumedErrorWhenCallingRecordsMultipleTimes()
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult result = session.run( "Invalid" );
+        RxResult result = session.run( "Invalid" );
 
         // When
         StepVerifier.create( Flux.from( result.records() ) )
@@ -451,7 +451,7 @@ void throwResultConsumedErrorWhenCallingRecordsMultipleTimes()
         verifyRecordsAlreadyDiscarded( result );
     }
 
-    private void verifyCanAccessSummary( RxStatementResult res )
+    private void verifyCanAccessSummary( RxResult res )
     {
         StepVerifier.create( res.consume() ).assertNext( summary -> {
             assertThat( summary.statement().text(), equalTo( "UNWIND [1,2,3,4] AS a RETURN a" ) );
@@ -460,25 +460,25 @@ private void verifyCanAccessSummary( RxStatementResult res )
         } ).verifyComplete();
     }
 
-    private void verifyRecordsAlreadyDiscarded( RxStatementResult res )
+    private void verifyRecordsAlreadyDiscarded( RxResult res )
     {
         StepVerifier.create( Flux.from( res.records() ) )
                 .expectErrorSatisfies( error -> assertThat( error.getMessage(), containsString( "has already been consumed" ) ) )
                 .verify();
     }
 
-    private void verifyCanAccessFullRecords( RxStatementResult res )
+    private void verifyCanAccessFullRecords( RxResult res )
     {
         StepVerifier.create( Flux.from( res.records() ).map( r -> r.get( "a" ).asInt() ) ).expectNext( 1 ).expectNext( 2 ).expectNext( 3 ).expectNext(
                 4 ).expectComplete().verify();
     }
 
-    private void verifyCanAccessKeys( RxStatementResult res )
+    private void verifyCanAccessKeys( RxResult res )
     {
         StepVerifier.create( res.keys() ).expectNext( singletonList( "a" ) ).verifyComplete();
     }
 
-    private RxStatementResult sessionRunUnwind()
+    private RxResult sessionRunUnwind()
     {
         RxSession session = neo4j.driver().rxSession();
         return session.run( "UNWIND [1,2,3,4] AS a RETURN a" );
diff --git a/driver/src/test/java/org/neo4j/driver/integration/reactive/RxSessionIT.java b/driver/src/test/java/org/neo4j/driver/integration/reactive/RxSessionIT.java
index 4c32733a80..991c876113 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/reactive/RxSessionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/reactive/RxSessionIT.java
@@ -31,7 +31,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.exceptions.DatabaseException;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
@@ -39,7 +39,7 @@
 import org.neo4j.driver.exceptions.TransientException;
 import org.neo4j.driver.internal.util.EnabledOnNeo4jWith;
 import org.neo4j.driver.reactive.RxSession;
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.reactive.RxTransaction;
 import org.neo4j.driver.reactive.RxTransactionWork;
 import org.neo4j.driver.util.DatabaseExtension;
@@ -65,7 +65,7 @@ void shouldAllowSessionRun()
     {
         // When
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult res = session.run( "UNWIND [1,2,3,4] AS a RETURN a" );
+        RxResult res = session.run( "UNWIND [1,2,3,4] AS a RETURN a" );
 
         // Then I should be able to iterate over the result
         StepVerifier.create( Flux.from( res.records() ).map( r -> r.get( "a" ).asInt() ) )
@@ -82,12 +82,12 @@ void shouldBeAbleToReuseSessionAfterFailure()
     {
         // Given
         RxSession session = neo4j.driver().rxSession();
-        RxStatementResult res1 = session.run( "INVALID" );
+        RxResult res1 = session.run( "INVALID" );
 
         StepVerifier.create( res1.records() ).expectError( ClientException.class ).verify();
 
         // When
-        RxStatementResult res2 = session.run( "RETURN 1" );
+        RxResult res2 = session.run( "RETURN 1" );
 
         // Then
         StepVerifier.create( res2.records() ).assertNext( record -> {
@@ -196,7 +196,7 @@ private long countNodesByLabel( String label )
     {
         try ( Session session = neo4j.driver().session() )
         {
-            StatementResult result = session.run( "MATCH (n:" + label + ") RETURN count(n)" );
+            Result result = session.run( "MATCH (n:" + label + ") RETURN count(n)" );
             return result.single().get( 0 ).asLong();
         }
     }
diff --git a/driver/src/test/java/org/neo4j/driver/integration/reactive/RxTransactionIT.java b/driver/src/test/java/org/neo4j/driver/integration/reactive/RxTransactionIT.java
index cb8e28d1aa..083047a7e8 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/reactive/RxTransactionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/reactive/RxTransactionIT.java
@@ -45,7 +45,7 @@
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
 import org.neo4j.driver.internal.util.EnabledOnNeo4jWith;
 import org.neo4j.driver.reactive.RxSession;
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.reactive.RxTransaction;
 import org.neo4j.driver.summary.ResultSummary;
 import org.neo4j.driver.summary.StatementType;
@@ -147,13 +147,13 @@ void shouldBePossibleToRunMultipleStatements( boolean commit )
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
 
-        RxStatementResult cursor1 = tx.run( "CREATE (n:Node {id: 1})" );
+        RxResult cursor1 = tx.run( "CREATE (n:Node {id: 1})" );
         await( cursor1.records() );
 
-        RxStatementResult cursor2 = tx.run( "CREATE (n:Node {id: 2})" );
+        RxResult cursor2 = tx.run( "CREATE (n:Node {id: 2})" );
         await( cursor2.records() );
 
-        RxStatementResult cursor3 = tx.run( "CREATE (n:Node {id: 1})" );
+        RxResult cursor3 = tx.run( "CREATE (n:Node {id: 1})" );
         await( cursor3.records() );
 
         assertCanCommitOrRollback( commit, tx );
@@ -167,9 +167,9 @@ void shouldBePossibleToRunMultipleStatementsWithoutWaiting( boolean commit )
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
 
-        RxStatementResult cursor1 = tx.run( "CREATE (n:Node {id: 1})" );
-        RxStatementResult cursor2 = tx.run( "CREATE (n:Node {id: 2})" );
-        RxStatementResult cursor3 = tx.run( "CREATE (n:Node {id: 1})" );
+        RxResult cursor1 = tx.run( "CREATE (n:Node {id: 1})" );
+        RxResult cursor2 = tx.run( "CREATE (n:Node {id: 2})" );
+        RxResult cursor3 = tx.run( "CREATE (n:Node {id: 1})" );
 
         await( Flux.from( cursor1.records() ).concatWith( cursor2.records() ).concatWith( cursor3.records() ) );
         assertCanCommitOrRollback( commit, tx );
@@ -183,8 +183,8 @@ void shouldRunStatementsOnResultPublish( boolean commit )
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
 
-        RxStatementResult cursor1 = tx.run( "CREATE (n:Person {name: 'Alice'}) RETURN n.name" );
-        RxStatementResult cursor2 = tx.run( "CREATE (n:Person {name: 'Bob'}) RETURN n.name" );
+        RxResult cursor1 = tx.run( "CREATE (n:Person {name: 'Alice'}) RETURN n.name" );
+        RxResult cursor2 = tx.run( "CREATE (n:Person {name: 'Bob'}) RETURN n.name" );
 
         // The execution order is the same as the record publishing order.
         List records = await( Flux.from( cursor2.records() ).concatWith( cursor1.records() ) );
@@ -200,7 +200,7 @@ void shouldRunStatementsOnResultPublish( boolean commit )
     void shouldDiscardOnCommitOrRollback( boolean commit )
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        RxStatementResult cursor = tx.run( "UNWIND [1,2,3,4] AS a RETURN a" );
+        RxResult cursor = tx.run( "UNWIND [1,2,3,4] AS a RETURN a" );
 
         // We only perform run without any pull
         await( Flux.from( cursor.keys() ) );
@@ -220,9 +220,9 @@ void shouldBePossibleToRunMultipleStatementsWithoutStreaming( boolean commit )
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
 
-        RxStatementResult cursor1 = tx.run( "CREATE (n:Node {id: 1})" );
-        RxStatementResult cursor2 = tx.run( "CREATE (n:Node {id: 2})" );
-        RxStatementResult cursor3 = tx.run( "CREATE (n:Node {id: 1})" );
+        RxResult cursor1 = tx.run( "CREATE (n:Node {id: 1})" );
+        RxResult cursor2 = tx.run( "CREATE (n:Node {id: 2})" );
+        RxResult cursor3 = tx.run( "CREATE (n:Node {id: 1})" );
 
         await( Flux.from( cursor1.keys() ).concatWith( cursor2.keys() ).concatWith( cursor3.keys() ) );
         assertCanCommitOrRollback( commit, tx );
@@ -275,7 +275,7 @@ void shouldNotAllowNewStatementsAfterAnIncorrectStatement()
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
         assertFailToRunWrongStatement( tx );
 
-        RxStatementResult result = tx.run( "CREATE ()" );
+        RxResult result = tx.run( "CREATE ()" );
         Exception e = assertThrows( Exception.class, () -> await( result.records() ) );
         assertThat( e.getMessage(), startsWith( "Cannot run more statements in this transaction" ) );
 
@@ -361,7 +361,7 @@ void shouldAllowRollbackAfterFailedCommit()
     void shouldExposeStatementKeysForColumnsWithAliases()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        RxStatementResult result = tx.run( "RETURN 1 AS one, 2 AS two, 3 AS three, 4 AS five" );
+        RxResult result = tx.run( "RETURN 1 AS one, 2 AS two, 3 AS three, 4 AS five" );
 
         List keys = await( Mono.from( result.keys() ) );
         assertEquals( Arrays.asList( "one", "two", "three", "five" ), keys );
@@ -373,7 +373,7 @@ void shouldExposeStatementKeysForColumnsWithAliases()
     void shouldExposeStatementKeysForColumnsWithoutAliases()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        RxStatementResult result = tx.run( "RETURN 1, 2, 3, 5" );
+        RxResult result = tx.run( "RETURN 1, 2, 3, 5" );
 
         List keys = await( Mono.from( result.keys() ) );
         assertEquals( Arrays.asList( "1", "2", "3", "5" ), keys );
@@ -388,7 +388,7 @@ void shouldExposeResultSummaryForSimpleQuery()
         String query = "CREATE (p1:Person {name: $name1})-[:KNOWS]->(p2:Person {name: $name2}) RETURN p1, p2";
         Value params = parameters( "name1", "Bob", "name2", "John" );
 
-        RxStatementResult result = tx.run( query, params );
+        RxResult result = tx.run( query, params );
         await( result.records() ); // we run and stream
 
         ResultSummary summary = await( Mono.from( result.consume() ) );
@@ -416,7 +416,7 @@ void shouldExposeResultSummaryForExplainQuery()
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
         String query = "EXPLAIN MATCH (n) RETURN n";
 
-        RxStatementResult result = tx.run( query );
+        RxResult result = tx.run( query );
         await( result.records() ); // we run and stream
 
         ResultSummary summary = await( Mono.from( result.consume() ) );
@@ -448,7 +448,7 @@ void shouldExposeResultSummaryForProfileQuery()
 
         Value params = parameters( "name", "Bob" );
 
-        RxStatementResult result = tx.run( query, params );
+        RxResult result = tx.run( query, params );
         await( result.records() ); // we run and stream
 
         ResultSummary summary = await( Mono.from( result.consume() ) );
@@ -476,7 +476,7 @@ void shouldExposeResultSummaryForProfileQuery()
     void shouldCancelRecordStream()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        RxStatementResult result = tx.run( "UNWIND ['a', 'b', 'c'] AS x RETURN x" );
+        RxResult result = tx.run( "UNWIND ['a', 'b', 'c'] AS x RETURN x" );
 
         Flux abc = Flux.from( result.records() ).limitRate( 1 ).take( 1 ).map( record -> record.get( 0 ).asString() );
         StepVerifier.create( abc ).expectNext( "a" ).verifyComplete();
@@ -525,7 +525,7 @@ void shouldConvertToListWithNonEmptyCursor()
     void shouldConvertToTransformedListWithEmptyCursor()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        RxStatementResult result = tx.run( "CREATE ()" );
+        RxResult result = tx.run( "CREATE ()" );
         List> maps = await( Flux.from( result.records() ).map( record -> record.get( 0 ).asMap() )  );
         assertEquals( 0, maps.size() );
         assertCanRollback( tx );
@@ -535,7 +535,7 @@ void shouldConvertToTransformedListWithEmptyCursor()
     void shouldConvertToTransformedListWithNonEmptyCursor()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        RxStatementResult result = tx.run( "UNWIND ['a', 'b', 'c'] AS x RETURN x" );
+        RxResult result = tx.run( "UNWIND ['a', 'b', 'c'] AS x RETURN x" );
         List strings = await( Flux.from( result.records() ).map( record -> record.get( 0 ).asString() + "!" )  );
 
         assertEquals( Arrays.asList( "a!", "b!", "c!" ), strings );
@@ -560,7 +560,7 @@ void shouldFailWhenListTransformationFunctionFails()
     void shouldFailToCommitWhenServerIsRestarted()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        RxStatementResult result = tx.run( "RETURN 1" );
+        RxResult result = tx.run( "RETURN 1" );
 
         assertThrows( ServiceUnavailableException.class, () -> {
             await( Flux.from( result.records() ).doOnSubscribe( subscription -> {
@@ -576,7 +576,7 @@ void shouldFailToCommitWhenServerIsRestarted()
     void shouldFailSingleWithEmptyCursor()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        RxStatementResult result = tx.run( "MATCH (n:NoSuchLabel) RETURN n" );
+        RxResult result = tx.run( "MATCH (n:NoSuchLabel) RETURN n" );
 
         NoSuchElementException e = assertThrows( NoSuchElementException.class, () -> await( Flux.from( result.records() ).single() ) );
         assertThat( e.getMessage(), containsString( "Source was empty" ) );
@@ -587,7 +587,7 @@ void shouldFailSingleWithEmptyCursor()
     void shouldFailSingleWithMultiRecordCursor()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        RxStatementResult result = tx.run( "UNWIND ['a', 'b'] AS x RETURN x" );
+        RxResult result = tx.run( "UNWIND ['a', 'b'] AS x RETURN x" );
 
         IndexOutOfBoundsException e = assertThrows( IndexOutOfBoundsException.class, () -> await( Flux.from( result.records() ).single() ) );
         assertThat( e.getMessage(), startsWith( "Source emitted more than one item" ) );
@@ -598,7 +598,7 @@ void shouldFailSingleWithMultiRecordCursor()
     void shouldReturnSingleWithSingleRecordCursor()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        RxStatementResult result = tx.run( "RETURN 'Hello!'" );
+        RxResult result = tx.run( "RETURN 'Hello!'" );
 
         Record record = await( Flux.from( result.records() ).single() );
         assertEquals( "Hello!", record.get( 0 ).asString() );
@@ -609,7 +609,7 @@ void shouldReturnSingleWithSingleRecordCursor()
     void shouldPropagateFailureFromFirstRecordInSingleAsync()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        RxStatementResult result = tx.run( "UNWIND [0] AS x RETURN 10 / x" );
+        RxResult result = tx.run( "UNWIND [0] AS x RETURN 10 / x" );
 
         ClientException e = assertThrows( ClientException.class, () -> await( Flux.from( result.records() ).single() ) );
         assertThat( e.getMessage(), containsString( "/ by zero" ) );
@@ -620,7 +620,7 @@ void shouldPropagateFailureFromFirstRecordInSingleAsync()
     void shouldPropagateFailureFromSecondRecordInSingleAsync()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        RxStatementResult result = tx.run( "UNWIND [1, 0] AS x RETURN 10 / x" );
+        RxResult result = tx.run( "UNWIND [1, 0] AS x RETURN 10 / x" );
 
         ClientException e = assertThrows( ClientException.class, () -> await( Flux.from( result.records() ).single() ) );
         assertThat( e.getMessage(), containsString( "/ by zero" ) );
@@ -644,7 +644,7 @@ void shouldConsumeNonEmptyCursor()
     void shouldFailToRunQueryAfterCommit( boolean commit )
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        RxStatementResult result = tx.run( "CREATE (:MyLabel)" );
+        RxResult result = tx.run( "CREATE (:MyLabel)" );
         await( result.records() );
 
         assertCanCommitOrRollback( commit, tx );
@@ -696,10 +696,10 @@ void shouldFailToCommitWhenQueriesFailAndErrorNotConsumed() throws InterruptedEx
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
 
-        RxStatementResult result1 = tx.run( "CREATE (:TestNode)" );
-        RxStatementResult result2 = tx.run( "CREATE (:TestNode)" );
-        RxStatementResult result3 = tx.run( "RETURN 10 / 0" );
-        RxStatementResult result4 = tx.run( "CREATE (:TestNode)" );
+        RxResult result1 = tx.run( "CREATE (:TestNode)" );
+        RxResult result2 = tx.run( "CREATE (:TestNode)" );
+        RxResult result3 = tx.run( "RETURN 10 / 0" );
+        RxResult result4 = tx.run( "CREATE (:TestNode)" );
 
         Flux records =
                 Flux.from( result1.records() ).concatWith( result2.records() ).concatWith( result3.records() ).concatWith( result4.records() );
@@ -713,10 +713,10 @@ void shouldNotRunUntilPublisherIsConnected() throws Throwable
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
 
-        RxStatementResult result1 = tx.run( "RETURN 1" );
-        RxStatementResult result2 = tx.run( "RETURN 2" );
-        RxStatementResult result3 = tx.run( "RETURN 3" );
-        RxStatementResult result4 = tx.run( "RETURN 4" );
+        RxResult result1 = tx.run( "RETURN 1" );
+        RxResult result2 = tx.run( "RETURN 2" );
+        RxResult result3 = tx.run( "RETURN 3" );
+        RxResult result4 = tx.run( "RETURN 4" );
 
         Flux records =
                 Flux.from( result4.records() ).concatWith( result3.records() ).concatWith( result2.records() ).concatWith( result1.records() );
@@ -744,7 +744,7 @@ void shouldNotPropagateRunFailureIfNotExecuted( boolean commit )
     void shouldPropagateRunFailureOnRecord()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        RxStatementResult result = tx.run( "RETURN 42 / 0" );
+        RxResult result = tx.run( "RETURN 42 / 0" );
         await( result.keys() ); // always returns keys
 
         ClientException e = assertThrows( ClientException.class, () -> await( result.records() ) );
@@ -756,7 +756,7 @@ void shouldPropagateRunFailureOnRecord()
     void shouldFailToCommitWhenPullAllFailureIsConsumed()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        RxStatementResult result = tx.run( "FOREACH (value IN [1,2, 'aaa'] | CREATE (:Person {name: 10 / value}))" );
+        RxResult result = tx.run( "FOREACH (value IN [1,2, 'aaa'] | CREATE (:Person {name: 10 / value}))" );
 
         ClientException e1 = assertThrows( ClientException.class, () -> await( result.records() ) );
         assertThat( e1.code(), containsString( "TypeError" ) );
@@ -769,7 +769,7 @@ void shouldFailToCommitWhenPullAllFailureIsConsumed()
     void shouldBeAbleToRollbackWhenPullAllFailureIsConsumed()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        RxStatementResult result = tx.run( "FOREACH (value IN [1,2, 'aaa'] | CREATE (:Person {name: 10 / value}))" );
+        RxResult result = tx.run( "FOREACH (value IN [1,2, 'aaa'] | CREATE (:Person {name: 10 / value}))" );
 
         ClientException e1 = assertThrows( ClientException.class, () -> await( result.records() ) );
         assertThat( e1.code(), containsString( "TypeError" ) );
@@ -782,7 +782,7 @@ void shouldNotPropagateRunFailureFromSummary()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
 
-        RxStatementResult result = tx.run( "RETURN Wrong" );
+        RxResult result = tx.run( "RETURN Wrong" );
         ClientException e = assertThrows( ClientException.class, () -> await( result.records() ) );
         assertThat( e.code(), containsString( "SyntaxError" ) );
 
@@ -792,14 +792,14 @@ void shouldNotPropagateRunFailureFromSummary()
 
     private int countNodes( Object id )
     {
-        RxStatementResult result = session.run( "MATCH (n:Node {id: $id}) RETURN count(n)", parameters( "id", id ) );
+        RxResult result = session.run( "MATCH (n:Node {id: $id}) RETURN count(n)", parameters( "id", id ) );
         return await( Flux.from( result.records() ).single().map( record -> record.get( 0 ).asInt() ) );
     }
 
     private void testForEach( String query, int expectedSeenRecords )
     {
         Flux summary = Flux.usingWhen( session.beginTransaction(), tx -> {
-            RxStatementResult result = tx.run( query );
+            RxResult result = tx.run( query );
             AtomicInteger recordsSeen = new AtomicInteger();
             return Flux.from( result.records() )
                     .doOnNext( record -> recordsSeen.incrementAndGet() )
@@ -886,7 +886,7 @@ private static Stream commit()
 
     private static void assertCanRunCreate( RxTransaction tx )
     {
-        RxStatementResult result = tx.run( "CREATE (n:Node {id: 4242}) RETURN n" );
+        RxResult result = tx.run( "CREATE (n:Node {id: 4242}) RETURN n" );
 
         Record record = await( Flux.from(result.records()).single() );
 
@@ -897,14 +897,14 @@ private static void assertCanRunCreate( RxTransaction tx )
 
     private static void assertFailToRunWrongStatement( RxTransaction tx )
     {
-        RxStatementResult result = tx.run( "RETURN" );
+        RxResult result = tx.run( "RETURN" );
         Exception e = assertThrows( Exception.class, () -> await( result.records() ) );
         assertThat( e, is( syntaxError( "Unexpected end of input" ) ) );
     }
 
     private void assertCanRunReturnOne( RxTransaction tx )
     {
-        RxStatementResult result = tx.run( "RETURN 42" );
+        RxResult result = tx.run( "RETURN 42" );
         List records = await( result.records() );
         assertThat( records.size(), equalTo( 1 ) );
         Record record = records.get( 0 );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/DirectDriverBoltKitTest.java b/driver/src/test/java/org/neo4j/driver/internal/DirectDriverBoltKitTest.java
index 91d90f1867..acf4dad1e1 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/DirectDriverBoltKitTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/DirectDriverBoltKitTest.java
@@ -39,7 +39,7 @@
 import org.neo4j.driver.Logger;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.exceptions.TransientException;
 import org.neo4j.driver.internal.cluster.RoutingSettings;
@@ -47,7 +47,7 @@
 import org.neo4j.driver.internal.util.Clock;
 import org.neo4j.driver.internal.util.io.ChannelTrackingDriverFactory;
 import org.neo4j.driver.reactive.RxSession;
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.util.StubServer;
 
 import static java.util.Arrays.asList;
@@ -231,7 +231,7 @@ void shouldPropagateTransactionRollbackErrorWhenSessionClosed() throws Exception
                 Session session = driver.session();
 
                 Transaction tx = session.beginTransaction();
-                StatementResult result = tx.run( "CREATE (n {name:'Alice'}) RETURN n.name AS name" );
+                Result result = tx.run( "CREATE (n {name:'Alice'}) RETURN n.name AS name" );
                 assertEquals( "Alice", result.single().get( "name" ).asString() );
 
                 TransientException e = assertThrows( TransientException.class, session::close );
@@ -254,7 +254,7 @@ void shouldStreamingRecordsInBatchesRx() throws Exception
             try ( Driver driver = GraphDatabase.driver( "bolt://localhost:9001", INSECURE_CONFIG ) )
             {
                 RxSession session = driver.rxSession();
-                RxStatementResult result = session.run( "MATCH (n) RETURN n.name" );
+                RxResult result = session.run( "MATCH (n) RETURN n.name" );
                 Flux records = Flux.from( result.records() ).limitRate( 2 ).map( record -> record.get( "n.name" ).asString() );
                 StepVerifier.create( records ).expectNext( "Bob", "Alice", "Tina" ).verifyComplete();
             }
@@ -274,7 +274,7 @@ void shouldStreamingRecordsInBatches() throws Exception
             try ( Driver driver = GraphDatabase.driver( "bolt://localhost:9001", insecureBuilder().withFetchSize( 2 ).build() ) )
             {
                 Session session = driver.session();
-                StatementResult result = session.run( "MATCH (n) RETURN n.name" );
+                Result result = session.run( "MATCH (n) RETURN n.name" );
                 List list = result.list( record -> record.get( "n.name" ).asString() );
                 assertEquals( list, asList( "Bob", "Alice", "Tina" ) );
             }
@@ -294,7 +294,7 @@ void shouldChangeFetchSize() throws Exception
             try ( Driver driver = GraphDatabase.driver( "bolt://localhost:9001", INSECURE_CONFIG ) )
             {
                 Session session = driver.session( builder().withFetchSize( 2 ).build() );
-                StatementResult result = session.run( "MATCH (n) RETURN n.name" );
+                Result result = session.run( "MATCH (n) RETURN n.name" );
                 List list = result.list( record -> record.get( "n.name" ).asString() );
                 assertEquals( list, asList( "Bob", "Alice", "Tina" ) );
             }
@@ -314,7 +314,7 @@ void shouldAllowPullAll() throws Exception
             try ( Driver driver = GraphDatabase.driver( "bolt://localhost:9001", insecureBuilder().withFetchSize( -1 ).build() ) )
             {
                 Session session = driver.session();
-                StatementResult result = session.run( "MATCH (n) RETURN n.name" );
+                Result result = session.run( "MATCH (n) RETURN n.name" );
                 List list = result.list( record -> record.get( "n.name" ).asString() );
                 assertEquals( list, asList( "Bob", "Alice", "Tina" ) );
             }
@@ -356,7 +356,7 @@ void shouldThrowCorrectErrorOnRunFailure() throws Throwable
                 Transaction transaction = session.beginTransaction() )
         {
             TransientException error = assertThrows( TransientException.class, () -> {
-                StatementResult result = transaction.run( "RETURN 1" );
+                Result result = transaction.run( "RETURN 1" );
                 result.consume();
             } );
             assertThat( error.code(), equalTo( "Neo.TransientError.General.DatabaseUnavailable" ) );
@@ -376,7 +376,7 @@ void shouldThrowCorrectErrorOnCommitFailure() throws Throwable
                 Session session = driver.session() )
         {
             Transaction transaction = session.beginTransaction();
-            StatementResult result = transaction.run( "CREATE (n {name:'Bob'})" );
+            Result result = transaction.run( "CREATE (n {name:'Bob'})" );
             result.consume();
 
             TransientException error = assertThrows( TransientException.class, transaction::commit );
@@ -396,7 +396,7 @@ void shouldAllowDatabaseNameInSessionRun() throws Throwable
         try ( Driver driver = GraphDatabase.driver( "bolt://localhost:9001", INSECURE_CONFIG );
                 Session session = driver.session( builder().withDatabase( "mydatabase" ).withDefaultAccessMode( AccessMode.READ ).build() ) )
         {
-            final StatementResult result = session.run( "MATCH (n) RETURN n.name" );
+            final Result result = session.run( "MATCH (n) RETURN n.name" );
             result.consume();
         }
         finally
@@ -450,7 +450,7 @@ private static void testTxCloseErrorPropagation( String script, Consumer txAction.accept( tx ) );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/InternalStatementResultTest.java b/driver/src/test/java/org/neo4j/driver/internal/InternalResultTest.java
similarity index 85%
rename from driver/src/test/java/org/neo4j/driver/internal/InternalStatementResultTest.java
rename to driver/src/test/java/org/neo4j/driver/internal/InternalResultTest.java
index f8435c6178..3fc5454a7c 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/InternalStatementResultTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/InternalResultTest.java
@@ -27,12 +27,12 @@
 
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Statement;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.exceptions.NoSuchRecordException;
-import org.neo4j.driver.internal.cursor.AsyncStatementResultCursor;
-import org.neo4j.driver.internal.cursor.AsyncStatementResultCursorImpl;
-import org.neo4j.driver.internal.cursor.DisposableAsyncStatementResultCursor;
+import org.neo4j.driver.internal.cursor.AsyncResultCursor;
+import org.neo4j.driver.internal.cursor.AsyncResultCursorImpl;
+import org.neo4j.driver.internal.cursor.DisposableAsyncResultCursor;
 import org.neo4j.driver.internal.handlers.LegacyPullAllResponseHandler;
 import org.neo4j.driver.internal.handlers.PullAllResponseHandler;
 import org.neo4j.driver.internal.handlers.PullResponseCompletionListener;
@@ -61,13 +61,13 @@
 import static org.neo4j.driver.internal.messaging.v1.BoltProtocolV1.METADATA_EXTRACTOR;
 import static org.neo4j.driver.util.TestUtil.anyServerVersion;
 
-class InternalStatementResultTest
+class InternalResultTest
 {
     @Test
     void iterationShouldWorksAsExpected()
     {
         // GIVEN
-        StatementResult result = createResult( 3 );
+        Result result = createResult( 3 );
 
         // WHEN
         assertTrue( result.hasNext() );
@@ -89,7 +89,7 @@ void iterationShouldWorksAsExpected()
     void firstOfFieldNameShouldWorkAsExpected()
     {
         // GIVEN
-        StatementResult result = createResult( 3 );
+        Result result = createResult( 3 );
 
         // THEN
         assertThat( result.next().get( "k1" ), equalTo( value( "v1-1" ) ) );
@@ -100,7 +100,7 @@ void firstOfFieldNameShouldWorkAsExpected()
     void firstOfFieldIndexShouldWorkAsExpected()
     {
         // GIVEN
-        StatementResult result = createResult( 3 );
+        Result result = createResult( 3 );
 
         // THEN
         assertThat( result.next().get( 0 ), equalTo( value( "v1-1" ) ) );
@@ -111,7 +111,7 @@ void firstOfFieldIndexShouldWorkAsExpected()
     void singlePastFirstShouldFail()
     {
         // GIVEN
-        StatementResult result = createResult( 2 );
+        Result result = createResult( 2 );
         result.next();
         result.next();
 
@@ -123,7 +123,7 @@ void singlePastFirstShouldFail()
     void singleNoneShouldFail()
     {
         // GIVEN
-        StatementResult result = createResult( 0 );
+        Result result = createResult( 0 );
 
         // THEN
         assertThrows( NoSuchRecordException.class, result::single );
@@ -133,7 +133,7 @@ void singleNoneShouldFail()
     void singleWhenMoreThanOneShouldFail()
     {
         // GIVEN
-        StatementResult result = createResult( 2 );
+        Result result = createResult( 2 );
 
         // THEN
         assertThrows( NoSuchRecordException.class, result::single );
@@ -143,7 +143,7 @@ void singleWhenMoreThanOneShouldFail()
     void singleOfFieldNameShouldWorkAsExpected()
     {
         // GIVEN
-        StatementResult result = createResult( 1 );
+        Result result = createResult( 1 );
 
         // THEN
         assertThat( result.single().get( "k1" ), equalTo( value( "v1-1" ) ) );
@@ -154,7 +154,7 @@ void singleOfFieldNameShouldWorkAsExpected()
     void singleOfFieldIndexShouldWorkAsExpected()
     {
         // GIVEN
-        StatementResult result = createResult( 1 );
+        Result result = createResult( 1 );
 
         // THEN
         assertThat( result.single().get( 0 ), equalTo( value( "v1-1" ) ) );
@@ -184,7 +184,7 @@ void singleShouldThrowOnConsumedResult()
     {
         assertThrows( ResultConsumedException.class, () ->
         {
-            StatementResult result = createResult( 2 );
+            Result result = createResult( 2 );
             result.consume();
             result.single();
         } );
@@ -194,7 +194,7 @@ void singleShouldThrowOnConsumedResult()
     void shouldConsumeTwice()
     {
         // GIVEN
-        StatementResult result = createResult( 2 );
+        Result result = createResult( 2 );
         result.consume();
 
         // WHEN
@@ -208,7 +208,7 @@ void shouldConsumeTwice()
     void shouldList()
     {
         // GIVEN
-        StatementResult result = createResult( 2 );
+        Result result = createResult( 2 );
         List records = result.list( column( "k1", ofString() ) );
 
         // THEN
@@ -219,7 +219,7 @@ void shouldList()
     void shouldListTwice()
     {
         // GIVEN
-        StatementResult result = createResult( 2 );
+        Result result = createResult( 2 );
         List firstList = result.list();
         assertThat( firstList.size(), equalTo( 2 ) );
 
@@ -232,7 +232,7 @@ void shouldListTwice()
     void singleShouldNotThrowOnPartiallyConsumedResult()
     {
         // Given
-        StatementResult result = createResult( 2 );
+        Result result = createResult( 2 );
         result.next();
 
         // When + Then
@@ -242,7 +242,7 @@ void singleShouldNotThrowOnPartiallyConsumedResult()
     @Test
     void singleShouldConsumeIfFailing()
     {
-        StatementResult result = createResult( 2 );
+        Result result = createResult( 2 );
 
         assertThrows( NoSuchRecordException.class, result::single );
         assertFalse( result.hasNext() );
@@ -252,7 +252,7 @@ void singleShouldConsumeIfFailing()
     void retainShouldWorkAsExpected()
     {
         // GIVEN
-        StatementResult result = createResult( 3 );
+        Result result = createResult( 3 );
 
         // WHEN
         List records = result.list();
@@ -266,7 +266,7 @@ void retainShouldWorkAsExpected()
     void retainAndMapByKeyShouldWorkAsExpected()
     {
         // GIVEN
-        StatementResult result = createResult( 3 );
+        Result result = createResult( 3 );
 
         // WHEN
         List records = result.list( column( "k1" ) );
@@ -280,7 +280,7 @@ void retainAndMapByKeyShouldWorkAsExpected()
     void retainAndMapByIndexShouldWorkAsExpected()
     {
         // GIVEN
-        StatementResult result = createResult( 3 );
+        Result result = createResult( 3 );
 
         // WHEN
         List records = result.list( column( 0 ) );
@@ -294,7 +294,7 @@ void retainAndMapByIndexShouldWorkAsExpected()
     void accessingOutOfBoundsShouldBeNull()
     {
         // GIVEN
-        StatementResult result = createResult( 1 );
+        Result result = createResult( 1 );
 
         // WHEN
         Record record = result.single();
@@ -310,7 +310,7 @@ void accessingOutOfBoundsShouldBeNull()
     void accessingKeysWithoutCallingNextShouldNotFail()
     {
         // GIVEN
-        StatementResult result = createResult( 11 );
+        Result result = createResult( 11 );
 
         // WHEN
         // not calling next or single
@@ -323,7 +323,7 @@ void accessingKeysWithoutCallingNextShouldNotFail()
     void shouldPeekIntoTheFuture()
     {
         // WHEN
-        StatementResult result = createResult( 2 );
+        Result result = createResult( 2 );
 
         // THEN
         assertThat( result.peek().get( "k1" ), equalTo( value( "v1-1" ) ) );
@@ -345,13 +345,13 @@ void shouldPeekIntoTheFuture()
     void shouldNotPeekIntoTheFutureWhenResultIsEmpty()
     {
         // GIVEN
-        StatementResult result = createResult( 0 );
+        Result result = createResult( 0 );
 
         // THEN
         assertThrows( NoSuchRecordException.class, result::peek );
     }
 
-    private StatementResult createResult( int numberOfRecords )
+    private Result createResult(int numberOfRecords )
     {
         RunResponseHandler runHandler = new RunResponseHandler( new CompletableFuture<>(), METADATA_EXTRACTOR );
         runHandler.onSuccess( singletonMap( "fields", value( Arrays.asList( "k1", "k2" ) ) ) );
@@ -369,8 +369,8 @@ private StatementResult createResult( int numberOfRecords )
         }
         pullAllHandler.onSuccess( emptyMap() );
 
-        AsyncStatementResultCursor cursor = new AsyncStatementResultCursorImpl( runHandler, pullAllHandler );
-        return new InternalStatementResult( connection, new DisposableAsyncStatementResultCursor( cursor ) );
+        AsyncResultCursor cursor = new AsyncResultCursorImpl( runHandler, pullAllHandler );
+        return new InternalResult( connection, new DisposableAsyncResultCursor( cursor ) );
     }
 
     private List values( Record record )
diff --git a/driver/src/test/java/org/neo4j/driver/internal/InternalTransactionTest.java b/driver/src/test/java/org/neo4j/driver/internal/InternalTransactionTest.java
index 44434ba763..4b8b20b37d 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/InternalTransactionTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/InternalTransactionTest.java
@@ -28,7 +28,7 @@
 import java.util.stream.Stream;
 
 import org.neo4j.driver.Statement;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.internal.async.ConnectionContext;
@@ -74,7 +74,7 @@ void setUp()
         tx = session.beginTransaction();
     }
 
-    private static Stream> allSessionRunMethods()
+    private static Stream> allSessionRunMethods()
     {
         return Stream.of(
                 tx -> tx.run( "RETURN 1" ),
@@ -88,11 +88,11 @@ private static Stream> allSessionRunMethod
 
     @ParameterizedTest
     @MethodSource( "allSessionRunMethods" )
-    void shouldFlushOnRun( Function runReturnOne ) throws Throwable
+    void shouldFlushOnRun( Function runReturnOne ) throws Throwable
     {
         setupSuccessfulRunAndPull( connection );
 
-        StatementResult result = runReturnOne.apply( tx );
+        Result result = runReturnOne.apply( tx );
         ResultSummary summary = result.consume();
 
         verifyRunAndPull( connection, summary.statement().text() );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/AsyncStatementResultCursorImplTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/AsyncResultCursorImplTest.java
similarity index 87%
rename from driver/src/test/java/org/neo4j/driver/internal/async/AsyncStatementResultCursorImplTest.java
rename to driver/src/test/java/org/neo4j/driver/internal/async/AsyncResultCursorImplTest.java
index 78b141e3a4..ac3eb85695 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/AsyncStatementResultCursorImplTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/AsyncResultCursorImplTest.java
@@ -33,7 +33,7 @@
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
 import org.neo4j.driver.internal.BoltServerAddress;
 import org.neo4j.driver.internal.InternalRecord;
-import org.neo4j.driver.internal.cursor.AsyncStatementResultCursorImpl;
+import org.neo4j.driver.internal.cursor.AsyncResultCursorImpl;
 import org.neo4j.driver.internal.handlers.PullAllResponseHandler;
 import org.neo4j.driver.internal.handlers.RunResponseHandler;
 import org.neo4j.driver.internal.messaging.v1.BoltProtocolV1;
@@ -65,7 +65,7 @@
 import static org.neo4j.driver.util.TestUtil.anyServerVersion;
 import static org.neo4j.driver.util.TestUtil.await;
 
-class AsyncStatementResultCursorImplTest
+class AsyncResultCursorImplTest
 {
     @Test
     void shouldReturnStatementKeys()
@@ -76,7 +76,7 @@ void shouldReturnStatementKeys()
         List keys = asList( "key1", "key2", "key3" );
         runHandler.onSuccess( singletonMap( "fields", value( keys ) ) );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( runHandler, pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( runHandler, pullAllHandler );
 
         assertEquals( keys, cursor.keys() );
     }
@@ -92,7 +92,7 @@ void shouldReturnSummary()
                 null, null, emptyList(), 42, 42 );
         when( pullAllHandler.consumeAsync() ).thenReturn( completedFuture( summary ) );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         assertEquals( summary, await( cursor.consumeAsync() ) );
     }
@@ -105,7 +105,7 @@ void shouldReturnNextExistingRecord()
         Record record = new InternalRecord( asList( "key1", "key2" ), values( 1, 2 ) );
         when( pullAllHandler.nextAsync() ).thenReturn( completedFuture( record ) );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         assertEquals( record, await( cursor.nextAsync() ) );
     }
@@ -116,7 +116,7 @@ void shouldReturnNextNonExistingRecord()
         PullAllResponseHandler pullAllHandler = mock( PullAllResponseHandler.class );
         when( pullAllHandler.nextAsync() ).thenReturn( completedWithNull() );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         assertNull( await( cursor.nextAsync() ) );
     }
@@ -129,7 +129,7 @@ void shouldPeekExistingRecord()
         Record record = new InternalRecord( asList( "key1", "key2", "key3" ), values( 3, 2, 1 ) );
         when( pullAllHandler.peekAsync() ).thenReturn( completedFuture( record ) );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         assertEquals( record, await( cursor.peekAsync() ) );
     }
@@ -140,7 +140,7 @@ void shouldPeekNonExistingRecord()
         PullAllResponseHandler pullAllHandler = mock( PullAllResponseHandler.class );
         when( pullAllHandler.peekAsync() ).thenReturn( completedWithNull() );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         assertNull( await( cursor.peekAsync() ) );
     }
@@ -154,7 +154,7 @@ void shouldReturnSingleRecord()
         when( pullAllHandler.nextAsync() ).thenReturn( completedFuture( record ) )
                 .thenReturn( completedWithNull() );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         assertEquals( record, await( cursor.singleAsync() ) );
     }
@@ -165,7 +165,7 @@ void shouldFailWhenAskedForSingleRecordButResultIsEmpty()
         PullAllResponseHandler pullAllHandler = mock( PullAllResponseHandler.class );
         when( pullAllHandler.nextAsync() ).thenReturn( completedWithNull() );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         NoSuchRecordException e = assertThrows( NoSuchRecordException.class, () -> await( cursor.singleAsync() ) );
         assertThat( e.getMessage(), containsString( "result is empty" ) );
@@ -181,7 +181,7 @@ void shouldFailWhenAskedForSingleRecordButResultContainsMore()
         when( pullAllHandler.nextAsync() ).thenReturn( completedFuture( record1 ) )
                 .thenReturn( completedFuture( record2 ) );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         NoSuchRecordException e = assertThrows( NoSuchRecordException.class, () -> await( cursor.singleAsync() ) );
         assertThat( e.getMessage(), containsString( "Ensure your query returns only one record" ) );
@@ -202,7 +202,7 @@ void shouldForEachAsyncWhenResultContainsMultipleRecords()
         ResultSummary summary = mock( ResultSummary.class );
         when( pullAllHandler.consumeAsync() ).thenReturn( completedFuture( summary ) );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         List records = new CopyOnWriteArrayList<>();
         CompletionStage summaryStage = cursor.forEachAsync( records::add );
@@ -223,7 +223,7 @@ void shouldForEachAsyncWhenResultContainsOneRecords()
         ResultSummary summary = mock( ResultSummary.class );
         when( pullAllHandler.consumeAsync() ).thenReturn( completedFuture( summary ) );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         List records = new CopyOnWriteArrayList<>();
         CompletionStage summaryStage = cursor.forEachAsync( records::add );
@@ -241,7 +241,7 @@ void shouldForEachAsyncWhenResultContainsNoRecords()
         ResultSummary summary = mock( ResultSummary.class );
         when( pullAllHandler.consumeAsync() ).thenReturn( completedFuture( summary ) );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         List records = new CopyOnWriteArrayList<>();
         CompletionStage summaryStage = cursor.forEachAsync( records::add );
@@ -262,7 +262,7 @@ void shouldFailForEachWhenGivenActionThrows()
                 .thenReturn( completedFuture( record2 ) ).thenReturn( completedFuture( record3 ) )
                 .thenReturn( completedWithNull() );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         AtomicInteger recordsProcessed = new AtomicInteger();
         RuntimeException error = new RuntimeException( "Hello" );
@@ -294,7 +294,7 @@ void shouldReturnFailureWhenExists()
         ServiceUnavailableException error = new ServiceUnavailableException( "Hi" );
         when( pullAllHandler.pullAllFailureAsync() ).thenReturn( completedFuture( error ) );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         assertEquals( error, await( cursor.pullAllFailureAsync() ) );
     }
@@ -305,7 +305,7 @@ void shouldReturnNullFailureWhenDoesNotExist()
         PullAllResponseHandler pullAllHandler = mock( PullAllResponseHandler.class );
         when( pullAllHandler.pullAllFailureAsync() ).thenReturn( completedWithNull() );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         assertNull( await( cursor.pullAllFailureAsync() ) );
     }
@@ -321,7 +321,7 @@ void shouldListAsyncWithoutMapFunction()
 
         when( pullAllHandler.listAsync( Function.identity() ) ).thenReturn( completedFuture( records ) );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         assertEquals( records, await( cursor.listAsync() ) );
         verify( pullAllHandler ).listAsync( Function.identity() );
@@ -336,7 +336,7 @@ void shouldListAsyncWithMapFunction()
         List values = asList( "a", "b", "c", "d", "e" );
         when( pullAllHandler.listAsync( mapFunction ) ).thenReturn( completedFuture( values ) );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         assertEquals( values, await( cursor.listAsync( mapFunction ) ) );
         verify( pullAllHandler ).listAsync( mapFunction );
@@ -349,7 +349,7 @@ void shouldPropagateFailureFromListAsyncWithoutMapFunction()
         RuntimeException error = new RuntimeException( "Hi" );
         when( pullAllHandler.listAsync( Function.identity() ) ).thenReturn( failedFuture( error ) );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         RuntimeException e = assertThrows( RuntimeException.class, () -> await( cursor.listAsync() ) );
         assertEquals( error, e );
@@ -364,7 +364,7 @@ void shouldPropagateFailureFromListAsyncWithMapFunction()
         RuntimeException error = new RuntimeException( "Hi" );
         when( pullAllHandler.listAsync( mapFunction ) ).thenReturn( failedFuture( error ) );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         RuntimeException e = assertThrows( RuntimeException.class, () -> await( cursor.listAsync( mapFunction ) ) );
         assertEquals( error, e );
@@ -379,7 +379,7 @@ void shouldConsumeAsync()
         ResultSummary summary = mock( ResultSummary.class );
         when( pullAllHandler.consumeAsync() ).thenReturn( completedFuture( summary ) );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         assertEquals( summary, await( cursor.consumeAsync() ) );
     }
@@ -391,20 +391,20 @@ void shouldPropagateFailureInConsumeAsync()
         RuntimeException error = new RuntimeException( "Hi" );
         when( pullAllHandler.consumeAsync() ).thenReturn( failedFuture( error ) );
 
-        AsyncStatementResultCursorImpl cursor = newCursor( pullAllHandler );
+        AsyncResultCursorImpl cursor = newCursor( pullAllHandler );
 
         RuntimeException e = assertThrows( RuntimeException.class, () -> await( cursor.consumeAsync() ) );
         assertEquals( error, e );
     }
 
-    private static AsyncStatementResultCursorImpl newCursor( PullAllResponseHandler pullAllHandler )
+    private static AsyncResultCursorImpl newCursor(PullAllResponseHandler pullAllHandler )
     {
-        return new AsyncStatementResultCursorImpl( newRunResponseHandler(), pullAllHandler );
+        return new AsyncResultCursorImpl( newRunResponseHandler(), pullAllHandler );
     }
 
-    private static AsyncStatementResultCursorImpl newCursor( RunResponseHandler runHandler, PullAllResponseHandler pullAllHandler )
+    private static AsyncResultCursorImpl newCursor(RunResponseHandler runHandler, PullAllResponseHandler pullAllHandler )
     {
-        return new AsyncStatementResultCursorImpl( runHandler, pullAllHandler );
+        return new AsyncResultCursorImpl( runHandler, pullAllHandler );
     }
 
     private static RunResponseHandler newRunResponseHandler()
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncSessionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncSessionTest.java
index 828ffb9663..ed72a69018 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncSessionTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncSessionTest.java
@@ -36,7 +36,7 @@
 import org.neo4j.driver.async.AsyncSession;
 import org.neo4j.driver.async.AsyncTransaction;
 import org.neo4j.driver.async.AsyncTransactionWork;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
 import org.neo4j.driver.exceptions.SessionExpiredException;
 import org.neo4j.driver.internal.InternalBookmark;
@@ -97,7 +97,7 @@ void setUp()
         asyncSession = new InternalAsyncSession( session );
     }
 
-    private static Stream>> allSessionRunMethods()
+    private static Stream>> allSessionRunMethods()
     {
         return Stream.of(
                 session -> session.runAsync( "RETURN 1" ),
@@ -132,11 +132,11 @@ private static Stream>> allRunTxM
 
     @ParameterizedTest
     @MethodSource( "allSessionRunMethods" )
-    void shouldFlushOnRun( Function> runReturnOne ) throws Throwable
+    void shouldFlushOnRun( Function> runReturnOne ) throws Throwable
     {
         setupSuccessfulRunAndPull( connection );
 
-        StatementResultCursor cursor = await( runReturnOne.apply( asyncSession ) );
+        ResultCursor cursor = await( runReturnOne.apply( asyncSession ) );
 
         verifyRunAndPull( connection, await( cursor.consumeAsync() ).statement().text() );
     }
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncTransactionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncTransactionTest.java
index 983cbca8d7..5c521f3580 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncTransactionTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncTransactionTest.java
@@ -30,7 +30,7 @@
 import org.neo4j.driver.Statement;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.async.AsyncTransaction;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.internal.InternalRecord;
 import org.neo4j.driver.internal.messaging.v4.BoltProtocolV4;
@@ -77,7 +77,7 @@ void setUp()
         tx = (InternalAsyncTransaction) await( session.beginTransactionAsync() );
     }
 
-    private static Stream>> allSessionRunMethods()
+    private static Stream>> allSessionRunMethods()
     {
         return Stream.of(
                 tx -> tx.runAsync( "RETURN 1" ),
@@ -91,11 +91,11 @@ private static Stream> runReturnOne ) throws Throwable
+    void shouldFlushOnRun( Function> runReturnOne ) throws Throwable
     {
         setupSuccessfulRunAndPull( connection );
 
-        StatementResultCursor result = await( runReturnOne.apply( tx ) );
+        ResultCursor result = await( runReturnOne.apply( tx ) );
         ResultSummary summary = await( result.consumeAsync() );
 
         verifyRunAndPull( connection, summary.statement().text() );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/NetworkSessionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/NetworkSessionTest.java
index 15d039b01d..318ed476ef 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/NetworkSessionTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/NetworkSessionTest.java
@@ -28,7 +28,7 @@
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Statement;
 import org.neo4j.driver.TransactionConfig;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.Bookmark;
 import org.neo4j.driver.internal.InternalBookmark;
@@ -124,7 +124,7 @@ void shouldBeAbleToOpenTxAfterPreviousIsClosed()
         await( beginTransaction( session ).closeAsync() );
 
         // When
-        ExplicitTransaction tx = beginTransaction( session );
+        UnmanagedTransaction tx = beginTransaction( session );
 
         // Then we should've gotten a transaction object back
         assertNotNull( tx );
@@ -222,7 +222,7 @@ void closeWithoutConnection()
     @Test
     void acquiresNewConnectionForBeginTx()
     {
-        ExplicitTransaction tx = beginTransaction( session );
+        UnmanagedTransaction tx = beginTransaction( session );
 
         assertNotNull( tx );
         verify( connectionProvider ).acquireConnection( any( ConnectionContext.class ) );
@@ -238,7 +238,7 @@ void updatesBookmarkWhenTxIsClosed()
 
         when( connection.protocol() ).thenReturn( protocol );
 
-        ExplicitTransaction tx = beginTransaction( session );
+        UnmanagedTransaction tx = beginTransaction( session );
         assertThat( session.lastBookmark(), instanceOf( InternalBookmark.class ) );
         Bookmark bookmark = (InternalBookmark) session.lastBookmark();
         assertTrue( bookmark.isEmpty() );
@@ -253,7 +253,7 @@ void releasesConnectionWhenTxIsClosed()
         String query = "RETURN 42";
         setupSuccessfulRunAndPull( connection, query );
 
-        ExplicitTransaction tx = beginTransaction( session );
+        UnmanagedTransaction tx = beginTransaction( session );
         await( tx.runAsync( new Statement( query ), false ) );
 
         verify( connectionProvider ).acquireConnection( any( ConnectionContext.class ) );
@@ -269,7 +269,7 @@ void bookmarkIsPropagatedFromSession()
         Bookmark bookmark = InternalBookmark.parse( "Bookmarks" );
         NetworkSession session = newSession( connectionProvider, bookmark );
 
-        ExplicitTransaction tx = beginTransaction( session );
+        UnmanagedTransaction tx = beginTransaction( session );
         assertNotNull( tx );
         verifyBeginTx( connection, bookmark );
     }
@@ -287,11 +287,11 @@ void bookmarkIsPropagatedBetweenTransactions()
 
         when( connection.protocol() ).thenReturn( protocol );
 
-        ExplicitTransaction tx1 = beginTransaction( session );
+        UnmanagedTransaction tx1 = beginTransaction( session );
         await( tx1.commitAsync() );
         assertEquals( bookmark1, session.lastBookmark() );
 
-        ExplicitTransaction tx2 = beginTransaction( session );
+        UnmanagedTransaction tx2 = beginTransaction( session );
         verifyBeginTx( connection, bookmark1 );
         await( tx2.commitAsync() );
 
@@ -443,7 +443,7 @@ void shouldBeginTxAfterRunFailureToAcquireConnection()
     @Test
     void shouldMarkTransactionAsTerminatedAndThenResetConnectionOnReset()
     {
-        ExplicitTransaction tx = beginTransaction( session );
+        UnmanagedTransaction tx = beginTransaction( session );
 
         assertTrue( tx.isOpen() );
         verify( connection, never() ).reset();
@@ -453,12 +453,12 @@ void shouldMarkTransactionAsTerminatedAndThenResetConnectionOnReset()
         verify( connection ).reset();
     }
 
-    private static StatementResultCursor run( NetworkSession session, String statement )
+    private static ResultCursor run(NetworkSession session, String statement )
     {
         return await( session.runAsync( new Statement( statement ), TransactionConfig.empty(), false ) );
     }
 
-    private static ExplicitTransaction beginTransaction( NetworkSession session )
+    private static UnmanagedTransaction beginTransaction(NetworkSession session )
     {
         return await( session.beginTransactionAsync( TransactionConfig.empty() ) );
     }
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/ResultCursorsHolderTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/ResultCursorsHolderTest.java
index 66dc54aeb7..7e6a72da6f 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/ResultCursorsHolderTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/ResultCursorsHolderTest.java
@@ -25,7 +25,7 @@
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.TimeoutException;
 
-import org.neo4j.driver.internal.cursor.AsyncStatementResultCursorImpl;
+import org.neo4j.driver.internal.cursor.AsyncResultCursorImpl;
 import org.neo4j.driver.internal.util.Futures;
 
 import static java.util.concurrent.CompletableFuture.completedFuture;
@@ -136,19 +136,19 @@ void shouldWaitForAllFailuresToArrive()
         assertEquals( error1, await( failureFuture ) );
     }
 
-    private static CompletionStage cursorWithoutError()
+    private static CompletionStage cursorWithoutError()
     {
         return cursorWithError( null );
     }
 
-    private static CompletionStage cursorWithError( Throwable error )
+    private static CompletionStage cursorWithError(Throwable error )
     {
         return cursorWithFailureFuture( completedFuture( error ) );
     }
 
-    private static CompletionStage cursorWithFailureFuture( CompletableFuture future )
+    private static CompletionStage cursorWithFailureFuture(CompletableFuture future )
     {
-        AsyncStatementResultCursorImpl cursor = mock( AsyncStatementResultCursorImpl.class );
+        AsyncResultCursorImpl cursor = mock( AsyncResultCursorImpl.class );
         when( cursor.discardAllFailureAsync() ).thenReturn( future );
         return completedFuture( cursor );
     }
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/ExplicitTransactionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/UnmanagedTransactionTest.java
similarity index 85%
rename from driver/src/test/java/org/neo4j/driver/internal/async/ExplicitTransactionTest.java
rename to driver/src/test/java/org/neo4j/driver/internal/async/UnmanagedTransactionTest.java
index 3eb1f79333..4ead228ec7 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/ExplicitTransactionTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/UnmanagedTransactionTest.java
@@ -58,7 +58,7 @@
 import static org.neo4j.driver.util.TestUtil.verifyRunAndPull;
 import static org.neo4j.driver.util.TestUtil.verifyRunRx;
 
-class ExplicitTransactionTest
+class UnmanagedTransactionTest
 {
     @ParameterizedTest
     @ValueSource( strings = {"true", "false"} )
@@ -66,7 +66,7 @@ void shouldFlushOnRunAsync( boolean waitForResponse )
     {
         // Given
         Connection connection = connectionMock( BoltProtocolV4.INSTANCE );
-        ExplicitTransaction tx = beginTx( connection );
+        UnmanagedTransaction tx = beginTx( connection );
         setupSuccessfulRunAndPull( connection );
 
         // When
@@ -81,7 +81,7 @@ void shouldFlushOnRunRx()
     {
         // Given
         Connection connection = connectionMock( BoltProtocolV4.INSTANCE );
-        ExplicitTransaction tx = beginTx( connection );
+        UnmanagedTransaction tx = beginTx( connection );
         setupSuccessfulRunRx( connection );
 
         // When
@@ -96,7 +96,7 @@ void shouldRollbackOnImplicitFailure()
     {
         // Given
         Connection connection = connectionMock();
-        ExplicitTransaction tx = beginTx( connection );
+        UnmanagedTransaction tx = beginTx( connection );
 
         // When
         await( tx.closeAsync() );
@@ -134,7 +134,7 @@ void shouldFlushWhenBookmarkGiven()
     @Test
     void shouldBeOpenAfterConstruction()
     {
-        ExplicitTransaction tx = beginTx( connectionMock() );
+        UnmanagedTransaction tx = beginTx( connectionMock() );
 
         assertTrue( tx.isOpen() );
     }
@@ -142,7 +142,7 @@ void shouldBeOpenAfterConstruction()
     @Test
     void shouldBeClosedWhenMarkedAsTerminated()
     {
-        ExplicitTransaction tx = beginTx( connectionMock() );
+        UnmanagedTransaction tx = beginTx( connectionMock() );
 
         tx.markTerminated();
 
@@ -152,7 +152,7 @@ void shouldBeClosedWhenMarkedAsTerminated()
     @Test
     void shouldBeClosedWhenMarkedTerminatedAndClosed()
     {
-        ExplicitTransaction tx = beginTx( connectionMock() );
+        UnmanagedTransaction tx = beginTx( connectionMock() );
 
         tx.markTerminated();
         await( tx.closeAsync() );
@@ -165,7 +165,7 @@ void shouldReleaseConnectionWhenBeginFails()
     {
         RuntimeException error = new RuntimeException( "Wrong bookmark!" );
         Connection connection = connectionWithBegin( handler -> handler.onFailure( error ) );
-        ExplicitTransaction tx = new ExplicitTransaction( connection, new DefaultBookmarkHolder(), UNLIMITED_FETCH_SIZE );
+        UnmanagedTransaction tx = new UnmanagedTransaction( connection, new DefaultBookmarkHolder(), UNLIMITED_FETCH_SIZE );
 
         Bookmark bookmark = InternalBookmark.parse( "SomeBookmark" );
         TransactionConfig txConfig = TransactionConfig.empty();
@@ -180,7 +180,7 @@ void shouldReleaseConnectionWhenBeginFails()
     void shouldNotReleaseConnectionWhenBeginSucceeds()
     {
         Connection connection = connectionWithBegin( handler -> handler.onSuccess( emptyMap() ) );
-        ExplicitTransaction tx = new ExplicitTransaction( connection, new DefaultBookmarkHolder(), UNLIMITED_FETCH_SIZE );
+        UnmanagedTransaction tx = new UnmanagedTransaction( connection, new DefaultBookmarkHolder(), UNLIMITED_FETCH_SIZE );
 
         Bookmark bookmark = InternalBookmark.parse( "SomeBookmark" );
         TransactionConfig txConfig = TransactionConfig.empty();
@@ -194,7 +194,7 @@ void shouldNotReleaseConnectionWhenBeginSucceeds()
     void shouldReleaseConnectionWhenTerminatedAndCommitted()
     {
         Connection connection = connectionMock();
-        ExplicitTransaction tx = new ExplicitTransaction( connection, new DefaultBookmarkHolder(), UNLIMITED_FETCH_SIZE );
+        UnmanagedTransaction tx = new UnmanagedTransaction( connection, new DefaultBookmarkHolder(), UNLIMITED_FETCH_SIZE );
 
         tx.markTerminated();
 
@@ -208,7 +208,7 @@ void shouldReleaseConnectionWhenTerminatedAndCommitted()
     void shouldReleaseConnectionWhenTerminatedAndRolledBack()
     {
         Connection connection = connectionMock();
-        ExplicitTransaction tx = new ExplicitTransaction( connection, new DefaultBookmarkHolder(), UNLIMITED_FETCH_SIZE );
+        UnmanagedTransaction tx = new UnmanagedTransaction( connection, new DefaultBookmarkHolder(), UNLIMITED_FETCH_SIZE );
 
         tx.markTerminated();
         await( tx.rollbackAsync() );
@@ -220,21 +220,21 @@ void shouldReleaseConnectionWhenTerminatedAndRolledBack()
     void shouldReleaseConnectionWhenClose() throws Throwable
     {
         Connection connection = connectionMock();
-        ExplicitTransaction tx = new ExplicitTransaction( connection, new DefaultBookmarkHolder(), UNLIMITED_FETCH_SIZE );
+        UnmanagedTransaction tx = new UnmanagedTransaction( connection, new DefaultBookmarkHolder(), UNLIMITED_FETCH_SIZE );
 
         await( tx.closeAsync() );
 
         verify( connection ).release();
     }
 
-    private static ExplicitTransaction beginTx( Connection connection )
+    private static UnmanagedTransaction beginTx(Connection connection )
     {
         return beginTx( connection, InternalBookmark.empty() );
     }
 
-    private static ExplicitTransaction beginTx( Connection connection, Bookmark initialBookmark )
+    private static UnmanagedTransaction beginTx(Connection connection, Bookmark initialBookmark )
     {
-        ExplicitTransaction tx = new ExplicitTransaction( connection, new DefaultBookmarkHolder(), UNLIMITED_FETCH_SIZE );
+        UnmanagedTransaction tx = new UnmanagedTransaction( connection, new DefaultBookmarkHolder(), UNLIMITED_FETCH_SIZE );
         return await( tx.beginAsync( initialBookmark, TransactionConfig.empty() ) );
     }
 
diff --git a/driver/src/test/java/org/neo4j/driver/internal/cursor/AsyncStatementResultCursorOnlyFactoryTest.java b/driver/src/test/java/org/neo4j/driver/internal/cursor/AsyncResultCursorOnlyFactoryTest.java
similarity index 74%
rename from driver/src/test/java/org/neo4j/driver/internal/cursor/AsyncStatementResultCursorOnlyFactoryTest.java
rename to driver/src/test/java/org/neo4j/driver/internal/cursor/AsyncResultCursorOnlyFactoryTest.java
index 3831b19852..7fae966a36 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/cursor/AsyncStatementResultCursorOnlyFactoryTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/cursor/AsyncResultCursorOnlyFactoryTest.java
@@ -47,7 +47,7 @@
 import static org.neo4j.driver.internal.util.Futures.failedFuture;
 import static org.neo4j.driver.internal.util.Futures.getNow;
 
-class AsyncStatementResultCursorOnlyFactoryTest
+class AsyncResultCursorOnlyFactoryTest
 {
     private static Stream waitForRun()
     {
@@ -61,10 +61,10 @@ void shouldReturnAsyncResultWhenRunSucceeded( boolean waitForRun ) throws Throwa
     {
         // Given
         Connection connection = mock( Connection.class );
-        StatementResultCursorFactory cursorFactory = newResultCursorFactory( connection, completedWithNull(), waitForRun );
+        ResultCursorFactory cursorFactory = newResultCursorFactory( connection, completedWithNull(), waitForRun );
 
         // When
-        CompletionStage cursorFuture = cursorFactory.asyncResult();
+        CompletionStage cursorFuture = cursorFactory.asyncResult();
 
         // Then
 
@@ -78,10 +78,10 @@ void shouldReturnAsyncResultWhenRunCompletedWithFailure( boolean waitForRun ) th
         // Given
         Connection connection = mock( Connection.class );
         Throwable error = new RuntimeException( "Hi there" );
-        StatementResultCursorFactory cursorFactory = newResultCursorFactory( connection, completedFuture( error ), waitForRun );
+        ResultCursorFactory cursorFactory = newResultCursorFactory( connection, completedFuture( error ), waitForRun );
 
         // When
-        CompletionStage cursorFuture = cursorFactory.asyncResult();
+        CompletionStage cursorFuture = cursorFactory.asyncResult();
 
         // Then
         verifyRunCompleted( connection, cursorFuture );
@@ -92,10 +92,10 @@ void shouldFailAsyncResultWhenRunFailed() throws Throwable
     {
         // Given
         Throwable error = new RuntimeException( "Hi there" );
-        StatementResultCursorFactory cursorFactory = newResultCursorFactory( failedFuture( error ), true );
+        ResultCursorFactory cursorFactory = newResultCursorFactory( failedFuture( error ), true );
 
         // When
-        CompletionStage cursorFuture = cursorFactory.asyncResult();
+        CompletionStage cursorFuture = cursorFactory.asyncResult();
 
         // Then
         CompletionException actual = assertThrows( CompletionException.class, () -> getNow( cursorFuture ) );
@@ -108,10 +108,10 @@ void shouldNotFailAsyncResultEvenWhenRunFailed() throws Throwable
         // Given
         Connection connection = mock( Connection.class );
         Throwable error = new RuntimeException( "Hi there" );
-        StatementResultCursorFactory cursorFactory = newResultCursorFactory( connection, failedFuture( error ), false );
+        ResultCursorFactory cursorFactory = newResultCursorFactory( connection, failedFuture( error ), false );
 
         // When
-        CompletionStage cursorFuture = cursorFactory.asyncResult();
+        CompletionStage cursorFuture = cursorFactory.asyncResult();
 
         // Then
         verifyRunCompleted( connection, cursorFuture );
@@ -130,7 +130,7 @@ void shouldPrePopulateRecords( boolean waitForRun ) throws Throwable
 
         PullAllResponseHandler pullAllHandler = mock( PullAllResponseHandler.class );
 
-        StatementResultCursorFactory cursorFactory = new AsyncStatementResultCursorOnlyFactory( connection, runMessage, runHandler, pullAllHandler, waitForRun );
+        ResultCursorFactory cursorFactory = new AsyncResultCursorOnlyFactory( connection, runMessage, runHandler, pullAllHandler, waitForRun );
 
         // When
         cursorFactory.asyncResult();
@@ -145,15 +145,15 @@ void shouldPrePopulateRecords( boolean waitForRun ) throws Throwable
     void shouldErrorForRxResult( boolean waitForRun ) throws Throwable
     {
         // Given
-        StatementResultCursorFactory cursorFactory = newResultCursorFactory( completedWithNull(), waitForRun );
+        ResultCursorFactory cursorFactory = newResultCursorFactory( completedWithNull(), waitForRun );
 
         // When & Then
-        CompletionStage rxCursorFuture = cursorFactory.rxResult();
+        CompletionStage rxCursorFuture = cursorFactory.rxResult();
         CompletionException error = assertThrows( CompletionException.class, () -> getNow( rxCursorFuture ) );
         assertThat( error.getCause().getMessage(), containsString( "Driver is connected to the database that does not support driver reactive API" ) );
     }
 
-    private AsyncStatementResultCursorOnlyFactory newResultCursorFactory( Connection connection, CompletableFuture runFuture, boolean waitForRun )
+    private AsyncResultCursorOnlyFactory newResultCursorFactory(Connection connection, CompletableFuture runFuture, boolean waitForRun )
     {
         Message runMessage = mock( Message.class );
 
@@ -162,18 +162,18 @@ private AsyncStatementResultCursorOnlyFactory newResultCursorFactory( Connection
 
         AutoPullResponseHandler pullHandler = mock( AutoPullResponseHandler.class );
 
-        return new AsyncStatementResultCursorOnlyFactory( connection, runMessage, runHandler, pullHandler, waitForRun );
+        return new AsyncResultCursorOnlyFactory( connection, runMessage, runHandler, pullHandler, waitForRun );
     }
 
-    private AsyncStatementResultCursorOnlyFactory newResultCursorFactory( CompletableFuture runFuture, boolean waitForRun )
+    private AsyncResultCursorOnlyFactory newResultCursorFactory(CompletableFuture runFuture, boolean waitForRun )
     {
         Connection connection = mock( Connection.class );
         return newResultCursorFactory( connection, runFuture, waitForRun );
     }
 
-    private void verifyRunCompleted( Connection connection, CompletionStage cursorFuture )
+    private void verifyRunCompleted( Connection connection, CompletionStage cursorFuture )
     {
         verify( connection ).write( any( Message.class ), any( RunResponseHandler.class ) );
-        assertThat( getNow( cursorFuture ), instanceOf( AsyncStatementResultCursor.class ) );
+        assertThat( getNow( cursorFuture ), instanceOf( AsyncResultCursor.class ) );
     }
 }
diff --git a/driver/src/test/java/org/neo4j/driver/internal/cursor/DisposableAsyncStatementResultCursorTest.java b/driver/src/test/java/org/neo4j/driver/internal/cursor/DisposableAsyncResultCursorTest.java
similarity index 85%
rename from driver/src/test/java/org/neo4j/driver/internal/cursor/DisposableAsyncStatementResultCursorTest.java
rename to driver/src/test/java/org/neo4j/driver/internal/cursor/DisposableAsyncResultCursorTest.java
index 4ca099e3fe..e968575353 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/cursor/DisposableAsyncStatementResultCursorTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/cursor/DisposableAsyncResultCursorTest.java
@@ -29,13 +29,13 @@
 import static org.mockito.Mockito.when;
 import static org.neo4j.driver.util.TestUtil.await;
 
-class DisposableAsyncStatementResultCursorTest
+class DisposableAsyncResultCursorTest
 {
     @Test
     void summaryShouldDisposeCursor() throws Throwable
     {
         // Given
-        DisposableAsyncStatementResultCursor cursor = newCursor();
+        DisposableAsyncResultCursor cursor = newCursor();
 
         // When
         await( cursor.consumeAsync() );
@@ -48,7 +48,7 @@ void summaryShouldDisposeCursor() throws Throwable
     void consumeShouldDisposeCursor() throws Throwable
     {
         // Given
-        DisposableAsyncStatementResultCursor cursor = newCursor();
+        DisposableAsyncResultCursor cursor = newCursor();
 
         // When
         await( cursor.discardAllFailureAsync() );
@@ -61,7 +61,7 @@ void consumeShouldDisposeCursor() throws Throwable
     void shouldNotDisposeCursor() throws Throwable
     {
         // Given
-        DisposableAsyncStatementResultCursor cursor = newCursor();
+        DisposableAsyncResultCursor cursor = newCursor();
 
         // When
         cursor.keys();
@@ -77,9 +77,9 @@ void shouldNotDisposeCursor() throws Throwable
         assertFalse( cursor.isDisposed() );
     }
 
-    private static DisposableAsyncStatementResultCursor newCursor()
+    private static DisposableAsyncResultCursor newCursor()
     {
-        AsyncStatementResultCursor delegate = mock( AsyncStatementResultCursor.class );
+        AsyncResultCursor delegate = mock( AsyncResultCursor.class );
         when( delegate.consumeAsync() ).thenReturn( Futures.completedWithNull() );
         when( delegate.discardAllFailureAsync() ).thenReturn( Futures.completedWithNull() );
         when( delegate.peekAsync() ).thenReturn( Futures.completedWithNull() );
@@ -89,6 +89,6 @@ private static DisposableAsyncStatementResultCursor newCursor()
         when( delegate.listAsync() ).thenReturn( Futures.completedWithNull() );
         when( delegate.listAsync( any() ) ).thenReturn( Futures.completedWithNull() );
         when( delegate.pullAllFailureAsync() ).thenReturn( Futures.completedWithNull() );
-        return new DisposableAsyncStatementResultCursor( delegate );
+        return new DisposableAsyncResultCursor( delegate );
     }
 }
diff --git a/driver/src/test/java/org/neo4j/driver/internal/cursor/StatementResultCursorFactoryImplTest.java b/driver/src/test/java/org/neo4j/driver/internal/cursor/ResultCursorFactoryImplTest.java
similarity index 71%
rename from driver/src/test/java/org/neo4j/driver/internal/cursor/StatementResultCursorFactoryImplTest.java
rename to driver/src/test/java/org/neo4j/driver/internal/cursor/ResultCursorFactoryImplTest.java
index cf8a327855..ae02d8c0a2 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/cursor/StatementResultCursorFactoryImplTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/cursor/ResultCursorFactoryImplTest.java
@@ -47,7 +47,7 @@
 import static org.neo4j.driver.internal.util.Futures.failedFuture;
 import static org.neo4j.driver.internal.util.Futures.getNow;
 
-class StatementResultCursorFactoryImplTest
+class ResultCursorFactoryImplTest
 {
     private static Stream waitForRun()
     {
@@ -61,10 +61,10 @@ void shouldReturnAsyncResultWhenRunSucceeded( boolean waitForRun ) throws Throwa
     {
         // Given
         Connection connection = mock( Connection.class );
-        StatementResultCursorFactory cursorFactory = newResultCursorFactory( connection, completedWithNull(), waitForRun );
+        ResultCursorFactory cursorFactory = newResultCursorFactory( connection, completedWithNull(), waitForRun );
 
         // When
-        CompletionStage cursorFuture = cursorFactory.asyncResult();
+        CompletionStage cursorFuture = cursorFactory.asyncResult();
 
         // Then
         verifyRunCompleted( connection, cursorFuture );
@@ -77,10 +77,10 @@ void shouldReturnAsyncResultWhenRunCompletedWithFailure( boolean waitForRun ) th
         // Given
         Connection connection = mock( Connection.class );
         Throwable error = new RuntimeException( "Hi there" );
-        StatementResultCursorFactory cursorFactory = newResultCursorFactory( connection, completedFuture( error ), waitForRun );
+        ResultCursorFactory cursorFactory = newResultCursorFactory( connection, completedFuture( error ), waitForRun );
 
         // When
-        CompletionStage cursorFuture = cursorFactory.asyncResult();
+        CompletionStage cursorFuture = cursorFactory.asyncResult();
 
         // Then
         verifyRunCompleted( connection, cursorFuture );
@@ -91,10 +91,10 @@ void shouldFailAsyncResultWhenRunFailed() throws Throwable
     {
         // Given
         Throwable error = new RuntimeException( "Hi there" );
-        StatementResultCursorFactory cursorFactory = newResultCursorFactory( failedFuture( error ), true );
+        ResultCursorFactory cursorFactory = newResultCursorFactory( failedFuture( error ), true );
 
         // When
-        CompletionStage cursorFuture = cursorFactory.asyncResult();
+        CompletionStage cursorFuture = cursorFactory.asyncResult();
 
         // Then
         CompletionException actual = assertThrows( CompletionException.class, () -> getNow( cursorFuture ) );
@@ -107,10 +107,10 @@ void shouldNotFailAsyncResultEvenWhenRunFailed() throws Throwable
         // Given
         Connection connection = mock( Connection.class );
         Throwable error = new RuntimeException( "Hi there" );
-        StatementResultCursorFactory cursorFactory = newResultCursorFactory( connection, failedFuture( error ), false );
+        ResultCursorFactory cursorFactory = newResultCursorFactory( connection, failedFuture( error ), false );
 
         // When
-        CompletionStage cursorFuture = cursorFactory.asyncResult();
+        CompletionStage cursorFuture = cursorFactory.asyncResult();
 
         // Then
         verifyRunCompleted( connection, cursorFuture );
@@ -130,7 +130,7 @@ void shouldPrePopulateRecords( boolean waitForRun ) throws Throwable
         PullResponseHandler pullHandler = mock( PullResponseHandler.class );
         PullAllResponseHandler pullAllHandler = mock( PullAllResponseHandler.class );
 
-        StatementResultCursorFactory cursorFactory = new StatementResultCursorFactoryImpl( connection, runMessage, runHandler, pullHandler, pullAllHandler, waitForRun );
+        ResultCursorFactory cursorFactory = new ResultCursorFactoryImpl( connection, runMessage, runHandler, pullHandler, pullAllHandler, waitForRun );
 
         // When
         cursorFactory.asyncResult();
@@ -147,10 +147,10 @@ void shouldReturnRxResultWhenRunSucceeded( boolean waitForRun ) throws Throwable
     {
         // Given
         Connection connection = mock( Connection.class );
-        StatementResultCursorFactory cursorFactory = newResultCursorFactory( connection, completedWithNull(), waitForRun );
+        ResultCursorFactory cursorFactory = newResultCursorFactory( connection, completedWithNull(), waitForRun );
 
         // When
-        CompletionStage cursorFuture = cursorFactory.rxResult();
+        CompletionStage cursorFuture = cursorFactory.rxResult();
 
         // Then
         verifyRxRunCompleted( connection, cursorFuture );
@@ -163,10 +163,10 @@ void shouldReturnRxResultWhenRunCompletedWithFailure( boolean waitForRun ) throw
         // Given
         Connection connection = mock( Connection.class );
         Throwable error = new RuntimeException( "Hi there" );
-        StatementResultCursorFactory cursorFactory = newResultCursorFactory( connection, completedFuture( error ), waitForRun );
+        ResultCursorFactory cursorFactory = newResultCursorFactory( connection, completedFuture( error ), waitForRun );
 
         // When
-        CompletionStage cursorFuture = cursorFactory.rxResult();
+        CompletionStage cursorFuture = cursorFactory.rxResult();
 
         // Then
         verifyRxRunCompleted( connection, cursorFuture );
@@ -177,10 +177,10 @@ void shouldFailRxResultWhenRunFailed() throws Throwable
     {
         // Given
         Throwable error = new RuntimeException( "Hi there" );
-        StatementResultCursorFactory cursorFactory = newResultCursorFactory( failedFuture( error ), true );
+        ResultCursorFactory cursorFactory = newResultCursorFactory( failedFuture( error ), true );
 
         // When & Then
-        CompletionStage rxCursorFuture = cursorFactory.rxResult();
+        CompletionStage rxCursorFuture = cursorFactory.rxResult();
         CompletionException actual = assertThrows( CompletionException.class, () -> getNow( rxCursorFuture ) );
         assertThat( actual.getCause(), equalTo( error ) );
     }
@@ -191,16 +191,16 @@ void shouldNotFailRxResultEvenWhenRunFailed() throws Throwable
         // Given
         Connection connection = mock( Connection.class );
         Throwable error = new RuntimeException( "Hi there" );
-        StatementResultCursorFactory cursorFactory = newResultCursorFactory( connection, completedFuture( error ), false );
+        ResultCursorFactory cursorFactory = newResultCursorFactory( connection, completedFuture( error ), false );
 
         // When
-        CompletionStage cursorFuture = cursorFactory.rxResult();
+        CompletionStage cursorFuture = cursorFactory.rxResult();
 
         // Then
         verifyRxRunCompleted( connection, cursorFuture );
     }
 
-    private StatementResultCursorFactoryImpl newResultCursorFactory( Connection connection, CompletableFuture runFuture, boolean waitForRun )
+    private ResultCursorFactoryImpl newResultCursorFactory(Connection connection, CompletableFuture runFuture, boolean waitForRun )
     {
         Message runMessage = mock( Message.class );
 
@@ -210,24 +210,24 @@ private StatementResultCursorFactoryImpl newResultCursorFactory( Connection conn
         PullResponseHandler pullHandler = mock( PullResponseHandler.class );
         PullAllResponseHandler pullAllHandler = mock( PullAllResponseHandler.class );
 
-        return new StatementResultCursorFactoryImpl( connection, runMessage, runHandler, pullHandler, pullAllHandler, waitForRun );
+        return new ResultCursorFactoryImpl( connection, runMessage, runHandler, pullHandler, pullAllHandler, waitForRun );
     }
 
-    private StatementResultCursorFactoryImpl newResultCursorFactory( CompletableFuture runFuture, boolean waitForRun )
+    private ResultCursorFactoryImpl newResultCursorFactory(CompletableFuture runFuture, boolean waitForRun )
     {
         Connection connection = mock( Connection.class );
         return newResultCursorFactory( connection, runFuture, waitForRun );
     }
 
-    private void verifyRunCompleted( Connection connection, CompletionStage cursorFuture )
+    private void verifyRunCompleted( Connection connection, CompletionStage cursorFuture )
     {
         verify( connection ).write( any( Message.class ), any( RunResponseHandler.class ) );
-        assertThat( getNow( cursorFuture ), instanceOf( AsyncStatementResultCursor.class ) );
+        assertThat( getNow( cursorFuture ), instanceOf( AsyncResultCursor.class ) );
     }
 
-    private void verifyRxRunCompleted( Connection connection, CompletionStage cursorFuture )
+    private void verifyRxRunCompleted( Connection connection, CompletionStage cursorFuture )
     {
         verify( connection ).writeAndFlush( any( Message.class ), any( RunResponseHandler.class ) );
-        assertThat( getNow( cursorFuture ), instanceOf( RxStatementResultCursorImpl.class ) );
+        assertThat( getNow( cursorFuture ), instanceOf( RxResultCursorImpl.class ) );
     }
 }
diff --git a/driver/src/test/java/org/neo4j/driver/internal/cursor/RxStatementResultCursorImplTest.java b/driver/src/test/java/org/neo4j/driver/internal/cursor/RxResultCursorImplTest.java
similarity index 86%
rename from driver/src/test/java/org/neo4j/driver/internal/cursor/RxStatementResultCursorImplTest.java
rename to driver/src/test/java/org/neo4j/driver/internal/cursor/RxResultCursorImplTest.java
index 2442757ca3..95f812278c 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/cursor/RxStatementResultCursorImplTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/cursor/RxResultCursorImplTest.java
@@ -43,11 +43,11 @@
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.neo4j.driver.Values.value;
-import static org.neo4j.driver.internal.cursor.RxStatementResultCursorImpl.DISCARD_RECORD_CONSUMER;
+import static org.neo4j.driver.internal.cursor.RxResultCursorImpl.DISCARD_RECORD_CONSUMER;
 import static org.neo4j.driver.internal.messaging.v3.BoltProtocolV3.METADATA_EXTRACTOR;
 import static org.neo4j.driver.internal.util.Futures.completedWithNull;
 
-class RxStatementResultCursorImplTest
+class RxResultCursorImplTest
 {
     @Test
     void shouldWaitForRunToFinishBeforeCreatingRxResultCurosr() throws Throwable
@@ -58,7 +58,7 @@ void shouldWaitForRunToFinishBeforeCreatingRxResultCurosr() throws Throwable
         PullResponseHandler pullHandler = mock( PullResponseHandler.class );
 
         // When
-        IllegalStateException error = assertThrows( IllegalStateException.class, () -> new RxStatementResultCursorImpl( runHandler, pullHandler ) );
+        IllegalStateException error = assertThrows( IllegalStateException.class, () -> new RxResultCursorImpl( runHandler, pullHandler ) );
         // Then
         assertThat( error.getMessage(), containsString( "Should wait for response of RUN" ) );
     }
@@ -72,7 +72,7 @@ void shouldInstallSummaryConsumerWithoutReportingError() throws Throwable
         PullResponseHandler pullHandler = mock( PullResponseHandler.class );
 
         // When
-        new RxStatementResultCursorImpl( error, runHandler, pullHandler );
+        new RxResultCursorImpl( error, runHandler, pullHandler );
 
         // Then
         verify( pullHandler ).installSummaryConsumer( any( BiConsumer.class ) );
@@ -90,7 +90,7 @@ void shouldReturnStatementKeys() throws Throwable
         PullResponseHandler pullHandler = mock( PullResponseHandler.class );
 
         // When
-        RxStatementResultCursor cursor = new RxStatementResultCursorImpl( runHandler, pullHandler );
+        RxResultCursor cursor = new RxResultCursorImpl( runHandler, pullHandler );
         List actual = cursor.keys();
 
         // Then
@@ -108,7 +108,7 @@ void shouldSupportReturnStatementKeysMultipleTimes() throws Throwable
         PullResponseHandler pullHandler = mock( PullResponseHandler.class );
 
         // When
-        RxStatementResultCursor cursor = new RxStatementResultCursorImpl( runHandler, pullHandler );
+        RxResultCursor cursor = new RxResultCursorImpl( runHandler, pullHandler );
 
         // Then
         List actual = cursor.keys();
@@ -128,7 +128,7 @@ void shouldPull() throws Throwable
         // Given
         RunResponseHandler runHandler = newRunResponseHandler();
         PullResponseHandler pullHandler = mock( PullResponseHandler.class );
-        RxStatementResultCursor cursor = new RxStatementResultCursorImpl( runHandler, pullHandler );
+        RxResultCursor cursor = new RxResultCursorImpl( runHandler, pullHandler );
 
         // When
         cursor.request( 100 );
@@ -143,7 +143,7 @@ void shouldCancel() throws Throwable
         // Given
         RunResponseHandler runHandler = newRunResponseHandler();
         PullResponseHandler pullHandler = mock( PullResponseHandler.class );
-        RxStatementResultCursor cursor = new RxStatementResultCursorImpl( runHandler, pullHandler );
+        RxResultCursor cursor = new RxResultCursorImpl( runHandler, pullHandler );
 
         // When
         cursor.cancel();
@@ -162,7 +162,7 @@ void shouldInstallRecordConsumerAndReportError() throws Throwable
         // When
         RunResponseHandler runHandler = newRunResponseHandler( error );
         PullResponseHandler pullHandler = new ListBasedPullHandler();
-        RxStatementResultCursor cursor = new RxStatementResultCursorImpl( error, runHandler, pullHandler );
+        RxResultCursor cursor = new RxResultCursorImpl( error, runHandler, pullHandler );
         cursor.installRecordConsumer( recordConsumer );
 
         // Then
@@ -176,7 +176,7 @@ void shouldReturnSummaryFuture() throws Throwable
         // Given
         RunResponseHandler runHandler = newRunResponseHandler();
         PullResponseHandler pullHandler = new ListBasedPullHandler();
-        RxStatementResultCursor cursor = new RxStatementResultCursorImpl( runHandler, pullHandler );
+        RxResultCursor cursor = new RxResultCursorImpl( runHandler, pullHandler );
 
         // When
         cursor.installRecordConsumer( DISCARD_RECORD_CONSUMER );
@@ -193,7 +193,7 @@ void shouldNotAllowToInstallRecordConsumerAfterSummary() throws Throwable
         // Given
         RunResponseHandler runHandler = newRunResponseHandler();
         PullResponseHandler pullHandler = new ListBasedPullHandler();
-        RxStatementResultCursor cursor = new RxStatementResultCursorImpl( runHandler, pullHandler );
+        RxResultCursor cursor = new RxResultCursorImpl( runHandler, pullHandler );
 
         // When
         cursor.summaryAsync();
@@ -208,7 +208,7 @@ void shouldAllowToCallSummaryMultipleTimes() throws Throwable
         // Given
         RunResponseHandler runHandler = newRunResponseHandler();
         PullResponseHandler pullHandler = new ListBasedPullHandler();
-        RxStatementResultCursor cursor = new RxStatementResultCursorImpl( runHandler, pullHandler );
+        RxResultCursor cursor = new RxResultCursorImpl( runHandler, pullHandler );
 
         // When
         cursor.summaryAsync();
@@ -224,7 +224,7 @@ void shouldOnlyInstallRecordConsumerOnce() throws Throwable
         // Given
         RunResponseHandler runHandler = newRunResponseHandler();
         PullResponseHandler pullHandler = mock( PullResponseHandler.class );
-        RxStatementResultCursor cursor = new RxStatementResultCursorImpl( runHandler, pullHandler );
+        RxResultCursor cursor = new RxResultCursorImpl( runHandler, pullHandler );
 
         // When
         cursor.installRecordConsumer( DISCARD_RECORD_CONSUMER ); // any consumer
@@ -240,7 +240,7 @@ void shouldCancelIfNotPulled() throws Throwable
         // Given
         RunResponseHandler runHandler = newRunResponseHandler();
         PullResponseHandler pullHandler = mock( PullResponseHandler.class );
-        RxStatementResultCursor cursor = new RxStatementResultCursorImpl( runHandler, pullHandler );
+        RxResultCursor cursor = new RxResultCursorImpl( runHandler, pullHandler );
 
         // When
         cursor.summaryAsync();
diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListenerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListenerTest.java
index 16ab6db684..068fcdf4c5 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListenerTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListenerTest.java
@@ -29,7 +29,7 @@
 import org.neo4j.driver.exceptions.SessionExpiredException;
 import org.neo4j.driver.exceptions.TransientException;
 import org.neo4j.driver.internal.BoltServerAddress;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
 import org.neo4j.driver.internal.handlers.pulln.BasicPullResponseHandler;
 import org.neo4j.driver.internal.handlers.pulln.PullResponseHandler;
 import org.neo4j.driver.internal.spi.Connection;
@@ -63,7 +63,7 @@ private static void testErrorHandling( Throwable error )
         Connection connection = mock( Connection.class );
         when( connection.serverAddress() ).thenReturn( BoltServerAddress.LOCAL_DEFAULT );
         when( connection.serverVersion() ).thenReturn( anyServerVersion() );
-        ExplicitTransaction tx = mock( ExplicitTransaction.class );
+        UnmanagedTransaction tx = mock( UnmanagedTransaction.class );
         TransactionPullResponseCompletionListener listener = new TransactionPullResponseCompletionListener( tx );
         RunResponseHandler runHandler = new RunResponseHandler( new CompletableFuture<>(), METADATA_EXTRACTOR );
         PullResponseHandler handler = new BasicPullResponseHandler( new Statement( "RETURN 1" ), runHandler,
diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/TransactionPullResponseCompletionListenerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/TransactionPullResponseCompletionListenerTest.java
index b70218f232..e472f1a062 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/TransactionPullResponseCompletionListenerTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/TransactionPullResponseCompletionListenerTest.java
@@ -23,7 +23,7 @@
 
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Statement;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
 import org.neo4j.driver.internal.handlers.RunResponseHandler;
 import org.neo4j.driver.internal.handlers.TransactionPullResponseCompletionListener;
 import org.neo4j.driver.internal.messaging.v4.BoltProtocolV4;
@@ -66,7 +66,7 @@ protected void shouldHandleFailure( PullResponseHandler.Status status )
         Connection conn = mockConnection();
         BiConsumer recordConsumer = mock( BiConsumer.class );
         BiConsumer summaryConsumer = mock( BiConsumer.class );
-        ExplicitTransaction tx = mock( ExplicitTransaction.class );
+        UnmanagedTransaction tx = mock( UnmanagedTransaction.class );
         BasicPullResponseHandler handler = newTxResponseHandler( conn, recordConsumer, summaryConsumer, tx, status );
 
         // When
@@ -84,12 +84,12 @@ protected void shouldHandleFailure( PullResponseHandler.Status status )
     protected BasicPullResponseHandler newResponseHandlerWithStatus( Connection conn, BiConsumer recordConsumer,
             BiConsumer summaryConsumer, PullResponseHandler.Status status )
     {
-        ExplicitTransaction tx = mock( ExplicitTransaction.class );
+        UnmanagedTransaction tx = mock( UnmanagedTransaction.class );
         return newTxResponseHandler( conn, recordConsumer, summaryConsumer, tx, status );
     }
 
-    private static BasicPullResponseHandler newTxResponseHandler( Connection conn, BiConsumer recordConsumer,
-            BiConsumer summaryConsumer, ExplicitTransaction tx, PullResponseHandler.Status status )
+    private static BasicPullResponseHandler newTxResponseHandler(Connection conn, BiConsumer recordConsumer,
+                                                                 BiConsumer summaryConsumer, UnmanagedTransaction tx, PullResponseHandler.Status status )
     {
         RunResponseHandler runHandler = mock( RunResponseHandler.class );
         TransactionPullResponseCompletionListener listener = new TransactionPullResponseCompletionListener( tx );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1Test.java
index 49aecbe505..c83744b5f3 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1Test.java
@@ -39,10 +39,10 @@
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.internal.BookmarkHolder;
 import org.neo4j.driver.internal.InternalBookmark;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
 import org.neo4j.driver.internal.async.connection.ChannelAttributes;
 import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher;
-import org.neo4j.driver.internal.cursor.AsyncStatementResultCursor;
+import org.neo4j.driver.internal.cursor.AsyncResultCursor;
 import org.neo4j.driver.internal.handlers.BeginTxResponseHandler;
 import org.neo4j.driver.internal.handlers.CommitTxResponseHandler;
 import org.neo4j.driver.internal.handlers.NoOpResponseHandler;
@@ -311,7 +311,7 @@ private void testRunWithoutWaitingForRunResponse( boolean autoCommitTx ) throws
         Connection connection = mock( Connection.class );
         when( connection.databaseName() ).thenReturn( defaultDatabase() );
 
-        CompletionStage cursorStage;
+        CompletionStage cursorStage;
         if ( autoCommitTx )
         {
             cursorStage = protocol
@@ -321,10 +321,10 @@ private void testRunWithoutWaitingForRunResponse( boolean autoCommitTx ) throws
         else
         {
             cursorStage = protocol
-                    .runInExplicitTransaction( connection, STATEMENT, mock( ExplicitTransaction.class ), false, UNLIMITED_FETCH_SIZE )
+                    .runInExplicitTransaction( connection, STATEMENT, mock( UnmanagedTransaction.class ), false, UNLIMITED_FETCH_SIZE )
                     .asyncResult();
         }
-        CompletableFuture cursorFuture = cursorStage.toCompletableFuture();
+        CompletableFuture cursorFuture = cursorStage.toCompletableFuture();
 
         assertTrue( cursorFuture.isDone() );
         assertNotNull( cursorFuture.get() );
@@ -336,7 +336,7 @@ private void testRunWithWaitingForResponse( boolean success, boolean session ) t
         Connection connection = mock( Connection.class );
         when( connection.databaseName() ).thenReturn( defaultDatabase() );
 
-        CompletionStage cursorStage;
+        CompletionStage cursorStage;
         if ( session )
         {
             cursorStage = protocol.runInAutoCommitTransaction( connection, STATEMENT, BookmarkHolder.NO_OP, TransactionConfig.empty(), true, UNLIMITED_FETCH_SIZE )
@@ -344,10 +344,10 @@ private void testRunWithWaitingForResponse( boolean success, boolean session ) t
         }
         else
         {
-            cursorStage = protocol.runInExplicitTransaction( connection, STATEMENT, mock( ExplicitTransaction.class ), true, UNLIMITED_FETCH_SIZE )
+            cursorStage = protocol.runInExplicitTransaction( connection, STATEMENT, mock( UnmanagedTransaction.class ), true, UNLIMITED_FETCH_SIZE )
                     .asyncResult();
         }
-        CompletableFuture cursorFuture = cursorStage.toCompletableFuture();
+        CompletableFuture cursorFuture = cursorStage.toCompletableFuture();
 
         assertFalse( cursorFuture.isDone() );
         ResponseHandler runResponseHandler = verifyRunInvoked( connection );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java
index 4b33f0c8ad..cf08cd36a9 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java
@@ -42,10 +42,10 @@
 import org.neo4j.driver.internal.BookmarkHolder;
 import org.neo4j.driver.internal.DefaultBookmarkHolder;
 import org.neo4j.driver.internal.InternalBookmark;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
 import org.neo4j.driver.internal.async.connection.ChannelAttributes;
 import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher;
-import org.neo4j.driver.internal.cursor.AsyncStatementResultCursor;
+import org.neo4j.driver.internal.cursor.AsyncResultCursor;
 import org.neo4j.driver.internal.handlers.BeginTxResponseHandler;
 import org.neo4j.driver.internal.handlers.CommitTxResponseHandler;
 import org.neo4j.driver.internal.handlers.NoOpResponseHandler;
@@ -359,8 +359,8 @@ protected void testRunInExplicitTransactionAndWaitForRunResponse( boolean succes
         // Given
         Connection connection = connectionMock( mode, protocol );
 
-        CompletableFuture cursorFuture =
-                protocol.runInExplicitTransaction( connection, STATEMENT, mock( ExplicitTransaction.class ), true, UNLIMITED_FETCH_SIZE ).asyncResult().toCompletableFuture();
+        CompletableFuture cursorFuture =
+                protocol.runInExplicitTransaction( connection, STATEMENT, mock( UnmanagedTransaction.class ), true, UNLIMITED_FETCH_SIZE ).asyncResult().toCompletableFuture();
 
         ResponseHandler runResponseHandler = verifyRunInvoked( connection, false, InternalBookmark.empty(), TransactionConfig.empty(), mode ).runHandler;
         assertFalse( cursorFuture.isDone() );
@@ -385,7 +385,7 @@ protected void testRunWithoutWaitingForRunResponse( boolean autoCommitTx, Transa
         Connection connection = connectionMock( mode, protocol );
         Bookmark initialBookmark = InternalBookmark.parse( "neo4j:bookmark:v1:tx987" );
 
-        CompletionStage cursorStage;
+        CompletionStage cursorStage;
         if ( autoCommitTx )
         {
             BookmarkHolder bookmarkHolder = new DefaultBookmarkHolder( initialBookmark );
@@ -393,9 +393,9 @@ protected void testRunWithoutWaitingForRunResponse( boolean autoCommitTx, Transa
         }
         else
         {
-            cursorStage = protocol.runInExplicitTransaction( connection, STATEMENT, mock( ExplicitTransaction.class ), false, UNLIMITED_FETCH_SIZE ).asyncResult();
+            cursorStage = protocol.runInExplicitTransaction( connection, STATEMENT, mock( UnmanagedTransaction.class ), false, UNLIMITED_FETCH_SIZE ).asyncResult();
         }
-        CompletableFuture cursorFuture = cursorStage.toCompletableFuture();
+        CompletableFuture cursorFuture = cursorStage.toCompletableFuture();
 
         assertTrue( cursorFuture.isDone() );
         assertNotNull( cursorFuture.get() );
@@ -415,7 +415,7 @@ protected void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( Bookmark b
         Connection connection = connectionMock( mode, protocol );
         BookmarkHolder bookmarkHolder = new DefaultBookmarkHolder( bookmark );
 
-        CompletableFuture cursorFuture =
+        CompletableFuture cursorFuture =
                 protocol.runInAutoCommitTransaction( connection, STATEMENT, bookmarkHolder, config, true, UNLIMITED_FETCH_SIZE )
                         .asyncResult()
                         .toCompletableFuture();
@@ -437,7 +437,7 @@ protected void testFailedRunInAutoCommitTxWithWaitingForResponse( Bookmark bookm
         Connection connection = connectionMock( mode, protocol );
         BookmarkHolder bookmarkHolder = new DefaultBookmarkHolder( bookmark );
 
-        CompletableFuture cursorFuture =
+        CompletableFuture cursorFuture =
                 protocol.runInAutoCommitTransaction( connection, STATEMENT, bookmarkHolder, config, true, UNLIMITED_FETCH_SIZE )
                         .asyncResult()
                         .toCompletableFuture();
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java
index 88ab8b734a..55160acba9 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java
@@ -30,9 +30,9 @@
 import org.neo4j.driver.internal.DatabaseName;
 import org.neo4j.driver.internal.DefaultBookmarkHolder;
 import org.neo4j.driver.internal.InternalBookmark;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
-import org.neo4j.driver.internal.cursor.AsyncStatementResultCursor;
-import org.neo4j.driver.internal.cursor.StatementResultCursorFactory;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
+import org.neo4j.driver.internal.cursor.AsyncResultCursor;
+import org.neo4j.driver.internal.cursor.ResultCursorFactory;
 import org.neo4j.driver.internal.handlers.BeginTxResponseHandler;
 import org.neo4j.driver.internal.handlers.NoOpResponseHandler;
 import org.neo4j.driver.internal.handlers.PullAllResponseHandler;
@@ -84,7 +84,7 @@ protected void testFailedRunInAutoCommitTxWithWaitingForResponse( Bookmark bookm
         Connection connection = connectionMock( mode, protocol );
         BookmarkHolder bookmarkHolder = new DefaultBookmarkHolder( bookmark );
 
-        CompletableFuture cursorFuture =
+        CompletableFuture cursorFuture =
                 protocol.runInAutoCommitTransaction( connection, STATEMENT, bookmarkHolder, config, true, UNLIMITED_FETCH_SIZE )
                         .asyncResult()
                         .toCompletableFuture();
@@ -108,7 +108,7 @@ protected void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( Bookmark b
         Connection connection = connectionMock( mode, protocol );
         BookmarkHolder bookmarkHolder = new DefaultBookmarkHolder( bookmark );
 
-        CompletableFuture cursorFuture =
+        CompletableFuture cursorFuture =
                 protocol.runInAutoCommitTransaction( connection, STATEMENT, bookmarkHolder, config, true, UNLIMITED_FETCH_SIZE )
                         .asyncResult()
                         .toCompletableFuture();
@@ -131,8 +131,8 @@ protected void testRunInExplicitTransactionAndWaitForRunResponse( boolean succes
         // Given
         Connection connection = connectionMock( mode, protocol );
 
-        CompletableFuture cursorFuture =
-                protocol.runInExplicitTransaction( connection, STATEMENT, mock( ExplicitTransaction.class ), true, UNLIMITED_FETCH_SIZE )
+        CompletableFuture cursorFuture =
+                protocol.runInExplicitTransaction( connection, STATEMENT, mock( UnmanagedTransaction.class ), true, UNLIMITED_FETCH_SIZE )
                         .asyncResult()
                         .toCompletableFuture();
 
@@ -161,7 +161,7 @@ protected void testRunWithoutWaitingForRunResponse( boolean autoCommitTx, Transa
         Connection connection = connectionMock( mode, protocol );
         Bookmark initialBookmark = InternalBookmark.parse( "neo4j:bookmark:v1:tx987" );
 
-        CompletionStage cursorStage;
+        CompletionStage cursorStage;
         if ( autoCommitTx )
         {
             BookmarkHolder bookmarkHolder = new DefaultBookmarkHolder( initialBookmark );
@@ -170,12 +170,12 @@ protected void testRunWithoutWaitingForRunResponse( boolean autoCommitTx, Transa
         }
         else
         {
-            cursorStage = protocol.runInExplicitTransaction( connection, STATEMENT, mock( ExplicitTransaction.class ), false, UNLIMITED_FETCH_SIZE )
+            cursorStage = protocol.runInExplicitTransaction( connection, STATEMENT, mock( UnmanagedTransaction.class ), false, UNLIMITED_FETCH_SIZE )
                     .asyncResult();
         }
 
         // When I complete it immediately without waiting for any responses to run message
-        CompletableFuture cursorFuture = cursorStage.toCompletableFuture();
+        CompletableFuture cursorFuture = cursorStage.toCompletableFuture();
         assertTrue( cursorFuture.isDone() );
         assertNotNull( cursorFuture.get() );
 
@@ -196,7 +196,7 @@ protected void testDatabaseNameSupport( boolean autoCommitTx )
         Connection connection = connectionMock( "foo", protocol );
         if ( autoCommitTx )
         {
-            StatementResultCursorFactory factory =
+            ResultCursorFactory factory =
                     protocol.runInAutoCommitTransaction( connection, STATEMENT, BookmarkHolder.NO_OP, TransactionConfig.empty(), false, UNLIMITED_FETCH_SIZE );
             await( factory.asyncResult() );
             verifySessionRunInvoked( connection, InternalBookmark.empty(), TransactionConfig.empty(), AccessMode.WRITE, database( "foo" ) );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxStatementResultTest.java b/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxResultTest.java
similarity index 79%
rename from driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxStatementResultTest.java
rename to driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxResultTest.java
index b0adeafcb3..76b141bf6c 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxStatementResultTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxResultTest.java
@@ -29,13 +29,13 @@
 import java.util.concurrent.CompletionException;
 
 import org.neo4j.driver.internal.InternalRecord;
-import org.neo4j.driver.internal.cursor.RxStatementResultCursorImpl;
+import org.neo4j.driver.internal.cursor.RxResultCursorImpl;
 import org.neo4j.driver.internal.handlers.RunResponseHandler;
 import org.neo4j.driver.internal.handlers.pulln.PullResponseHandler;
 import org.neo4j.driver.internal.util.Futures;
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.internal.reactive.util.ListBasedPullHandler;
-import org.neo4j.driver.internal.cursor.RxStatementResultCursor;
+import org.neo4j.driver.internal.cursor.RxResultCursor;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.summary.ResultSummary;
 
@@ -52,17 +52,17 @@
 import static org.neo4j.driver.internal.util.Futures.failedFuture;
 import static org.neo4j.driver.Values.values;
 
-class InternalRxStatementResultTest
+class InternalRxResultTest
 {
     @Test
     void shouldInitCursorFuture()
     {
         // Given
-        RxStatementResultCursor cursor = mock( RxStatementResultCursorImpl.class );
-        InternalRxStatementResult rxResult = newRxResult( cursor );
+        RxResultCursor cursor = mock( RxResultCursorImpl.class );
+        InternalRxResult rxResult = newRxResult( cursor );
 
         // When
-        CompletableFuture cursorFuture = rxResult.initCursorFuture().toCompletableFuture();
+        CompletableFuture cursorFuture = rxResult.initCursorFuture().toCompletableFuture();
 
         // Then
         assertTrue( cursorFuture.isDone() );
@@ -74,10 +74,10 @@ void shouldInitCursorFutureWithFailedCursor()
     {
         // Given
         RuntimeException error = new RuntimeException( "Failed to obtain cursor probably due to connection problem" );
-        InternalRxStatementResult rxResult = newRxResult( error );
+        InternalRxResult rxResult = newRxResult( error );
 
         // When
-        CompletableFuture cursorFuture = rxResult.initCursorFuture().toCompletableFuture();
+        CompletableFuture cursorFuture = rxResult.initCursorFuture().toCompletableFuture();
 
         // Then
         assertTrue( cursorFuture.isDone() );
@@ -89,8 +89,8 @@ void shouldInitCursorFutureWithFailedCursor()
     void shouldObtainKeys()
     {
         // Given
-        RxStatementResultCursor cursor = mock( RxStatementResultCursorImpl.class );
-        RxStatementResult rxResult = newRxResult( cursor );
+        RxResultCursor cursor = mock( RxResultCursorImpl.class );
+        RxResult rxResult = newRxResult( cursor );
 
         List keys = Arrays.asList( "one", "two", "three" );
         when( cursor.keys() ).thenReturn( keys );
@@ -106,7 +106,7 @@ void shouldErrorWhenFailedObtainKeys()
     {
         // Given
         RuntimeException error = new RuntimeException( "Failed to obtain cursor" );
-        InternalRxStatementResult rxResult = newRxResult( error );
+        InternalRxResult rxResult = newRxResult( error );
 
         // When & Then
         StepVerifier.create( Flux.from( rxResult.keys() ) )
@@ -118,8 +118,8 @@ void shouldErrorWhenFailedObtainKeys()
     void shouldCancelKeys()
     {
         // Given
-        RxStatementResultCursor cursor = mock( RxStatementResultCursorImpl.class );
-        RxStatementResult rxResult = newRxResult( cursor );
+        RxResultCursor cursor = mock( RxResultCursorImpl.class );
+        RxResult rxResult = newRxResult( cursor );
 
         List keys = Arrays.asList( "one", "two", "three" );
         when( cursor.keys() ).thenReturn( keys );
@@ -139,7 +139,7 @@ void shouldObtainRecordsAndSummary()
         Record record3 = new InternalRecord( asList( "key1", "key2", "key3" ), values( 3, 3, 3 ) );
 
         PullResponseHandler pullHandler = new ListBasedPullHandler( Arrays.asList( record1, record2, record3 ) );
-        RxStatementResult rxResult = newRxResult( pullHandler );
+        RxResult rxResult = newRxResult( pullHandler );
 
         // When
         StepVerifier.create( Flux.from( rxResult.records() ) )
@@ -159,7 +159,7 @@ void shouldCancelStreamingButObtainSummary()
         Record record3 = new InternalRecord( asList( "key1", "key2", "key3" ), values( 3, 3, 3 ) );
 
         PullResponseHandler pullHandler = new ListBasedPullHandler( Arrays.asList( record1, record2, record3 ) );
-        RxStatementResult rxResult = newRxResult( pullHandler );
+        RxResult rxResult = newRxResult( pullHandler );
 
         // When
         StepVerifier.create( Flux.from( rxResult.records() ).limitRate( 1 ).take( 1 ) )
@@ -173,7 +173,7 @@ void shouldErrorIfFailedToCreateCursor()
     {
         // Given
         Throwable error = new RuntimeException( "Hi" );
-        RxStatementResult rxResult = newRxResult( error );
+        RxResult rxResult = newRxResult( error );
 
         // When & Then
         StepVerifier.create( Flux.from( rxResult.records() ) ).expectErrorMatches( isEqual( error ) ).verify();
@@ -185,7 +185,7 @@ void shouldErrorIfFailedToStream()
     {
         // Given
         Throwable error = new RuntimeException( "Hi" );
-        RxStatementResult rxResult = newRxResult( new ListBasedPullHandler( error ) );
+        RxResult rxResult = newRxResult( new ListBasedPullHandler( error ) );
 
         // When & Then
         StepVerifier.create( Flux.from( rxResult.records() ) ).expectErrorMatches( isEqual( error ) ).verify();
@@ -194,25 +194,25 @@ void shouldErrorIfFailedToStream()
         } ).verifyComplete();
     }
 
-    private InternalRxStatementResult newRxResult( PullResponseHandler pullHandler )
+    private InternalRxResult newRxResult(PullResponseHandler pullHandler )
     {
         RunResponseHandler runHandler = mock( RunResponseHandler.class );
         when( runHandler.runFuture() ).thenReturn( Futures.completedWithNull() );
-        RxStatementResultCursor cursor = new RxStatementResultCursorImpl( runHandler, pullHandler );
+        RxResultCursor cursor = new RxResultCursorImpl( runHandler, pullHandler );
         return newRxResult( cursor );
     }
 
-    private InternalRxStatementResult newRxResult( RxStatementResultCursor cursor )
+    private InternalRxResult newRxResult(RxResultCursor cursor )
     {
-        return new InternalRxStatementResult( () -> {
+        return new InternalRxResult( () -> {
             // now we successfully run
             return completedFuture( cursor );
         } );
     }
 
-    private InternalRxStatementResult newRxResult( Throwable error )
+    private InternalRxResult newRxResult(Throwable error )
     {
-        return new InternalRxStatementResult( () -> {
+        return new InternalRxResult( () -> {
             // now we successfully run
             return failedFuture( new CompletionException( error ) );
         } );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxSessionTest.java b/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxSessionTest.java
index 649f1fda7b..6bf3563e6c 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxSessionTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxSessionTest.java
@@ -38,14 +38,14 @@
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.internal.InternalRecord;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
 import org.neo4j.driver.internal.async.NetworkSession;
-import org.neo4j.driver.internal.cursor.RxStatementResultCursor;
-import org.neo4j.driver.internal.cursor.RxStatementResultCursorImpl;
+import org.neo4j.driver.internal.cursor.RxResultCursor;
+import org.neo4j.driver.internal.cursor.RxResultCursorImpl;
 import org.neo4j.driver.internal.util.FixedRetryLogic;
 import org.neo4j.driver.internal.util.Futures;
 import org.neo4j.driver.internal.value.IntegerValue;
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.reactive.RxSession;
 import org.neo4j.driver.reactive.RxTransaction;
 
@@ -67,7 +67,7 @@
 
 class InternalRxSessionTest
 {
-    private static Stream> allSessionRunMethods()
+    private static Stream> allSessionRunMethods()
     {
         return Stream.of(
                 rxSession -> rxSession.run( "RETURN 1" ),
@@ -102,20 +102,20 @@ private static Stream>> allRunTxMethods()
 
     @ParameterizedTest
     @MethodSource( "allSessionRunMethods" )
-    void shouldDelegateRun( Function runReturnOne ) throws Throwable
+    void shouldDelegateRun( Function runReturnOne ) throws Throwable
     {
         // Given
         NetworkSession session = mock( NetworkSession.class );
-        RxStatementResultCursor cursor = mock( RxStatementResultCursorImpl.class );
+        RxResultCursor cursor = mock( RxResultCursorImpl.class );
 
         // Run succeeded with a cursor
         when( session.runRx( any( Statement.class ), any( TransactionConfig.class ) ) ).thenReturn( completedFuture( cursor ) );
         InternalRxSession rxSession = new InternalRxSession( session );
 
         // When
-        RxStatementResult result = runReturnOne.apply( rxSession );
+        RxResult result = runReturnOne.apply( rxSession );
         // Execute the run
-        CompletionStage cursorFuture = ((InternalRxStatementResult) result).cursorFutureSupplier().get();
+        CompletionStage cursorFuture = ((InternalRxResult) result).cursorFutureSupplier().get();
 
         // Then
         verify( session ).runRx( any( Statement.class ), any( TransactionConfig.class ) );
@@ -124,7 +124,7 @@ void shouldDelegateRun( Function runReturnOne ) thr
 
     @ParameterizedTest
     @MethodSource( "allSessionRunMethods" )
-    void shouldReleaseConnectionIfFailedToRun( Function runReturnOne ) throws Throwable
+    void shouldReleaseConnectionIfFailedToRun( Function runReturnOne ) throws Throwable
     {
         // Given
         Throwable error = new RuntimeException( "Hi there" );
@@ -137,9 +137,9 @@ void shouldReleaseConnectionIfFailedToRun( Function
         InternalRxSession rxSession = new InternalRxSession( session );
 
         // When
-        RxStatementResult result = runReturnOne.apply( rxSession );
+        RxResult result = runReturnOne.apply( rxSession );
         // Execute the run
-        CompletionStage cursorFuture = ((InternalRxStatementResult) result).cursorFutureSupplier().get();
+        CompletionStage cursorFuture = ((InternalRxResult) result).cursorFutureSupplier().get();
 
         // Then
         verify( session ).runRx( any( Statement.class ), any( TransactionConfig.class ) );
@@ -154,7 +154,7 @@ void shouldDelegateBeginTx( Function> beginTx
     {
         // Given
         NetworkSession session = mock( NetworkSession.class );
-        ExplicitTransaction tx = mock( ExplicitTransaction.class );
+        UnmanagedTransaction tx = mock( UnmanagedTransaction.class );
 
         when( session.beginTransactionAsync( any( TransactionConfig.class ) ) ).thenReturn( completedFuture( tx ) );
         InternalRxSession rxSession = new InternalRxSession( session );
@@ -198,7 +198,7 @@ void shouldDelegateRunTx( Function> runTx ) throws T
     {
         // Given
         NetworkSession session = mock( NetworkSession.class );
-        ExplicitTransaction tx = mock( ExplicitTransaction.class );
+        UnmanagedTransaction tx = mock( UnmanagedTransaction.class );
         when( tx.commitAsync() ).thenReturn( completedWithNull() );
         when( tx.rollbackAsync() ).thenReturn( completedWithNull() );
 
@@ -221,7 +221,7 @@ void shouldRetryOnError() throws Throwable
         // Given
         int retryCount = 2;
         NetworkSession session = mock( NetworkSession.class );
-        ExplicitTransaction tx = mock( ExplicitTransaction.class );
+        UnmanagedTransaction tx = mock( UnmanagedTransaction.class );
         when( tx.commitAsync() ).thenReturn( completedWithNull() );
         when( tx.rollbackAsync() ).thenReturn( completedWithNull() );
 
@@ -248,7 +248,7 @@ void shouldObtainResultIfRetrySucceed() throws Throwable
         // Given
         int retryCount = 2;
         NetworkSession session = mock( NetworkSession.class );
-        ExplicitTransaction tx = mock( ExplicitTransaction.class );
+        UnmanagedTransaction tx = mock( UnmanagedTransaction.class );
         when( tx.commitAsync() ).thenReturn( completedWithNull() );
         when( tx.rollbackAsync() ).thenReturn( completedWithNull() );
 
diff --git a/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxTransactionTest.java b/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxTransactionTest.java
index 64d43ad34d..7a967e9229 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxTransactionTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxTransactionTest.java
@@ -32,12 +32,12 @@
 import org.neo4j.driver.Statement;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.internal.InternalRecord;
-import org.neo4j.driver.internal.async.ExplicitTransaction;
-import org.neo4j.driver.internal.cursor.RxStatementResultCursor;
-import org.neo4j.driver.internal.cursor.RxStatementResultCursorImpl;
+import org.neo4j.driver.internal.async.UnmanagedTransaction;
+import org.neo4j.driver.internal.cursor.RxResultCursor;
+import org.neo4j.driver.internal.cursor.RxResultCursorImpl;
 import org.neo4j.driver.internal.util.Futures;
 import org.neo4j.driver.internal.value.IntegerValue;
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.reactive.RxTransaction;
 
 import static java.util.Collections.singletonList;
@@ -57,7 +57,7 @@ class InternalRxTransactionTest
     @Test
     void commitShouldDelegate()
     {
-        ExplicitTransaction tx = mock( ExplicitTransaction.class );
+        UnmanagedTransaction tx = mock( UnmanagedTransaction.class );
         when( tx.commitAsync() ).thenReturn( Futures.completedWithNull() );
 
         InternalRxTransaction rxTx = new InternalRxTransaction( tx );
@@ -70,7 +70,7 @@ void commitShouldDelegate()
     @Test
     void rollbackShouldDelegate()
     {
-        ExplicitTransaction tx = mock( ExplicitTransaction.class );
+        UnmanagedTransaction tx = mock( UnmanagedTransaction.class );
         when( tx.rollbackAsync() ).thenReturn( Futures.completedWithNull() );
 
         InternalRxTransaction rxTx = new InternalRxTransaction( tx );
@@ -80,7 +80,7 @@ void rollbackShouldDelegate()
         verify( tx ).rollbackAsync();
     }
 
-    private static Stream> allTxRunMethods()
+    private static Stream> allTxRunMethods()
     {
         return Stream.of(
                 rxSession -> rxSession.run( "RETURN 1" ),
@@ -94,20 +94,20 @@ private static Stream> allTxRunMethods
 
     @ParameterizedTest
     @MethodSource( "allTxRunMethods" )
-    void shouldDelegateRun( Function runReturnOne ) throws Throwable
+    void shouldDelegateRun( Function runReturnOne ) throws Throwable
     {
         // Given
-        ExplicitTransaction tx = mock( ExplicitTransaction.class );
-        RxStatementResultCursor cursor = mock( RxStatementResultCursorImpl.class );
+        UnmanagedTransaction tx = mock( UnmanagedTransaction.class );
+        RxResultCursor cursor = mock( RxResultCursorImpl.class );
 
         // Run succeeded with a cursor
         when( tx.runRx( any( Statement.class ) ) ).thenReturn( completedFuture( cursor ) );
         InternalRxTransaction rxTx = new InternalRxTransaction( tx );
 
         // When
-        RxStatementResult result = runReturnOne.apply( rxTx );
+        RxResult result = runReturnOne.apply( rxTx );
         // Execute the run
-        CompletionStage cursorFuture = ((InternalRxStatementResult) result).cursorFutureSupplier().get();
+        CompletionStage cursorFuture = ((InternalRxResult) result).cursorFutureSupplier().get();
 
         // Then
         verify( tx ).runRx( any( Statement.class ) );
@@ -116,20 +116,20 @@ void shouldDelegateRun( Function runReturnOne )
 
     @ParameterizedTest
     @MethodSource( "allTxRunMethods" )
-    void shouldMarkTxIfFailedToRun( Function runReturnOne ) throws Throwable
+    void shouldMarkTxIfFailedToRun( Function runReturnOne ) throws Throwable
     {
         // Given
         Throwable error = new RuntimeException( "Hi there" );
-        ExplicitTransaction tx = mock( ExplicitTransaction.class );
+        UnmanagedTransaction tx = mock( UnmanagedTransaction.class );
 
         // Run failed with error
         when( tx.runRx( any( Statement.class ) ) ).thenReturn( Futures.failedFuture( error ) );
         InternalRxTransaction rxTx = new InternalRxTransaction( tx );
 
         // When
-        RxStatementResult result = runReturnOne.apply( rxTx );
+        RxResult result = runReturnOne.apply( rxTx );
         // Execute the run
-        CompletionStage cursorFuture = ((InternalRxStatementResult) result).cursorFutureSupplier().get();
+        CompletionStage cursorFuture = ((InternalRxResult) result).cursorFutureSupplier().get();
 
         // Then
         verify( tx ).runRx( any( Statement.class ) );
diff --git a/driver/src/test/java/org/neo4j/driver/stress/AbstractStressTestBase.java b/driver/src/test/java/org/neo4j/driver/stress/AbstractStressTestBase.java
index 9ccc0ae7ba..491ba4d7ad 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/AbstractStressTestBase.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/AbstractStressTestBase.java
@@ -58,11 +58,11 @@
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
 import org.neo4j.driver.Statement;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.async.AsyncSession;
 import org.neo4j.driver.async.AsyncTransaction;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.Bookmark;
 import org.neo4j.driver.internal.InternalDriver;
 import org.neo4j.driver.internal.logging.DevNullLogger;
@@ -529,7 +529,7 @@ private static void readNodesBlocking( Driver driver, Bookmark bookmark, int exp
         {
             int nodesProcessed = session.readTransaction( tx ->
             {
-                StatementResult result = tx.run( "MATCH (n:Node) RETURN n" );
+                Result result = tx.run( "MATCH (n:Node) RETURN n" );
 
                 int nodesSeen = 0;
                 while ( result.hasNext() )
@@ -702,7 +702,7 @@ private static CompletableFuture createNodeInTxAsync( AsyncTransaction tx,
     {
         Statement statement = createNodeInTxStatement( nodeIndex );
         return tx.runAsync( statement )
-                .thenCompose( StatementResultCursor::consumeAsync )
+                .thenCompose( ResultCursor::consumeAsync )
                 .thenApply( ignore -> (Void) null )
                 .toCompletableFuture();
     }
diff --git a/driver/src/test/java/org/neo4j/driver/stress/AsyncFailingQuery.java b/driver/src/test/java/org/neo4j/driver/stress/AsyncFailingQuery.java
index 615d68b876..552e0118a3 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/AsyncFailingQuery.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/AsyncFailingQuery.java
@@ -23,7 +23,7 @@
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.async.AsyncSession;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.internal.util.Futures;
 
 import static org.hamcrest.Matchers.is;
@@ -44,7 +44,7 @@ public CompletionStage execute( C context )
         AsyncSession session = newSession( AccessMode.READ, context );
 
         return session.runAsync( "UNWIND [10, 5, 0] AS x RETURN 10 / x" )
-                .thenCompose( StatementResultCursor::listAsync )
+                .thenCompose( ResultCursor::listAsync )
                 .handle( ( records, error ) ->
                 {
                     session.closeAsync();
diff --git a/driver/src/test/java/org/neo4j/driver/stress/AsyncFailingQueryInTx.java b/driver/src/test/java/org/neo4j/driver/stress/AsyncFailingQueryInTx.java
index bc9d6fd00b..1cf38d3dcc 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/AsyncFailingQueryInTx.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/AsyncFailingQueryInTx.java
@@ -24,7 +24,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.async.AsyncSession;
 import org.neo4j.driver.async.AsyncTransaction;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.internal.util.Futures;
 
 import static org.hamcrest.Matchers.is;
@@ -46,7 +46,7 @@ public CompletionStage execute( C context )
 
         return session.beginTransactionAsync()
                 .thenCompose( tx -> tx.runAsync( "UNWIND [10, 5, 0] AS x RETURN 10 / x" )
-                        .thenCompose( StatementResultCursor::listAsync )
+                        .thenCompose( ResultCursor::listAsync )
                         .handle( ( records, error ) ->
                         {
                             assertNull( records );
diff --git a/driver/src/test/java/org/neo4j/driver/stress/AsyncReadQuery.java b/driver/src/test/java/org/neo4j/driver/stress/AsyncReadQuery.java
index 841b115528..4213d0abc8 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/AsyncReadQuery.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/AsyncReadQuery.java
@@ -24,7 +24,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.async.AsyncSession;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.summary.ResultSummary;
 import org.neo4j.driver.types.Node;
 
@@ -58,7 +58,7 @@ public CompletionStage execute( C context )
         return queryFinished.thenApply( summary -> null );
     }
 
-    private CompletionStage processAndGetSummary( Record record, StatementResultCursor cursor )
+    private CompletionStage processAndGetSummary( Record record, ResultCursor cursor )
     {
         if ( record != null )
         {
diff --git a/driver/src/test/java/org/neo4j/driver/stress/AsyncReadQueryInTx.java b/driver/src/test/java/org/neo4j/driver/stress/AsyncReadQueryInTx.java
index feca545ceb..a943b1341a 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/AsyncReadQueryInTx.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/AsyncReadQueryInTx.java
@@ -25,7 +25,7 @@
 import org.neo4j.driver.Record;
 import org.neo4j.driver.async.AsyncSession;
 import org.neo4j.driver.async.AsyncTransaction;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.summary.ResultSummary;
 import org.neo4j.driver.types.Node;
 
@@ -54,7 +54,7 @@ public CompletionStage execute( C ctx )
         return txCommitted;
     }
 
-    private CompletionStage processRecordAndGetSummary( Record record, StatementResultCursor cursor )
+    private CompletionStage processRecordAndGetSummary( Record record, ResultCursor cursor )
     {
         if ( record != null )
         {
diff --git a/driver/src/test/java/org/neo4j/driver/stress/AsyncWriteQuery.java b/driver/src/test/java/org/neo4j/driver/stress/AsyncWriteQuery.java
index 1c7df2a6a6..9538b4fd43 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/AsyncWriteQuery.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/AsyncWriteQuery.java
@@ -23,7 +23,7 @@
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.async.AsyncSession;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.internal.util.Futures;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -44,7 +44,7 @@ public CompletionStage execute( C context )
         AsyncSession session = newSession( AccessMode.WRITE, context );
 
         return session.runAsync( "CREATE ()" )
-                .thenCompose( StatementResultCursor::consumeAsync )
+                .thenCompose( ResultCursor::consumeAsync )
                 .handle( ( summary, error ) ->
                 {
                     session.closeAsync();
diff --git a/driver/src/test/java/org/neo4j/driver/stress/AsyncWrongQuery.java b/driver/src/test/java/org/neo4j/driver/stress/AsyncWrongQuery.java
index f87c565d97..7669370f99 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/AsyncWrongQuery.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/AsyncWrongQuery.java
@@ -23,7 +23,7 @@
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.async.AsyncSession;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.exceptions.Neo4jException;
 import org.neo4j.driver.internal.util.Futures;
@@ -47,7 +47,7 @@ public CompletionStage execute( C context )
         AsyncSession session = newSession( AccessMode.READ, context );
 
         return session.runAsync( "RETURN Wrong" )
-                .thenCompose( StatementResultCursor::nextAsync )
+                .thenCompose( ResultCursor::nextAsync )
                 .handle( ( record, error ) ->
                 {
                     session.closeAsync();
diff --git a/driver/src/test/java/org/neo4j/driver/stress/AsyncWrongQueryInTx.java b/driver/src/test/java/org/neo4j/driver/stress/AsyncWrongQueryInTx.java
index a7e9a30620..ed505398df 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/AsyncWrongQueryInTx.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/AsyncWrongQueryInTx.java
@@ -24,7 +24,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.async.AsyncSession;
 import org.neo4j.driver.async.AsyncTransaction;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.exceptions.Neo4jException;
 import org.neo4j.driver.internal.util.Futures;
@@ -49,7 +49,7 @@ public CompletionStage execute( C context )
 
         return session.beginTransactionAsync()
                 .thenCompose( tx -> tx.runAsync( "RETURN Wrong" )
-                        .thenCompose( StatementResultCursor::nextAsync )
+                        .thenCompose( ResultCursor::nextAsync )
                         .handle( ( record, error ) ->
                         {
                             assertNull( record );
diff --git a/driver/src/test/java/org/neo4j/driver/stress/BlockingFailingQuery.java b/driver/src/test/java/org/neo4j/driver/stress/BlockingFailingQuery.java
index 7864464de4..e3d4e952b7 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/BlockingFailingQuery.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/BlockingFailingQuery.java
@@ -21,7 +21,7 @@
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.junit.MatcherAssert.assertThat;
@@ -40,7 +40,7 @@ public void execute( C context )
     {
         try ( Session session = newSession( AccessMode.READ, context ) )
         {
-            StatementResult result = session.run( "UNWIND [10, 5, 0] AS x RETURN 10 / x" );
+            Result result = session.run( "UNWIND [10, 5, 0] AS x RETURN 10 / x" );
             Exception e = assertThrows( Exception.class, result::consume );
             assertThat( e, is( arithmeticError() ) );
         }
diff --git a/driver/src/test/java/org/neo4j/driver/stress/BlockingFailingQueryInTx.java b/driver/src/test/java/org/neo4j/driver/stress/BlockingFailingQueryInTx.java
index 2b8b7e55ec..7550f54224 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/BlockingFailingQueryInTx.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/BlockingFailingQueryInTx.java
@@ -21,7 +21,7 @@
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 
 import static org.hamcrest.Matchers.is;
@@ -43,7 +43,7 @@ public void execute( C context )
         {
             try ( Transaction tx = beginTransaction( session, context ) )
             {
-                StatementResult result = tx.run( "UNWIND [10, 5, 0] AS x RETURN 10 / x" );
+                Result result = tx.run( "UNWIND [10, 5, 0] AS x RETURN 10 / x" );
 
                 Exception e = assertThrows( Exception.class, result::consume );
                 assertThat( e, is( arithmeticError() ) );
diff --git a/driver/src/test/java/org/neo4j/driver/stress/BlockingReadQuery.java b/driver/src/test/java/org/neo4j/driver/stress/BlockingReadQuery.java
index 98ee8286e8..521d8678b0 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/BlockingReadQuery.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/BlockingReadQuery.java
@@ -24,7 +24,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.types.Node;
 
 import static org.junit.jupiter.api.Assertions.assertNotNull;
@@ -42,7 +42,7 @@ public void execute( C context )
     {
         try ( Session session = newSession( AccessMode.READ, context ) )
         {
-            StatementResult result = session.run( "MATCH (n) RETURN n LIMIT 1" );
+            Result result = session.run( "MATCH (n) RETURN n LIMIT 1" );
             List records = result.list();
             if ( !records.isEmpty() )
             {
diff --git a/driver/src/test/java/org/neo4j/driver/stress/BlockingReadQueryInTx.java b/driver/src/test/java/org/neo4j/driver/stress/BlockingReadQueryInTx.java
index c12924bd79..6633d411ef 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/BlockingReadQueryInTx.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/BlockingReadQueryInTx.java
@@ -24,7 +24,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.types.Node;
 
@@ -44,7 +44,7 @@ public void execute( C context )
         try ( Session session = newSession( AccessMode.READ, context );
               Transaction tx = beginTransaction( session, context ) )
         {
-            StatementResult result = tx.run( "MATCH (n) RETURN n LIMIT 1" );
+            Result result = tx.run( "MATCH (n) RETURN n LIMIT 1" );
             List records = result.list();
             if ( !records.isEmpty() )
             {
diff --git a/driver/src/test/java/org/neo4j/driver/stress/BlockingWriteQuery.java b/driver/src/test/java/org/neo4j/driver/stress/BlockingWriteQuery.java
index 6293da5a91..415889dd46 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/BlockingWriteQuery.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/BlockingWriteQuery.java
@@ -21,7 +21,7 @@
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
@@ -38,7 +38,7 @@ public BlockingWriteQuery( AbstractStressTestBase stressTest, Driver driver,
     @Override
     public void execute( C context )
     {
-        StatementResult result = null;
+        Result result = null;
         Throwable queryError = null;
 
         try ( Session session = newSession( AccessMode.WRITE, context ) )
diff --git a/driver/src/test/java/org/neo4j/driver/stress/BlockingWriteQueryInTx.java b/driver/src/test/java/org/neo4j/driver/stress/BlockingWriteQueryInTx.java
index 16a2847b7a..2f506bf83e 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/BlockingWriteQueryInTx.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/BlockingWriteQueryInTx.java
@@ -21,7 +21,7 @@
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -39,7 +39,7 @@ public BlockingWriteQueryInTx( AbstractStressTestBase stressTest, Driver driv
     @Override
     public void execute( C context )
     {
-        StatementResult result = null;
+        Result result = null;
         Throwable txError = null;
 
         try ( Session session = newSession( AccessMode.WRITE, context ) )
diff --git a/driver/src/test/java/org/neo4j/driver/stress/BlockingWriteQueryUsingReadSession.java b/driver/src/test/java/org/neo4j/driver/stress/BlockingWriteQueryUsingReadSession.java
index 69381865be..6635c9f446 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/BlockingWriteQueryUsingReadSession.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/BlockingWriteQueryUsingReadSession.java
@@ -23,7 +23,7 @@
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.exceptions.ClientException;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -40,12 +40,12 @@ public BlockingWriteQueryUsingReadSession( Driver driver, boolean useBookmark )
     @Override
     public void execute( C context )
     {
-        AtomicReference resultRef = new AtomicReference<>();
+        AtomicReference resultRef = new AtomicReference<>();
         assertThrows( ClientException.class, () ->
         {
             try ( Session session = newSession( AccessMode.READ, context ) )
             {
-                StatementResult result = session.run( "CREATE ()" );
+                Result result = session.run( "CREATE ()" );
                 resultRef.set( result );
             }
         } );
diff --git a/driver/src/test/java/org/neo4j/driver/stress/BlockingWriteQueryUsingReadSessionInTx.java b/driver/src/test/java/org/neo4j/driver/stress/BlockingWriteQueryUsingReadSessionInTx.java
index fcd2a28591..d80e515578 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/BlockingWriteQueryUsingReadSessionInTx.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/BlockingWriteQueryUsingReadSessionInTx.java
@@ -23,7 +23,7 @@
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.exceptions.ClientException;
 
@@ -41,13 +41,13 @@ public BlockingWriteQueryUsingReadSessionInTx( Driver driver, boolean useBookmar
     @Override
     public void execute( C context )
     {
-        AtomicReference resultRef = new AtomicReference<>();
+        AtomicReference resultRef = new AtomicReference<>();
         assertThrows( ClientException.class, () ->
         {
             try ( Session session = newSession( AccessMode.READ, context );
                   Transaction tx = beginTransaction( session, context ) )
             {
-                StatementResult result = tx.run( "CREATE ()" );
+                Result result = tx.run( "CREATE ()" );
                 resultRef.set( result );
                 tx.commit();
             }
diff --git a/driver/src/test/java/org/neo4j/driver/stress/CausalClusteringIT.java b/driver/src/test/java/org/neo4j/driver/stress/CausalClusteringIT.java
index 068764516b..d6a9068a5b 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/CausalClusteringIT.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/CausalClusteringIT.java
@@ -48,12 +48,12 @@
 import org.neo4j.driver.GraphDatabase;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.StatementRunner;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.Values;
 import org.neo4j.driver.async.AsyncSession;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.exceptions.Neo4jException;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
@@ -408,7 +408,7 @@ void shouldServeReadsWhenMajorityOfCoresAreDead()
             {
                 int writeResult = session.writeTransaction( tx ->
                 {
-                    StatementResult result = tx.run( "CREATE (:Person {name: 'Star Lord'}) RETURN 42" );
+                    Result result = tx.run( "CREATE (:Person {name: 'Star Lord'}) RETURN 42" );
                     return result.single().get( 0 ).asInt();
                 } );
 
@@ -439,7 +439,7 @@ void shouldServeReadsWhenMajorityOfCoresAreDead()
             {
                 int count = session.readTransaction( tx ->
                 {
-                    StatementResult result = tx.run( "MATCH (:Person {name: 'Star Lord'}) RETURN COUNT(*)" );
+                    Result result = tx.run( "MATCH (:Person {name: 'Star Lord'}) RETURN COUNT(*)" );
                     return result.single().get( 0 ).asInt();
                 } );
 
@@ -514,7 +514,7 @@ void shouldNotReuseReadConnectionForWriteTransaction()
 
             CompletionStage countStage =
                     session.readTransactionAsync( tx -> tx.runAsync( "MATCH (n:Node1) RETURN count(n)" )
-                            .thenCompose( StatementResultCursor::singleAsync ) )
+                            .thenCompose( ResultCursor::singleAsync ) )
                             .thenApply( record -> record.get( 0 ).asInt() );
 
             assertEquals( 1, await( countStage ).intValue() );
@@ -712,14 +712,14 @@ private static void assertUnableToRunMoreStatementsInTx( Transaction tx, Service
         assertEquals( cause, e.getCause() );
     }
 
-    private CompletionStage> combineCursors( StatementResultCursor cursor1,
-            StatementResultCursor cursor2 )
+    private CompletionStage> combineCursors( ResultCursor cursor1,
+            ResultCursor cursor2 )
     {
         return buildRecordAndSummary( cursor1 ).thenCombine( buildRecordAndSummary( cursor2 ),
                 ( rs1, rs2 ) -> Arrays.asList( rs1, rs2 ) );
     }
 
-    private CompletionStage buildRecordAndSummary( StatementResultCursor cursor )
+    private CompletionStage buildRecordAndSummary( ResultCursor cursor )
     {
         return cursor.singleAsync().thenCompose( record ->
                 cursor.consumeAsync().thenApply( summary -> new RecordAndSummary( record, summary ) ) );
@@ -800,7 +800,7 @@ private int countNodesUsingDirectDriver( ClusterMember member, final String name
         {
             return session.readTransaction( tx ->
             {
-                StatementResult result = tx.run( "MATCH (:Person {name: $name}) RETURN count(*)",
+                Result result = tx.run( "MATCH (:Person {name: $name}) RETURN count(*)",
                         parameters( "name", name ) );
                 return result.single().get( 0 ).asInt();
             } );
@@ -956,7 +956,7 @@ private static List readNodeIds( final Session session, final String label
     {
         return session.readTransaction( tx ->
         {
-            StatementResult result = tx.run( "MATCH (n:" + label + " {" + property + ": $value}) RETURN n LIMIT 10",
+            Result result = tx.run( "MATCH (n:" + label + " {" + property + ": $value}) RETURN n LIMIT 10",
                     parameters( "value", value ) );
 
             return result.list( record -> record.get( 0 ).asNode().id() );
@@ -1006,14 +1006,14 @@ private static Bookmark createNodeAndGetBookmark( Session session, String label,
         }
     }
 
-    private static StatementResult runCreateNode( StatementRunner statementRunner, String label, String property, String value )
+    private static Result runCreateNode(StatementRunner statementRunner, String label, String property, String value )
     {
         return statementRunner.run( "CREATE (n:" + label + ") SET n." + property + " = $value", parameters( "value", value ) );
     }
 
     private static int runCountNodes( StatementRunner statementRunner, String label, String property, String value )
     {
-        StatementResult result = statementRunner.run( "MATCH (n:" + label + " {" + property + ": $value}) RETURN count(n)", parameters( "value", value ) );
+        Result result = statementRunner.run( "MATCH (n:" + label + " {" + property + ": $value}) RETURN count(n)", parameters( "value", value ) );
         return result.single().get( 0 ).asInt();
     }
 
diff --git a/driver/src/test/java/org/neo4j/driver/stress/RxReadQuery.java b/driver/src/test/java/org/neo4j/driver/stress/RxReadQuery.java
index 3878ee7abd..7f7c315567 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/RxReadQuery.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/RxReadQuery.java
@@ -27,7 +27,7 @@
 
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Driver;
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.reactive.RxSession;
 import org.neo4j.driver.summary.ResultSummary;
 import org.neo4j.driver.types.Node;
@@ -56,7 +56,7 @@ public CompletionStage execute( C context )
 
     private Publisher processAndGetSummary( RxSession session )
     {
-        RxStatementResult result = session.run( "MATCH (n) RETURN n LIMIT 1" );
+        RxResult result = session.run( "MATCH (n) RETURN n LIMIT 1" );
         Mono records = Flux.from( result.records() ).singleOrEmpty().map( record -> record.get( 0 ).asNode() );
         Mono summaryMono = Mono.from( result.consume() ).single();
         return records.then( summaryMono );
diff --git a/driver/src/test/java/org/neo4j/driver/stress/RxReadQueryInTx.java b/driver/src/test/java/org/neo4j/driver/stress/RxReadQueryInTx.java
index 83ba935341..6325516eb7 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/RxReadQueryInTx.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/RxReadQueryInTx.java
@@ -27,7 +27,7 @@
 
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Driver;
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.reactive.RxSession;
 import org.neo4j.driver.reactive.RxTransaction;
 import org.neo4j.driver.summary.ResultSummary;
@@ -59,7 +59,7 @@ public CompletionStage execute( C context )
 
     private Publisher processAndGetSummary( RxTransaction tx )
     {
-        RxStatementResult result = tx.run( "MATCH (n) RETURN n LIMIT 1" );
+        RxResult result = tx.run( "MATCH (n) RETURN n LIMIT 1" );
         Mono records = Flux.from( result.records() ).singleOrEmpty().map( record -> record.get( 0 ).asNode() );
         Mono summaryMono = Mono.from( result.consume() ).single();
         return records.then( summaryMono );
diff --git a/driver/src/test/java/org/neo4j/driver/stress/RxReadQueryWithRetries.java b/driver/src/test/java/org/neo4j/driver/stress/RxReadQueryWithRetries.java
index 9339571bab..dc87ca33d9 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/RxReadQueryWithRetries.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/RxReadQueryWithRetries.java
@@ -27,7 +27,7 @@
 
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Driver;
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.reactive.RxSession;
 import org.neo4j.driver.summary.ResultSummary;
 import org.neo4j.driver.types.Node;
@@ -57,7 +57,7 @@ public CompletionStage execute( C context )
     private Publisher processAndGetSummary( RxSession session )
     {
         return session.readTransaction( tx -> {
-            RxStatementResult result = tx.run( "MATCH (n) RETURN n LIMIT 1" );
+            RxResult result = tx.run( "MATCH (n) RETURN n LIMIT 1" );
             Mono records = Flux.from( result.records() ).singleOrEmpty().map( record -> record.get( 0 ).asNode() );
             Mono summaryMono = Mono.from( result.consume() ).single();
             return records.then( summaryMono );
diff --git a/driver/src/test/java/org/neo4j/driver/stress/SessionPoolingStressIT.java b/driver/src/test/java/org/neo4j/driver/stress/SessionPoolingStressIT.java
index 7deeb20eec..e71523df91 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/SessionPoolingStressIT.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/SessionPoolingStressIT.java
@@ -35,7 +35,7 @@
 import org.neo4j.driver.Config;
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.util.DatabaseExtension;
 import org.neo4j.driver.util.ParallelizableIT;
 
@@ -158,7 +158,7 @@ private void runQuery( String query ) throws InterruptedException
         {
             try ( Session session = driver.session() )
             {
-                StatementResult run = session.run( query );
+                Result run = session.run( query );
                 Thread.sleep( random.nextInt( 100 ) );
                 run.consume();
                 Thread.sleep( random.nextInt( 100 ) );
diff --git a/driver/src/test/java/org/neo4j/driver/util/SessionExtension.java b/driver/src/test/java/org/neo4j/driver/util/SessionExtension.java
index 2e4cefcb27..0978234558 100644
--- a/driver/src/test/java/org/neo4j/driver/util/SessionExtension.java
+++ b/driver/src/test/java/org/neo4j/driver/util/SessionExtension.java
@@ -27,7 +27,7 @@
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
 import org.neo4j.driver.Statement;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.TransactionWork;
@@ -120,49 +120,49 @@ public void reset()
     }
 
     @Override
-    public StatementResult run( String statementText, Map statementParameters )
+    public Result run(String statementText, Map statementParameters )
     {
         return realSession.run( statementText, statementParameters );
     }
 
     @Override
-    public StatementResult run( String statementText, Value parameters )
+    public Result run(String statementText, Value parameters )
     {
         return realSession.run( statementText, parameters );
     }
 
     @Override
-    public StatementResult run( String statementText, Record parameters )
+    public Result run(String statementText, Record parameters )
     {
         return realSession.run( statementText, parameters );
     }
 
     @Override
-    public StatementResult run( String statementTemplate )
+    public Result run(String statementTemplate )
     {
         return realSession.run( statementTemplate );
     }
 
     @Override
-    public StatementResult run( Statement statement )
+    public Result run(Statement statement )
     {
         return realSession.run( statement.text(), statement.parameters() );
     }
 
     @Override
-    public StatementResult run( String statement, TransactionConfig config )
+    public Result run(String statement, TransactionConfig config )
     {
         return realSession.run( statement, config );
     }
 
     @Override
-    public StatementResult run( String statement, Map parameters, TransactionConfig config )
+    public Result run(String statement, Map parameters, TransactionConfig config )
     {
         return realSession.run( statement, parameters, config );
     }
 
     @Override
-    public StatementResult run( Statement statement, TransactionConfig config )
+    public Result run(Statement statement, TransactionConfig config )
     {
         return realSession.run( statement, config );
     }
diff --git a/driver/src/test/java/org/neo4j/driver/util/TestUtil.java b/driver/src/test/java/org/neo4j/driver/util/TestUtil.java
index d08c12e207..513b1fd5b1 100644
--- a/driver/src/test/java/org/neo4j/driver/util/TestUtil.java
+++ b/driver/src/test/java/org/neo4j/driver/util/TestUtil.java
@@ -48,7 +48,7 @@
 import org.neo4j.driver.Bookmark;
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
 import org.neo4j.driver.internal.BoltServerAddress;
 import org.neo4j.driver.internal.DefaultBookmarkHolder;
@@ -640,7 +640,7 @@ private static int deleteBatchOfNodes( Session session )
     {
         return session.writeTransaction( tx ->
         {
-            StatementResult result = tx.run( "MATCH (n) WITH n LIMIT 10000 DETACH DELETE n RETURN count(n)" );
+            Result result = tx.run( "MATCH (n) WITH n LIMIT 10000 DETACH DELETE n RETURN count(n)" );
             return result.single().get( 0 ).asInt();
         } );
     }
diff --git a/driver/src/test/java/org/neo4j/driver/util/cc/ClusterMemberRoleDiscoveryFactory.java b/driver/src/test/java/org/neo4j/driver/util/cc/ClusterMemberRoleDiscoveryFactory.java
index 7083aacf37..8fe672ef7e 100644
--- a/driver/src/test/java/org/neo4j/driver/util/cc/ClusterMemberRoleDiscoveryFactory.java
+++ b/driver/src/test/java/org/neo4j/driver/util/cc/ClusterMemberRoleDiscoveryFactory.java
@@ -28,7 +28,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Values;
 import org.neo4j.driver.internal.BoltServerAddress;
 import org.neo4j.driver.internal.util.ServerVersion;
@@ -76,7 +76,7 @@ public Map findClusterOverview( Driver driv
         {
             try ( Session session = driver.session( builder().withDefaultAccessMode( AccessMode.WRITE ).build() ) )
             {
-                StatementResult result = session.run( "CALL dbms.cluster.overview()" );
+                Result result = session.run( "CALL dbms.cluster.overview()" );
                 Map overview = new HashMap<>();
                 for ( Record record : result.list() )
                 {
@@ -110,7 +110,7 @@ public Map findClusterOverview( Driver driv
         {
             try ( Session session = driver.session( builder().withDefaultAccessMode( AccessMode.READ ).build() ) )
             {
-                StatementResult result = session.run( "CALL dbms.cluster.overview()" );
+                Result result = session.run( "CALL dbms.cluster.overview()" );
                 Map overview = new HashMap<>();
                 for ( Record record : result.list() )
                 {
diff --git a/examples/src/main/java/org/neo4j/docs/driver/AsyncExplicitTransactionExample.java b/examples/src/main/java/org/neo4j/docs/driver/AsyncExplicitTransactionExample.java
index 2a90ac42b3..2655eb2c0c 100644
--- a/examples/src/main/java/org/neo4j/docs/driver/AsyncExplicitTransactionExample.java
+++ b/examples/src/main/java/org/neo4j/docs/driver/AsyncExplicitTransactionExample.java
@@ -25,7 +25,7 @@
 
 import org.neo4j.driver.async.AsyncSession;
 import org.neo4j.driver.async.AsyncTransaction;
-import org.neo4j.driver.async.StatementResultCursor;
+import org.neo4j.driver.async.ResultCursor;
 
 public class AsyncExplicitTransactionExample extends BaseApplication
 {
@@ -44,7 +44,7 @@ public CompletionStage printSingleProduct()
 
         Function> printSingleTitle = tx ->
                 tx.runAsync( query, parameters )
-                        .thenCompose( StatementResultCursor::singleAsync )
+                        .thenCompose( ResultCursor::singleAsync )
                         .thenApply( record -> record.get( 0 ).asString() )
                         .thenApply( title ->
                         {
diff --git a/examples/src/main/java/org/neo4j/docs/driver/BasicAuthExample.java b/examples/src/main/java/org/neo4j/docs/driver/BasicAuthExample.java
index c0d2fba5d5..c3598c5a21 100644
--- a/examples/src/main/java/org/neo4j/docs/driver/BasicAuthExample.java
+++ b/examples/src/main/java/org/neo4j/docs/driver/BasicAuthExample.java
@@ -23,7 +23,7 @@
 import org.neo4j.driver.AuthTokens;
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.GraphDatabase;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 // end::basic-auth-import[]
 
 public class BasicAuthExample implements AutoCloseable
@@ -45,7 +45,7 @@ public void close() throws Exception
 
     public boolean canConnect()
     {
-        StatementResult result = driver.session().run( "RETURN 1" );
+        Result result = driver.session().run( "RETURN 1" );
         return result.single().get( 0 ).asInt() == 1;
     }
 }
diff --git a/examples/src/main/java/org/neo4j/docs/driver/ConfigConnectionPoolExample.java b/examples/src/main/java/org/neo4j/docs/driver/ConfigConnectionPoolExample.java
index 0318cd48a9..91ed52adf9 100644
--- a/examples/src/main/java/org/neo4j/docs/driver/ConfigConnectionPoolExample.java
+++ b/examples/src/main/java/org/neo4j/docs/driver/ConfigConnectionPoolExample.java
@@ -24,7 +24,7 @@
 import org.neo4j.driver.Config;
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.GraphDatabase;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 
 public class ConfigConnectionPoolExample  implements AutoCloseable
 {
@@ -51,7 +51,7 @@ public void close() throws Exception
 
     public boolean canConnect()
     {
-        StatementResult result = driver.session().run( "RETURN 1" );
+        Result result = driver.session().run( "RETURN 1" );
         return result.single().get( 0 ).asInt() == 1;
     }
 }
diff --git a/examples/src/main/java/org/neo4j/docs/driver/ConfigCustomResolverExample.java b/examples/src/main/java/org/neo4j/docs/driver/ConfigCustomResolverExample.java
index f86209c9db..1cc68dca9b 100644
--- a/examples/src/main/java/org/neo4j/docs/driver/ConfigCustomResolverExample.java
+++ b/examples/src/main/java/org/neo4j/docs/driver/ConfigCustomResolverExample.java
@@ -27,7 +27,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.GraphDatabase;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.net.ServerAddress;
 
 import static org.neo4j.driver.Values.parameters;
@@ -81,7 +81,7 @@ public void close() throws Exception
 
     public boolean canConnect()
     {
-        StatementResult result = driver.session( builder().withDefaultAccessMode( AccessMode.READ ).build() ).run( "RETURN 1" );
+        Result result = driver.session( builder().withDefaultAccessMode( AccessMode.READ ).build() ).run( "RETURN 1" );
         return result.single().get( 0 ).asInt() == 1;
     }
 }
diff --git a/examples/src/main/java/org/neo4j/docs/driver/CypherErrorExample.java b/examples/src/main/java/org/neo4j/docs/driver/CypherErrorExample.java
index 70bc679a17..f72d607460 100644
--- a/examples/src/main/java/org/neo4j/docs/driver/CypherErrorExample.java
+++ b/examples/src/main/java/org/neo4j/docs/driver/CypherErrorExample.java
@@ -21,7 +21,7 @@
 // tag::cypher-error-import[]
 
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.TransactionWork;
 import org.neo4j.driver.exceptions.ClientException;
@@ -56,7 +56,7 @@ private static int selectEmployee( Transaction tx, String name )
     {
         try
         {
-            StatementResult result = tx.run( "SELECT * FROM Employees WHERE name = $name", parameters( "name", name ) );
+            Result result = tx.run( "SELECT * FROM Employees WHERE name = $name", parameters( "name", name ) );
             return result.single().get( "employee_number" ).asInt();
         }
         catch ( ClientException ex )
diff --git a/examples/src/main/java/org/neo4j/docs/driver/HelloWorldExample.java b/examples/src/main/java/org/neo4j/docs/driver/HelloWorldExample.java
index 93382ca7d4..d8dd1331d7 100644
--- a/examples/src/main/java/org/neo4j/docs/driver/HelloWorldExample.java
+++ b/examples/src/main/java/org/neo4j/docs/driver/HelloWorldExample.java
@@ -24,7 +24,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.GraphDatabase;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.TransactionWork;
 
@@ -56,7 +56,7 @@ public void printGreeting( final String message )
                 @Override
                 public String execute( Transaction tx )
                 {
-                    StatementResult result = tx.run( "CREATE (a:Greeting) " +
+                    Result result = tx.run( "CREATE (a:Greeting) " +
                                                      "SET a.message = $message " +
                                                      "RETURN a.message + ', from node ' + id(a)",
                             parameters( "message", message ) );
diff --git a/examples/src/main/java/org/neo4j/docs/driver/PassBookmarkExample.java b/examples/src/main/java/org/neo4j/docs/driver/PassBookmarkExample.java
index 10d244cabf..adc575c72c 100644
--- a/examples/src/main/java/org/neo4j/docs/driver/PassBookmarkExample.java
+++ b/examples/src/main/java/org/neo4j/docs/driver/PassBookmarkExample.java
@@ -25,7 +25,7 @@
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.Bookmark;
 
@@ -43,20 +43,20 @@ public PassBookmarkExample( String uri, String user, String password )
 
     // tag::pass-bookmarks[]
     // Create a company node
-    private StatementResult addCompany( final Transaction tx, final String name )
+    private Result addCompany(final Transaction tx, final String name )
     {
         return tx.run( "CREATE (:Company {name: $name})", parameters( "name", name ) );
     }
 
     // Create a person node
-    private StatementResult addPerson( final Transaction tx, final String name )
+    private Result addPerson(final Transaction tx, final String name )
     {
         return tx.run( "CREATE (:Person {name: $name})", parameters( "name", name ) );
     }
 
     // Create an employment relationship to a pre-existing company node.
     // This relies on the person first having been created.
-    private StatementResult employ( final Transaction tx, final String person, final String company )
+    private Result employ(final Transaction tx, final String person, final String company )
     {
         return tx.run( "MATCH (person:Person {name: $person_name}) " +
                         "MATCH (company:Company {name: $company_name}) " +
@@ -65,7 +65,7 @@ private StatementResult employ( final Transaction tx, final String person, final
     }
 
     // Create a friendship between two people.
-    private StatementResult makeFriends( final Transaction tx, final String person1, final String person2 )
+    private Result makeFriends(final Transaction tx, final String person1, final String person2 )
     {
         return tx.run( "MATCH (a:Person {name: $person_1}) " +
                         "MATCH (b:Person {name: $person_2}) " +
@@ -74,9 +74,9 @@ private StatementResult makeFriends( final Transaction tx, final String person1,
     }
 
     // Match and display all friendships.
-    private StatementResult printFriends( final Transaction tx )
+    private Result printFriends(final Transaction tx )
     {
-        StatementResult result = tx.run( "MATCH (a)-[:KNOWS]->(b) RETURN a.name, b.name" );
+        Result result = tx.run( "MATCH (a)-[:KNOWS]->(b) RETURN a.name, b.name" );
         while ( result.hasNext() )
         {
             Record record = result.next();
diff --git a/examples/src/main/java/org/neo4j/docs/driver/ReadWriteTransactionExample.java b/examples/src/main/java/org/neo4j/docs/driver/ReadWriteTransactionExample.java
index d221cea0fd..60b8ca5ef9 100644
--- a/examples/src/main/java/org/neo4j/docs/driver/ReadWriteTransactionExample.java
+++ b/examples/src/main/java/org/neo4j/docs/driver/ReadWriteTransactionExample.java
@@ -21,7 +21,7 @@
 // tag::read-write-transaction-import[]
 
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.TransactionWork;
 
@@ -67,7 +67,7 @@ private static Void createPersonNode( Transaction tx, String name )
 
     private static long matchPersonNode( Transaction tx, String name )
     {
-        StatementResult result = tx.run( "MATCH (a:Person {name: $name}) RETURN id(a)", parameters( "name", name ) );
+        Result result = tx.run( "MATCH (a:Person {name: $name}) RETURN id(a)", parameters( "name", name ) );
         return result.single().get( 0 ).asLong();
     }
     // end::read-write-transaction[]
diff --git a/examples/src/main/java/org/neo4j/docs/driver/ResultConsumeExample.java b/examples/src/main/java/org/neo4j/docs/driver/ResultConsumeExample.java
index 2365f43b26..9d2a021e82 100644
--- a/examples/src/main/java/org/neo4j/docs/driver/ResultConsumeExample.java
+++ b/examples/src/main/java/org/neo4j/docs/driver/ResultConsumeExample.java
@@ -24,7 +24,7 @@
 import java.util.List;
 
 import org.neo4j.driver.Session;
-import org.neo4j.driver.StatementResult;
+import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.TransactionWork;
 // end::result-consume-import[]
@@ -55,7 +55,7 @@ public List execute( Transaction tx )
     private static List matchPersonNodes( Transaction tx )
     {
         List names = new ArrayList<>();
-        StatementResult result = tx.run( "MATCH (a:Person) RETURN a.name ORDER BY a.name" );
+        Result result = tx.run( "MATCH (a:Person) RETURN a.name ORDER BY a.name" );
         while ( result.hasNext() )
         {
             names.add( result.next().get( 0 ).asString() );
diff --git a/examples/src/main/java/org/neo4j/docs/driver/RxTransactionFunctionExample.java b/examples/src/main/java/org/neo4j/docs/driver/RxTransactionFunctionExample.java
index ae3c0aeb06..b126f6f07c 100644
--- a/examples/src/main/java/org/neo4j/docs/driver/RxTransactionFunctionExample.java
+++ b/examples/src/main/java/org/neo4j/docs/driver/RxTransactionFunctionExample.java
@@ -25,7 +25,7 @@
 import java.util.Collections;
 import java.util.Map;
 
-import org.neo4j.driver.reactive.RxStatementResult;
+import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.reactive.RxSession;
 import org.neo4j.driver.summary.ResultSummary;
 
@@ -44,7 +44,7 @@ public Flux printAllProductsReactor()
 
         return Flux.usingWhen( Mono.fromSupplier( driver::rxSession ),
                 session -> session.readTransaction( tx -> {
-                    RxStatementResult result = tx.run( query, parameters );
+                    RxResult result = tx.run( query, parameters );
                     return Flux.from( result.records() )
                             .doOnNext( record -> System.out.println( record.get( 0 ).asString() ) ).then( Mono.from( result.consume() ) );
                 }
@@ -60,7 +60,7 @@ public Flowable printAllProductsRxJava()
 
         RxSession session = driver.rxSession();
         return Flowable.fromPublisher( session.readTransaction( tx -> {
-                    RxStatementResult result = tx.run( query, parameters );
+                    RxResult result = tx.run( query, parameters );
                     return Flowable.fromPublisher( result.records() )
                             .doOnNext( record -> System.out.println( record.get( 0 ).asString() ) ).ignoreElements().andThen( result.consume() );
                 } ) ).onErrorResumeNext( error -> {

From 4b83307fe246bff3b3dedab5d9f8ecb17b02fd53 Mon Sep 17 00:00:00 2001
From: Nigel Small 
Date: Mon, 18 Nov 2019 11:41:12 +0000
Subject: [PATCH 2/7] Statement->Query

---
 LICENSE.txt                                   |  2 +-
 .../main/java/org/neo4j/driver/Driver.java    |  2 +-
 .../driver/{Statement.java => Query.java}     | 80 +++++++++----------
 ...{StatementRunner.java => QueryRunner.java} | 70 ++++++++--------
 .../main/java/org/neo4j/driver/Record.java    |  2 +-
 .../main/java/org/neo4j/driver/Result.java    | 18 ++---
 .../main/java/org/neo4j/driver/Session.java   | 38 ++++-----
 .../java/org/neo4j/driver/Transaction.java    | 12 +--
 .../main/java/org/neo4j/driver/Values.java    |  4 +-
 ...ementRunner.java => AsyncQueryRunner.java} | 68 ++++++++--------
 .../org/neo4j/driver/async/AsyncSession.java  | 48 +++++------
 .../neo4j/driver/async/AsyncTransaction.java  | 10 +--
 .../org/neo4j/driver/async/ResultCursor.java  | 18 ++---
 .../exceptions/ResultConsumedException.java   |  4 +-
 ...ntRunner.java => AbstractQueryRunner.java} | 22 ++---
 .../driver/internal/InternalSession.java      | 20 ++---
 .../driver/internal/InternalTransaction.java  |  8 +-
 ...ner.java => AsyncAbstractQueryRunner.java} | 24 +++---
 .../internal/async/InternalAsyncSession.java  | 20 ++---
 .../async/InternalAsyncTransaction.java       |  8 +-
 .../driver/internal/async/NetworkSession.java | 16 ++--
 .../internal/async/UnmanagedTransaction.java  | 16 ++--
 .../MultiDatabasesRoutingProcedureRunner.java |  6 +-
 ...ngProcedureClusterCompositionProvider.java |  6 +-
 .../cluster/RoutingProcedureResponse.java     | 12 +--
 .../cluster/RoutingProcedureRunner.java       | 16 ++--
 .../cursor/AsyncResultCursorImpl.java         |  2 +-
 .../internal/cursor/RxResultCursorImpl.java   |  2 +-
 .../LegacyPullAllResponseHandler.java         | 14 ++--
 .../internal/handlers/PullHandlers.java       | 18 ++---
 .../internal/handlers/RunResponseHandler.java | 18 ++---
 .../pulln/AutoPullResponseHandler.java        |  8 +-
 .../pulln/BasicPullResponseHandler.java       | 18 ++---
 .../internal/messaging/BoltProtocol.java      | 18 ++---
 .../messaging/encode/RunMessageEncoder.java   |  2 +-
 .../encode/RunWithMetadataMessageEncoder.java |  2 +-
 .../messaging/request/RunMessage.java         | 22 ++---
 .../request/RunWithMetadataMessage.java       | 30 +++----
 .../internal/messaging/v1/BoltProtocolV1.java | 20 ++---
 .../internal/messaging/v3/BoltProtocolV3.java | 18 ++---
 .../internal/messaging/v4/BoltProtocolV4.java |  8 +-
 ...Runner.java => AbstractRxQueryRunner.java} | 24 +++---
 .../internal/reactive/InternalRxSession.java  | 20 ++---
 .../reactive/InternalRxTransaction.java       |  8 +-
 .../driver/internal/summary/InternalPlan.java |  2 +-
 .../summary/InternalProfiledPlan.java         |  2 +-
 .../summary/InternalResultSummary.java        | 34 ++++----
 .../neo4j/driver/internal/util/ErrorUtil.java |  2 +-
 .../internal/util/MetadataExtractor.java      | 20 ++---
 ...tatementRunner.java => RxQueryRunner.java} | 68 ++++++++--------
 .../org/neo4j/driver/reactive/RxResult.java   | 26 +++---
 .../org/neo4j/driver/reactive/RxSession.java  | 52 ++++++------
 .../neo4j/driver/reactive/RxTransaction.java  |  2 +-
 .../neo4j/driver/summary/InputPosition.java   |  2 +-
 .../neo4j/driver/summary/Notification.java    |  8 +-
 .../java/org/neo4j/driver/summary/Plan.java   |  6 +-
 .../{StatementType.java => QueryType.java}    | 16 ++--
 .../neo4j/driver/summary/ResultSummary.java   | 40 +++++-----
 .../neo4j/driver/summary/SummaryCounters.java |  4 +-
 .../{StatementTest.java => QueryTest.java}    | 60 +++++++-------
 .../integration/ConnectionHandlingIT.java     |  6 +-
 .../org/neo4j/driver/integration/ErrorIT.java |  6 +-
 .../driver/integration/NestedQueries.java     | 20 ++---
 .../{StatementIT.java => QueryIT.java}        | 12 +--
 ...erCloseIT.java => QueryRunnerCloseIT.java} |  2 +-
 .../driver/integration/ScalarTypeIT.java      |  4 +-
 .../neo4j/driver/integration/SessionIT.java   | 16 ++--
 .../driver/integration/SessionMixIT.java      |  6 +-
 .../driver/integration/SessionResetIT.java    | 28 +++----
 .../neo4j/driver/integration/SummaryIT.java   | 24 +++---
 .../driver/integration/TransactionIT.java     | 12 +--
 .../integration/UnmanagedTransactionIT.java   | 18 ++---
 .../integration/async/AsyncSessionIT.java     | 34 ++++----
 .../integration/async/AsyncTransactionIT.java | 56 ++++++-------
 .../integration/reactive/RxResultIT.java      | 18 ++---
 .../integration/reactive/RxTransactionIT.java | 66 +++++++--------
 .../internal/DirectDriverBoltKitTest.java     |  4 +-
 .../driver/internal/InternalResultTest.java   |  6 +-
 .../internal/InternalTransactionTest.java     |  6 +-
 .../async/AsyncResultCursorImplTest.java      | 10 +--
 .../async/InternalAsyncSessionTest.java       |  8 +-
 .../async/InternalAsyncTransactionTest.java   |  6 +-
 .../internal/async/NetworkSessionTest.java    | 12 +--
 .../async/UnmanagedTransactionTest.java       | 10 +--
 ...tiDatabasesRoutingProcedureRunnerTest.java | 20 ++---
 ...ocedureClusterCompositionProviderTest.java |  6 +-
 .../cluster/RoutingProcedureResponseTest.java |  4 +-
 .../cluster/RoutingProcedureRunnerTest.java   | 20 ++---
 .../cursor/RxResultCursorImplTest.java        |  4 +-
 .../LegacyPullAllResponseHandlerTest.java     | 10 +--
 .../PullAllResponseHandlerTestBase.java       | 52 ++++++------
 .../handlers/RunResponseHandlerTest.java      |  4 +-
 ...ionPullResponseCompletionListenerTest.java |  4 +-
 ...ionPullResponseCompletionListenerTest.java |  4 +-
 .../pulln/AutoPullResponseHandlerTest.java    |  8 +-
 ...ionPullResponseCompletionListenerTest.java |  4 +-
 ...ionPullResponseCompletionListenerTest.java |  4 +-
 .../encode/DiscardMessageEncoderTest.java     |  2 +-
 .../encode/PullMessageEncoderTest.java        |  2 +-
 .../RunWithMetadataMessageEncoderTest.java    |  6 +-
 .../messaging/v1/BoltProtocolV1Test.java      | 16 ++--
 .../messaging/v3/BoltProtocolV3Test.java      | 20 ++---
 .../messaging/v3/MessageWriterV3Test.java     | 14 ++--
 .../messaging/v4/BoltProtocolV4Test.java      | 16 ++--
 .../messaging/v4/MessageWriterV4Test.java     | 14 ++--
 .../reactive/InternalRxSessionTest.java       | 14 ++--
 .../reactive/InternalRxTransactionTest.java   | 12 +--
 .../reactive/util/ListBasedPullHandler.java   |  8 +-
 .../internal/util/MetadataExtractorTest.java  | 70 ++++++++--------
 .../driver/stress/AbstractStressTestBase.java | 22 ++---
 .../driver/stress/CausalClusteringIT.java     | 14 ++--
 .../neo4j/driver/util/SessionExtension.java   | 34 ++++----
 .../java/org/neo4j/driver/util/TestUtil.java  | 18 ++---
 .../org/neo4j/docs/driver/ExamplesIT.java     | 24 +++---
 114 files changed, 991 insertions(+), 995 deletions(-)
 rename driver/src/main/java/org/neo4j/driver/{Statement.java => Query.java} (62%)
 rename driver/src/main/java/org/neo4j/driver/{StatementRunner.java => QueryRunner.java} (66%)
 rename driver/src/main/java/org/neo4j/driver/async/{AsyncStatementRunner.java => AsyncQueryRunner.java} (75%)
 rename driver/src/main/java/org/neo4j/driver/internal/{AbstractStatementRunner.java => AbstractQueryRunner.java} (66%)
 rename driver/src/main/java/org/neo4j/driver/internal/async/{AsyncAbstractStatementRunner.java => AsyncAbstractQueryRunner.java} (51%)
 rename driver/src/main/java/org/neo4j/driver/internal/reactive/{AbstractRxStatementRunner.java => AbstractRxQueryRunner.java} (53%)
 rename driver/src/main/java/org/neo4j/driver/reactive/{RxStatementRunner.java => RxQueryRunner.java} (58%)
 rename driver/src/main/java/org/neo4j/driver/summary/{StatementType.java => QueryType.java} (72%)
 rename driver/src/test/java/org/neo4j/driver/{StatementTest.java => QueryTest.java} (56%)
 rename driver/src/test/java/org/neo4j/driver/integration/{StatementIT.java => QueryIT.java} (94%)
 rename driver/src/test/java/org/neo4j/driver/integration/{StatementRunnerCloseIT.java => QueryRunnerCloseIT.java} (99%)

diff --git a/LICENSE.txt b/LICENSE.txt
index d645695673..a1fac6c0ad 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -121,7 +121,7 @@
           that such additional attribution notices cannot be construed
           as modifying the License.
 
-      You may add Your own copyright statement to Your modifications and
+      You may add Your own copyright query to Your modifications and
       may provide additional or different license terms and conditions
       for use, reproduction, or distribution of Your modifications, or
       for any such Derivative Works as a whole, provided Your use,
diff --git a/driver/src/main/java/org/neo4j/driver/Driver.java b/driver/src/main/java/org/neo4j/driver/Driver.java
index a3f44b7d2e..af732035ce 100644
--- a/driver/src/main/java/org/neo4j/driver/Driver.java
+++ b/driver/src/main/java/org/neo4j/driver/Driver.java
@@ -167,7 +167,7 @@ public interface Driver extends AutoCloseable
      * This will return the type system supported by the driver.
      * The types supported on a particular server a session is connected against might not contain all of the types defined here.
      *
-     * @return type system used by this statement runner for classifying values
+     * @return type system used by this query runner for classifying values
      */
     @Experimental
     TypeSystem defaultTypeSystem();
diff --git a/driver/src/main/java/org/neo4j/driver/Statement.java b/driver/src/main/java/org/neo4j/driver/Query.java
similarity index 62%
rename from driver/src/main/java/org/neo4j/driver/Statement.java
rename to driver/src/main/java/org/neo4j/driver/Query.java
index 2ec9002a06..89a2068e50 100644
--- a/driver/src/main/java/org/neo4j/driver/Statement.java
+++ b/driver/src/main/java/org/neo4j/driver/Query.java
@@ -31,7 +31,7 @@
 import static org.neo4j.driver.Values.value;
 
 /**
- * An executable statement, i.e. the statements' text and its parameters.
+ * The components of a Cypher query, containing the query text and parameter map.
  *
  * @see Session
  * @see Transaction
@@ -41,19 +41,19 @@
  * @since 1.0
  */
 @Immutable
-public class Statement
+public class Query
 {
     private final String text;
     private final Value parameters;
 
     /**
-     * Create a new statement.
-     * @param text the statement text
-     * @param parameters the statement parameters
+     * Create a new query.
+     * @param text the query text
+     * @param parameters the parameter map
      */
-    public Statement( String text, Value parameters )
+    public Query(String text, Value parameters )
     {
-        this.text = validateQuery( text );
+        this.text = validateQueryText( text );
         if( parameters == null )
         {
             this.parameters = Values.EmptyMap;
@@ -69,26 +69,26 @@ else if ( parameters instanceof MapValue )
     }
 
     /**
-     * Create a new statement.
-     * @param text the statement text
-     * @param parameters the statement parameters
+     * Create a new query.
+     * @param text the query text
+     * @param parameters the parameter map
      */
-    public Statement( String text, Map parameters )
+    public Query(String text, Map parameters )
     {
         this( text, Values.value( parameters ) );
     }
 
     /**
-     * Create a new statement.
-     * @param text the statement text
+     * Create a new query.
+     * @param text the query text
      */
-    public Statement( String text )
+    public Query(String text )
     {
         this( text, Values.EmptyMap );
     }
 
     /**
-     * @return the statement's text
+     * @return the query text
      */
     public String text()
     {
@@ -96,7 +96,7 @@ public String text()
     }
 
     /**
-     * @return the statement's parameters
+     * @return the parameter map
      */
     public Value parameters()
     {
@@ -104,44 +104,44 @@ public Value parameters()
     }
 
     /**
-     * @param newText the new statement's text
-     * @return a new statement with updated text
+     * @param newText the new query text
+     * @return a new Query object with updated text
      */
-    public Statement withText( String newText )
+    public Query withText(String newText )
     {
-        return new Statement( newText, parameters );
+        return new Query( newText, parameters );
     }
 
     /**
-     * @param newParameters the new statement's parameters
-     * @return a new statement with updated parameters
+     * @param newParameters the new parameter map
+     * @return a new Query object with updated parameters
      */
-    public Statement withParameters( Value newParameters )
+    public Query withParameters(Value newParameters )
     {
-        return new Statement( text, newParameters );
+        return new Query( text, newParameters );
     }
 
     /**
-     * @param newParameters the new statement's parameters
-     * @return a new statement with updated parameters
+     * @param newParameters the new parameter map
+     * @return a new Query object with updated parameters
      */
-    public Statement withParameters( Map newParameters )
+    public Query withParameters(Map newParameters )
     {
-        return new Statement( text, newParameters );
+        return new Query( text, newParameters );
     }
 
     /**
-     * Create a new statement with new parameters derived by updating this'
-     * statement's parameters using the given updates.
+     * Create a new query with new parameters derived by updating this'
+     * query's parameters using the given updates.
      *
      * Every update key that points to a null value will be removed from
-     * the new statement's parameters. All other entries will just replace
-     * any existing parameter in the new statement.
+     * the new query's parameters. All other entries will just replace
+     * any existing parameter in the new query.
      *
      * @param updates describing how to update the parameters
-     * @return a new statement with updated parameters
+     * @return a new query with updated parameters
      */
-    public Statement withUpdatedParameters( Value updates )
+    public Query withUpdatedParameters(Value updates )
     {
         if ( updates == null || updates.isEmpty() )
         {
@@ -179,8 +179,8 @@ public boolean equals( Object o )
             return false;
         }
 
-        Statement statement = (Statement) o;
-        return text.equals( statement.text ) && parameters.equals( statement.parameters );
+        Query query = (Query) o;
+        return text.equals( query.text ) && parameters.equals( query.parameters );
 
     }
 
@@ -195,13 +195,13 @@ public int hashCode()
     @Override
     public String toString()
     {
-        return format( "Statement{text='%s', parameters=%s}", text, parameters );
+        return format( "Query{text='%s', parameters=%s}", text, parameters );
     }
 
-    private static String validateQuery( String query )
+    private static String validateQueryText(String query )
     {
-        checkArgument( query != null, "Cypher query should not be null" );
-        checkArgument( !query.isEmpty(), "Cypher query should not be an empty string" );
+        checkArgument( query != null, "Cypher query text should not be null" );
+        checkArgument( !query.isEmpty(), "Cypher query text should not be an empty string" );
         return query;
     }
 }
diff --git a/driver/src/main/java/org/neo4j/driver/StatementRunner.java b/driver/src/main/java/org/neo4j/driver/QueryRunner.java
similarity index 66%
rename from driver/src/main/java/org/neo4j/driver/StatementRunner.java
rename to driver/src/main/java/org/neo4j/driver/QueryRunner.java
index d32565e652..e4ccec8b29 100644
--- a/driver/src/main/java/org/neo4j/driver/StatementRunner.java
+++ b/driver/src/main/java/org/neo4j/driver/QueryRunner.java
@@ -21,23 +21,23 @@
 import java.util.Map;
 
 /**
- * Common interface for components that can execute Neo4j statements.
+ * Common interface for components that can execute Neo4j queries.
  *
  * 
Important notes on semantics

  * 

- * Statements run in the same {@link StatementRunner} are guaranteed
- * to execute in order, meaning changes made by one statement will be seen
- * by all subsequent statements in the same {@link StatementRunner}.
+ * queries run in the same {@link QueryRunner} are guaranteed
+ * to execute in order, meaning changes made by one query will be seen
+ * by all subsequent queries in the same {@link QueryRunner}.
  * 

  * However, to allow handling very large results, and to improve performance,
  * result streams are retrieved lazily from the network.
- * This means that when any of {@link #run(Statement)}
- * methods return a result, the statement has only started executing - it may not
+ * This means that when any of {@link #run(Query)}
+ * methods return a result, the query has only started executing - it may not
  * have completed yet. Most of the time, you will not notice this, because the
- * driver automatically waits for statements to complete at specific points to
+ * driver automatically waits for queries to complete at specific points to
  * fulfill its contracts.
  * 

- * Specifically, the driver will ensure all outstanding statements are completed
+ * Specifically, the driver will ensure all outstanding queries are completed
  * whenever you:
  *
  * 
    
@@ -59,13 +59,13 @@
  * @see Transaction
  * @since 1.0
  */
-public interface StatementRunner
+public interface QueryRunner
 {
     /**
-     * Run a statement and return a result stream.
+     * Run a query and return a result stream.
      * 
    
      * This method takes a set of parameters that will be injected into the
-     * statement by Neo4j. Using parameters is highly encouraged, it helps avoid
+     * query by Neo4j. Using parameters is highly encouraged, it helps avoid
      * dangerous cypher injection attacks and improves database performance as
      * Neo4j can re-use query plans more often.
      * 
    
@@ -77,7 +77,7 @@ public interface StatementRunner
      * might be more helpful, it converts your map to a {@link Value} for you.
      *
      * 
    Example
    
-     * 
    +     * 
          * {@code
      *
      * Result result = session.run( "MATCH (n) WHERE n.name = {myNameParam} RETURN (n)",
@@ -85,17 +85,17 @@ public interface StatementRunner
      * }
      * 
    
      *
-     * @param statementTemplate text of a Neo4j statement
+     * @param query text of a Neo4j query
      * @param parameters input parameters, should be a map Value, see {@link Values#parameters(Object...)}.
      * @return a stream of result values and associated metadata
      */
-    Result run(String statementTemplate, Value parameters );
+    Result run(String query, Value parameters );
 
     /**
-     * Run a statement and return a result stream.
+     * Run a query and return a result stream.
      * 
    
      * This method takes a set of parameters that will be injected into the
-     * statement by Neo4j. Using parameters is highly encouraged, it helps avoid
+     * query by Neo4j. Using parameters is highly encouraged, it helps avoid
      * dangerous cypher injection attacks and improves database performance as
      * Neo4j can re-use query plans more often.
      * 
    
@@ -104,7 +104,7 @@ public interface StatementRunner
      * a list of allowed types.
      *
      * 
    Example
    
-     * 
    +     * 
          * {@code
      *
      * Map parameters = new HashMap();
@@ -115,50 +115,50 @@ public interface StatementRunner
      * }
      * 
    
      *
-     * @param statementTemplate text of a Neo4j statement
-     * @param statementParameters input data for the statement
+     * @param query text of a Neo4j query
+     * @param parameters input data for the query
      * @return a stream of result values and associated metadata
      */
-    Result run(String statementTemplate, Map statementParameters );
+    Result run(String query, Map parameters );
 
     /**
-     * Run a statement and return a result stream.
+     * Run a query and return a result stream.
      * 
    
      * This method takes a set of parameters that will be injected into the
-     * statement by Neo4j. Using parameters is highly encouraged, it helps avoid
+     * query by Neo4j. Using parameters is highly encouraged, it helps avoid
      * dangerous cypher injection attacks and improves database performance as
      * Neo4j can re-use query plans more often.
      * 
    
      * This version of run takes a {@link Record} of parameters, which can be useful
-     * if you want to use the output of one statement as input for another.
+     * if you want to use the output of one query as input for another.
      *
-     * @param statementTemplate text of a Neo4j statement
-     * @param statementParameters input data for the statement
+     * @param query text of a Neo4j query
+     * @param parameters input data for the query
      * @return a stream of result values and associated metadata
      */
-    Result run(String statementTemplate, Record statementParameters );
+    Result run(String query, Record parameters );
 
     /**
-     * Run a statement and return a result stream.
+     * Run a query and return a result stream.
      *
-     * @param statementTemplate text of a Neo4j statement
+     * @param query text of a Neo4j query
      * @return a stream of result values and associated metadata
      */
-    Result run(String statementTemplate );
+    Result run(String query );
 
     /**
-     * Run a statement and return a result stream.
+     * Run a query and return a result stream.
      * 
    Example
    
-     * 
    +     * 
          * {@code
      *
-     * Statement statement = new Statement( "MATCH (n) WHERE n.name=$myNameParam RETURN n.age" );
-     * Result result = session.run( statement.withParameters( Values.parameters( "myNameParam", "Bob" )  ) );
+     * Query query = new Query( "MATCH (n) WHERE n.name=$myNameParam RETURN n.age" );
+     * Result result = session.run( query.withParameters( Values.parameters( "myNameParam", "Bob" )  ) );
      * }
      * 
    
      *
-     * @param statement a Neo4j statement
+     * @param query a Neo4j query
      * @return a stream of result values and associated metadata
      */
-    Result run(Statement statement );
+    Result run(Query query);
 }
diff --git a/driver/src/main/java/org/neo4j/driver/Record.java b/driver/src/main/java/org/neo4j/driver/Record.java
index 946bb3c7ae..3f4beda137 100644
--- a/driver/src/main/java/org/neo4j/driver/Record.java
+++ b/driver/src/main/java/org/neo4j/driver/Record.java
@@ -32,7 +32,7 @@
 /**
  * Container for Cypher result values.
  * 
    
- * Streams of records are returned from Cypher statement execution, contained
+ * Streams of records are returned from Cypher query execution, contained
  * within a {@link Result}.
  * 
    
  * A record is a form of ordered map and, as such, contained values can be
diff --git a/driver/src/main/java/org/neo4j/driver/Result.java b/driver/src/main/java/org/neo4j/driver/Result.java
index bf0807b143..4a9d039878 100644
--- a/driver/src/main/java/org/neo4j/driver/Result.java
+++ b/driver/src/main/java/org/neo4j/driver/Result.java
@@ -29,22 +29,22 @@
 
 
 /**
- * The result of running a Cypher statement, conceptually a stream of {@link Record records}.
+ * The result of running a Cypher query, conceptually a stream of {@link Record records}.
  *
  * The standard way of navigating through the result returned by the database is to
  * {@link #next() iterate} over it.
  *
- * Results are valid until the next statement is run or until the end of the current transaction,
- * whichever comes first. To keep a result around while further statements are run, or to use a result outside the scope
+ * Results are valid until the next query is run or until the end of the current transaction,
+ * whichever comes first. To keep a result around while further queries are run, or to use a result outside the scope
  * of the current transaction, see {@link #list()}.
  *
  * 
    Important note on semantics
    
  *
  * In order to handle very large results, and to minimize memory overhead and maximize
- * performance, results are retrieved lazily. Please see {@link StatementRunner} for
+ * performance, results are retrieved lazily. Please see {@link QueryRunner} for
  * important details on the effects of this.
  *
- * The short version is that, if you want a hard guarantee that the underlying statement
+ * The short version is that, if you want a hard guarantee that the underlying query
  * has completed, you need to either call {@link Resource#close()} on the {@link Transaction}
  * or {@link Session} that created this result, or you need to use the result.
  *
@@ -109,8 +109,8 @@ public interface Result extends Iterator
      * This can be used if you want to iterate over the stream multiple times or to store the
      * whole result for later use.
      *
-     * Note that this method can only be used if you know that the statement that
-     * yielded this result returns a finite stream. Some statements can yield
+     * Note that this method can only be used if you know that the query that
+     * yielded this result returns a finite stream. Some queries can yield
      * infinite results, in which case calling this method will lead to running
      * out of memory.
      *
@@ -125,8 +125,8 @@ public interface Result extends Iterator
      * This can be used if you want to iterate over the stream multiple times or to store the
      * whole result for later use.
      *
-     * Note that this method can only be used if you know that the statement that
-     * yielded this result returns a finite stream. Some statements can yield
+     * Note that this method can only be used if you know that the query that
+     * yielded this result returns a finite stream. Some queries can yield
      * infinite results, in which case calling this method will lead to running
      * out of memory.
      *
diff --git a/driver/src/main/java/org/neo4j/driver/Session.java b/driver/src/main/java/org/neo4j/driver/Session.java
index b2835d6bb6..f20661a139 100644
--- a/driver/src/main/java/org/neo4j/driver/Session.java
+++ b/driver/src/main/java/org/neo4j/driver/Session.java
@@ -27,15 +27,15 @@
  * Provides a context of work for database interactions.
  * 
    
  * A Session hosts a series of {@linkplain Transaction transactions}
- * carried out against a database. Within the database, all statements are
+ * carried out against a database. Within the database, all queries are
  * carried out within a transaction. Within application code, however, it is
  * not always necessary to explicitly {@link #beginTransaction() begin a
- * transaction}. If a statement is {@link #run} directly against a {@link
+ * transaction}. If a query is {@link #run} directly against a {@link
  * Session}, the server will automatically BEGIN and
- * COMMIT that statement within its own transaction. This type
+ * COMMIT that query within its own transaction. This type
  * of transaction is known as an autocommit transaction.
  * 
    
- * Explicit transactions allow multiple statements to be committed as part of
+ * Explicit transactions allow multiple queries to be committed as part of
  * a single atomic operation and can be rolled back if necessary. They can also
  * be used to ensure causal consistency, meaning that an application
  * can run a series of queries on different members of a cluster, while
@@ -61,7 +61,7 @@
  *
  * @since 1.0 (Removed async API to {@link AsyncSession} in 2.0)
  */
-public interface Session extends Resource, StatementRunner
+public interface Session extends Resource, QueryRunner
 {
     /**
      * Begin a new explicit {@linkplain Transaction transaction}. At
@@ -135,19 +135,19 @@ public interface Session extends Resource, StatementRunner
      T writeTransaction( TransactionWork work, TransactionConfig config );
 
     /**
-     * Run a statement in an auto-commit transaction with the specified {@link TransactionConfig configuration} and return a result stream.
+     * Run a query in an auto-commit transaction with the specified {@link TransactionConfig configuration} and return a result stream.
      *
-     * @param statement text of a Neo4j statement.
+     * @param query text of a Neo4j query.
      * @param config configuration for the new transaction.
      * @return a stream of result values and associated metadata.
      */
-    Result run(String statement, TransactionConfig config );
+    Result run(String query, TransactionConfig config );
 
     /**
-     * Run a statement with parameters in an auto-commit transaction with specified {@link TransactionConfig configuration} and return a result stream.
+     * Run a query with parameters in an auto-commit transaction with specified {@link TransactionConfig configuration} and return a result stream.
      * 
    
      * This method takes a set of parameters that will be injected into the
-     * statement by Neo4j. Using parameters is highly encouraged, it helps avoid
+     * query by Neo4j. Using parameters is highly encouraged, it helps avoid
      * dangerous cypher injection attacks and improves database performance as
      * Neo4j can re-use query plans more often.
      * 
    
@@ -173,15 +173,15 @@ public interface Session extends Resource, StatementRunner
      * }
      * 
    
      *
-     * @param statement text of a Neo4j statement.
-     * @param parameters input data for the statement.
+     * @param query text of a Neo4j query.
+     * @param parameters input data for the query.
      * @param config configuration for the new transaction.
      * @return a stream of result values and associated metadata.
      */
-    Result run(String statement, Map parameters, TransactionConfig config );
+    Result run(String query, Map parameters, TransactionConfig config );
 
     /**
-     * Run a statement in an auto-commit transaction with specified {@link TransactionConfig configuration} and return a result stream.
+     * Run a query in an auto-commit transaction with specified {@link TransactionConfig configuration} and return a result stream.
      * 
    Example
    
      * 
          * {@code
@@ -193,16 +193,16 @@ public interface Session extends Resource, StatementRunner
      *                 .withMetadata(metadata)
      *                 .build();
      *
-     * Statement statement = new Statement("MATCH (n) WHERE n.name=$myNameParam RETURN n.age");
-     * Result result = session.run(statement.withParameters(Values.parameters("myNameParam", "Bob")));
+     * Query query = new Query("MATCH (n) WHERE n.name=$myNameParam RETURN n.age");
+     * Result result = session.run(query.withParameters(Values.parameters("myNameParam", "Bob")));
      * }
      * 
    
      *
-     * @param statement a Neo4j statement.
+     * @param query a Neo4j query.
      * @param config configuration for the new transaction.
      * @return a stream of result values and associated metadata.
      */
-    Result run(Statement statement, TransactionConfig config );
+    Result run(Query query, TransactionConfig config );
 
     /**
      * Return the bookmark received following the last completed
@@ -216,7 +216,7 @@ public interface Session extends Resource, StatementRunner
 
     /**
      * Reset the current session. This sends an immediate RESET signal to the server which both interrupts
-     * any statement that is currently executing and ignores any subsequently queued statements. Following
+     * any query that is currently executing and ignores any subsequently queued queries. Following
      * the reset, the current transaction will have been rolled back and any outstanding failures will
      * have been acknowledged.
      *
diff --git a/driver/src/main/java/org/neo4j/driver/Transaction.java b/driver/src/main/java/org/neo4j/driver/Transaction.java
index 65301c637c..4523132d3f 100644
--- a/driver/src/main/java/org/neo4j/driver/Transaction.java
+++ b/driver/src/main/java/org/neo4j/driver/Transaction.java
@@ -36,19 +36,19 @@
  * }
  * }
  * Blocking calls are: {@link #commit()}, {@link #rollback()}, {@link #close()}
- * and various overloads of {@link #run(Statement)}.
+ * and various overloads of {@link #run(Query)}.
  *
  * @see Session#run
- * @see StatementRunner
+ * @see QueryRunner
  * @since 1.0
  */
-public interface Transaction extends Resource, StatementRunner
+public interface Transaction extends Resource, QueryRunner
 {
     /**
      * Commit this current transaction.
-     * When this method returns, all outstanding statements in the transaction are guaranteed to
+     * When this method returns, all outstanding queries in the transaction are guaranteed to
      * have completed, meaning any writes you performed are guaranteed to be durably stored.
-     * No more statement can be executed inside this transaction once this transaction is committed.
+     * No more queries can be executed inside this transaction once this transaction is committed.
      * After this method is called, the transaction cannot be committed or rolled back again.
      * You must call this method before calling {@link #close()} to have your transaction committed.
      * If a transaction is not committed or rolled back before close,
@@ -68,7 +68,7 @@ public interface Transaction extends Resource, StatementRunner
 
     /**
      * Roll back this current transaction.
-     * No more statement can be executed inside this transaction once this transaction is committed.
+     * No more queries can be executed inside this transaction once this transaction is committed.
      * After this method has been called, the transaction cannot be committed or rolled back again.
      * If a transaction is not committed or rolled back before close,
      * the transaction will be rolled back by default in {@link #close}.
diff --git a/driver/src/main/java/org/neo4j/driver/Values.java b/driver/src/main/java/org/neo4j/driver/Values.java
index f49d34a186..4891eaa89e 100644
--- a/driver/src/main/java/org/neo4j/driver/Values.java
+++ b/driver/src/main/java/org/neo4j/driver/Values.java
@@ -366,7 +366,7 @@ public static Value point( int srid, double x, double y, double z )
 
     /**
      * Helper function for creating a map of parameters, this can be used when you {@link
-     * StatementRunner#run(String, Value) run} statements.
+     * QueryRunner#run(String, Value) run} queries.
      * 
    
      * Allowed parameter types are:
      * 
      
@@ -382,7 +382,7 @@ public static Value point( int srid, double x, double y, double z )
      *
      * @param keysAndValues alternating sequence of keys and values
      * @return Map containing all parameters specified
-     * @see StatementRunner#run(String, Value)
+     * @see QueryRunner#run(String, Value)
      */
     public static Value parameters( Object... keysAndValues )
     {
diff --git a/driver/src/main/java/org/neo4j/driver/async/AsyncStatementRunner.java b/driver/src/main/java/org/neo4j/driver/async/AsyncQueryRunner.java
similarity index 75%
rename from driver/src/main/java/org/neo4j/driver/async/AsyncStatementRunner.java
rename to driver/src/main/java/org/neo4j/driver/async/AsyncQueryRunner.java
index 0f00eaf7c5..03f63cae7a 100644
--- a/driver/src/main/java/org/neo4j/driver/async/AsyncStatementRunner.java
+++ b/driver/src/main/java/org/neo4j/driver/async/AsyncQueryRunner.java
@@ -24,29 +24,29 @@
 import java.util.concurrent.Executor;
 import java.util.function.Function;
 
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.Values;
 
 /**
- * Asynchronous interface for components that can execute Neo4j statements.
+ * Asynchronous interface for components that can execute Neo4j queries.
  *
  * 
      Important notes on semantics
      
  * 
      
- * Statements run in the same {@link AsyncStatementRunner} are guaranteed
- * to execute in order, meaning changes made by one statement will be seen
- * by all subsequent statements in the same {@link AsyncStatementRunner}.
+ * Queries run in the same {@link AsyncQueryRunner} are guaranteed
+ * to execute in order, meaning changes made by one query will be seen
+ * by all subsequent queries in the same {@link AsyncQueryRunner}.
  * 
      
  * However, to allow handling very large results, and to improve performance,
  * result streams are retrieved lazily from the network. This means that when
- * async {@link #runAsync(Statement)}
- * methods return a result, the statement has only started executing - it may not
+ * async {@link #runAsync(Query)}
+ * methods return a result, the query has only started executing - it may not
  * have completed yet. Most of the time, you will not notice this, because the
- * driver automatically waits for statements to complete at specific points to
+ * driver automatically waits for queries to complete at specific points to
  * fulfill its contracts.
  * 
      
- * Specifically, the driver will ensure all outstanding statements are completed
+ * Specifically, the driver will ensure all outstanding queries are completed
  * whenever you:
  *
  * 
        
@@ -66,7 +66,7 @@
  *
  * 
        Asynchronous API
        
  * 
        
- * All overloads of {@link #runAsync(Statement)} execute queries in async fashion and return {@link CompletionStage} of
+ * All overloads of {@link #runAsync(Query)} execute queries in async fashion and return {@link CompletionStage} of
  * a new {@link ResultCursor}. Stage can be completed exceptionally when error happens, e.g. connection can't
  * be acquired from the pool.
  * 
        
@@ -80,14 +80,14 @@
  * @see AsyncTransaction
  * @since 2.0
  */
-public interface AsyncStatementRunner
+public interface AsyncQueryRunner
 {
     /**
-     * Run a statement asynchronously and return a {@link CompletionStage} with a
+     * Run a query asynchronously and return a {@link CompletionStage} with a
      * result cursor.
      * 
        
      * This method takes a set of parameters that will be injected into the
-     * statement by Neo4j. Using parameters is highly encouraged, it helps avoid
+     * query by Neo4j. Using parameters is highly encouraged, it helps avoid
      * dangerous cypher injection attacks and improves database performance as
      * Neo4j can re-use query plans more often.
      * 
        
@@ -109,19 +109,19 @@ public interface AsyncStatementRunner
      * It is not allowed to chain blocking operations on the returned {@link CompletionStage}. See class javadoc for
      * more information.
      *
-     * @param statementTemplate text of a Neo4j statement
+     * @param query text of a Neo4j query
      * @param parameters input parameters, should be a map Value, see {@link Values#parameters(Object...)}.
      * @return new {@link CompletionStage} that gets completed with a result cursor when query execution is successful.
      * Stage can be completed exceptionally when error happens, e.g. connection can't be acquired from the pool.
      */
-    CompletionStage runAsync(String statementTemplate, Value parameters );
+    CompletionStage runAsync(String query, Value parameters );
 
     /**
-     * Run a statement asynchronously and return a {@link CompletionStage} with a
+     * Run a query asynchronously and return a {@link CompletionStage} with a
      * result cursor.
      * 
        
      * This method takes a set of parameters that will be injected into the
-     * statement by Neo4j. Using parameters is highly encouraged, it helps avoid
+     * query by Neo4j. Using parameters is highly encouraged, it helps avoid
      * dangerous cypher injection attacks and improves database performance as
      * Neo4j can re-use query plans more often.
      * 
        
@@ -143,64 +143,64 @@ public interface AsyncStatementRunner
      * It is not allowed to chain blocking operations on the returned {@link CompletionStage}. See class javadoc for
      * more information.
      *
-     * @param statementTemplate text of a Neo4j statement
-     * @param statementParameters input data for the statement
+     * @param query text of a Neo4j query
+     * @param parameters input data for the query
      * @return new {@link CompletionStage} that gets completed with a result cursor when query execution is successful.
      * Stage can be completed exceptionally when error happens, e.g. connection can't be acquired from the pool.
      */
-    CompletionStage runAsync(String statementTemplate, Map statementParameters );
+    CompletionStage runAsync(String query, Map parameters );
 
     /**
-     * Run a statement asynchronously and return a {@link CompletionStage} with a
+     * Run a query asynchronously and return a {@link CompletionStage} with a
      * result cursor.
      * 
        
      * This method takes a set of parameters that will be injected into the
-     * statement by Neo4j. Using parameters is highly encouraged, it helps avoid
+     * query by Neo4j. Using parameters is highly encouraged, it helps avoid
      * dangerous cypher injection attacks and improves database performance as
      * Neo4j can re-use query plans more often.
      * 
        
      * This version of runAsync takes a {@link Record} of parameters, which can be useful
-     * if you want to use the output of one statement as input for another.
+     * if you want to use the output of one query as input for another.
      * 
        
      * It is not allowed to chain blocking operations on the returned {@link CompletionStage}. See class javadoc for
      * more information.
      *
-     * @param statementTemplate text of a Neo4j statement
-     * @param statementParameters input data for the statement
+     * @param query text of a Neo4j query
+     * @param parameters input data for the query
      * @return new {@link CompletionStage} that gets completed with a result cursor when query execution is successful.
      * Stage can be completed exceptionally when error happens, e.g. connection can't be acquired from the pool.
      */
-    CompletionStage runAsync(String statementTemplate, Record statementParameters );
+    CompletionStage runAsync(String query, Record parameters );
 
     /**
-     * Run a statement asynchronously and return a {@link CompletionStage} with a
+     * Run a query asynchronously and return a {@link CompletionStage} with a
      * result cursor.
      * 
        
      * It is not allowed to chain blocking operations on the returned {@link CompletionStage}. See class javadoc for
      * more information.
      *
-     * @param statementTemplate text of a Neo4j statement
+     * @param query text of a Neo4j query
      * @return new {@link CompletionStage} that gets completed with a result cursor when query execution is successful.
      * Stage can be completed exceptionally when error happens, e.g. connection can't be acquired from the pool.
      */
-    CompletionStage runAsync(String statementTemplate );
+    CompletionStage runAsync(String query );
 
     /**
-     * Run a statement asynchronously and return a {@link CompletionStage} with a
+     * Run a query asynchronously and return a {@link CompletionStage} with a
      * result cursor.
      * 
        Example
        
      * 
              * {@code
-     * Statement statement = new Statement( "MATCH (n) WHERE n.name=$myNameParam RETURN n.age" );
-     * CompletionStage cursorStage = session.runAsync(statement);
+     * Query query = new Query( "MATCH (n) WHERE n.name=$myNameParam RETURN n.age" );
+     * CompletionStage cursorStage = session.runAsync(query);
      * }
      * 
        
      * It is not allowed to chain blocking operations on the returned {@link CompletionStage}. See class javadoc for
      * more information.
      *
-     * @param statement a Neo4j statement
+     * @param query a Neo4j query
      * @return new {@link CompletionStage} that gets completed with a result cursor when query execution is successful.
      * Stage can be completed exceptionally when error happens, e.g. connection can't be acquired from the pool.
      */
-    CompletionStage runAsync(Statement statement );
+    CompletionStage runAsync(Query query);
 }
diff --git a/driver/src/main/java/org/neo4j/driver/async/AsyncSession.java b/driver/src/main/java/org/neo4j/driver/async/AsyncSession.java
index decee1ba62..a3ece70519 100644
--- a/driver/src/main/java/org/neo4j/driver/async/AsyncSession.java
+++ b/driver/src/main/java/org/neo4j/driver/async/AsyncSession.java
@@ -25,7 +25,7 @@
 import java.util.function.Function;
 
 import org.neo4j.driver.AccessMode;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.Values;
@@ -35,15 +35,15 @@
  * Provides a context of work for database interactions.
  * 
        
  * A AsyncSession hosts a series of {@linkplain AsyncTransaction transactions}
- * carried out against a database. Within the database, all statements are
+ * carried out against a database. Within the database, all queries are
  * carried out within a transaction. Within application code, however, it is
  * not always necessary to explicitly {@link #beginTransactionAsync() begin a
- * transaction}. If a statement is {@link #runAsync} directly against a {@link
+ * transaction}. If a query is {@link #runAsync} directly against a {@link
  * AsyncSession}, the server will automatically BEGIN and
- * COMMIT that statement within its own transaction. This type
+ * COMMIT that query within its own transaction. This type
  * of transaction is known as an autocommit transaction.
  * 
        
- * Explicit transactions allow multiple statements to be committed as part of
+ * Explicit transactions allow multiple queries to be committed as part of
  * a single atomic operation and can be rolled back if necessary. They can also
  * be used to ensure causal consistency, meaning that an application
  * can run a series of queries on different members of a cluster, while
@@ -69,7 +69,7 @@
  *
  * @since 2.0
  */
-public interface AsyncSession extends AsyncStatementRunner
+public interface AsyncSession extends AsyncQueryRunner
 {
     /**
      * Begin a new explicit {@linkplain Transaction transaction}. At
@@ -210,25 +210,25 @@ public interface AsyncSession extends AsyncStatementRunner
      CompletionStage writeTransactionAsync( AsyncTransactionWork> work, TransactionConfig config );
 
     /**
-     * Run a statement asynchronously in an auto-commit transaction with the specified {@link TransactionConfig configuration} and return a
+     * Run a query asynchronously in an auto-commit transaction with the specified {@link TransactionConfig configuration} and return a
      * {@link CompletionStage} with a result cursor.
      * 
        
-     * It is not allowed to chain blocking operations on the returned {@link CompletionStage}. See class javadoc in {@link AsyncStatementRunner} for
+     * It is not allowed to chain blocking operations on the returned {@link CompletionStage}. See class javadoc in {@link AsyncQueryRunner} for
      * more information.
      *
-     * @param statement text of a Neo4j statement.
+     * @param query text of a Neo4j query.
      * @param config configuration for the new transaction.
      * @return new {@link CompletionStage} that gets completed with a result cursor when query execution is successful.
      * Stage can be completed exceptionally when error happens, e.g. connection can't be acquired from the pool.
      */
-    CompletionStage runAsync(String statement, TransactionConfig config );
+    CompletionStage runAsync(String query, TransactionConfig config );
 
     /**
-     * Run a statement asynchronously in an auto-commit transaction with the specified {@link TransactionConfig configuration} and return a
+     * Run a query asynchronously in an auto-commit transaction with the specified {@link TransactionConfig configuration} and return a
      * {@link CompletionStage} with a result cursor.
      * 
        
      * This method takes a set of parameters that will be injected into the
-     * statement by Neo4j. Using parameters is highly encouraged, it helps avoid
+     * query by Neo4j. Using parameters is highly encouraged, it helps avoid
      * dangerous cypher injection attacks and improves database performance as
      * Neo4j can re-use query plans more often.
      * 
        
@@ -255,19 +255,19 @@ public interface AsyncSession extends AsyncStatementRunner
      *             config);
      * }
      * 
    
-     * It is not allowed to chain blocking operations on the returned {@link CompletionStage}. See class javadoc in {@link AsyncStatementRunner} for
+     * It is not allowed to chain blocking operations on the returned {@link CompletionStage}. See class javadoc in {@link AsyncQueryRunner} for
      * more information.
      *
-     * @param statement text of a Neo4j statement.
-     * @param parameters input data for the statement.
+     * @param query text of a Neo4j query.
+     * @param parameters input data for the query.
      * @param config configuration for the new transaction.
      * @return new {@link CompletionStage} that gets completed with a result cursor when query execution is successful.
      * Stage can be completed exceptionally when error happens, e.g. connection can't be acquired from the pool.
      */
-    CompletionStage runAsync(String statement, Map parameters, TransactionConfig config );
+    CompletionStage runAsync(String query, Map parameters, TransactionConfig config );
 
     /**
-     * Run a statement asynchronously in an auto-commit transaction with the specified {@link TransactionConfig configuration} and return a
+     * Run a query asynchronously in an auto-commit transaction with the specified {@link TransactionConfig configuration} and return a
      * {@link CompletionStage} with a result cursor.
      * 
    Example
    
      * 
    @@ -280,19 +280,19 @@ public interface AsyncSession extends AsyncStatementRunner
      *                 .withMetadata(metadata)
      *                 .build();
      *
-     * Statement statement = new Statement( "MATCH (n) WHERE n.name=$myNameParam RETURN n.age" );
-     * CompletionStage cursorStage = session.runAsync(statement, config);
+     * Query query = new Query( "MATCH (n) WHERE n.name=$myNameParam RETURN n.age" );
+     * CompletionStage cursorStage = session.runAsync(query, config);
      * }
      * 
    
-     * It is not allowed to chain blocking operations on the returned {@link CompletionStage}. See class javadoc in {@link AsyncStatementRunner} for
+     * It is not allowed to chain blocking operations on the returned {@link CompletionStage}. See class javadoc in {@link AsyncQueryRunner} for
      * more information.
      *
-     * @param statement a Neo4j statement.
+     * @param query a Neo4j query.
      * @param config configuration for the new transaction.
      * @return new {@link CompletionStage} that gets completed with a result cursor when query execution is successful.
      * Stage can be completed exceptionally when error happens, e.g. connection can't be acquired from the pool.
      */
-    CompletionStage runAsync(Statement statement, TransactionConfig config );
+    CompletionStage runAsync(Query query, TransactionConfig config );
 
     /**
      * Return the bookmark received following the last completed
@@ -309,8 +309,8 @@ public interface AsyncSession extends AsyncStatementRunner
      * very low cost.
      * 
    
      * This operation is asynchronous and returns a {@link CompletionStage}. Stage is completed when all outstanding
-     * statements in the session have completed, meaning any writes you performed are guaranteed to be durably stored.
-     * It might be completed exceptionally when there are unconsumed errors from previous statements or transactions.
+     * queries in the session have completed, meaning any writes you performed are guaranteed to be durably stored.
+     * It might be completed exceptionally when there are unconsumed errors from previous queries or transactions.
      *
      * @return a {@link CompletionStage completion stage} that represents the asynchronous close.
      */
diff --git a/driver/src/main/java/org/neo4j/driver/async/AsyncTransaction.java b/driver/src/main/java/org/neo4j/driver/async/AsyncTransaction.java
index 4daaa77568..d42f4d0541 100644
--- a/driver/src/main/java/org/neo4j/driver/async/AsyncTransaction.java
+++ b/driver/src/main/java/org/neo4j/driver/async/AsyncTransaction.java
@@ -24,8 +24,8 @@
 import java.util.function.Function;
 
 import org.neo4j.driver.Session;
-import org.neo4j.driver.Statement;
-import org.neo4j.driver.StatementRunner;
+import org.neo4j.driver.Query;
+import org.neo4j.driver.QueryRunner;
 
 /**
  * Logical container for an atomic unit of work.
@@ -49,13 +49,13 @@
  * }
  * 
    
  * Async calls are: {@link #commitAsync()}, {@link #rollbackAsync()} and various overloads of
- * {@link #runAsync(Statement)}.
+ * {@link #runAsync(Query)}.
  *
  * @see Session#run
- * @see StatementRunner
+ * @see QueryRunner
  * @since 2.0
  */
-public interface AsyncTransaction extends AsyncStatementRunner
+public interface AsyncTransaction extends AsyncQueryRunner
 {
     /**
      * Commit this transaction in asynchronous fashion. This operation is typically executed as part of the
diff --git a/driver/src/main/java/org/neo4j/driver/async/ResultCursor.java b/driver/src/main/java/org/neo4j/driver/async/ResultCursor.java
index b06ad4c8e0..3ae5a2bfb4 100644
--- a/driver/src/main/java/org/neo4j/driver/async/ResultCursor.java
+++ b/driver/src/main/java/org/neo4j/driver/async/ResultCursor.java
@@ -32,22 +32,22 @@
 import org.neo4j.driver.summary.ResultSummary;
 
 /**
- * The result of asynchronous execution of a Cypher statement, conceptually an asynchronous stream of
+ * The result of asynchronous execution of a Cypher query, conceptually an asynchronous stream of
  * {@link Record records}.
  * 
    
  * Result can be eagerly fetched in a list using {@link #listAsync()} or navigated lazily using
  * {@link #forEachAsync(Consumer)} or {@link #nextAsync()}.
  * 
    
- * Results are valid until the next statement is run or until the end of the current transaction,
- * whichever comes first. To keep a result around while further statements are run, or to use a result outside the scope
+ * Results are valid until the next query is run or until the end of the current transaction,
+ * whichever comes first. To keep a result around while further queries are run, or to use a result outside the scope
  * of the current transaction, see {@link #listAsync()}.
  * 
    Important note on semantics
    
  * 
    
  * In order to handle very large results, and to minimize memory overhead and maximize
- * performance, results are retrieved lazily. Please see {@link AsyncStatementRunner} for
+ * performance, results are retrieved lazily. Please see {@link AsyncQueryRunner} for
  * important details on the effects of this.
  * 
    
- * The short version is that, if you want a hard guarantee that the underlying statement
+ * The short version is that, if you want a hard guarantee that the underlying query
  * has completed, you need to either call {@link AsyncTransaction#commitAsync()} on the {@link AsyncTransaction transaction}
  * or {@link AsyncSession#closeAsync()} on the {@link AsyncSession session} that created this result, or you need to use
  * the result.
@@ -124,8 +124,8 @@ public interface ResultCursor
      * This can be used if you want to iterate over the stream multiple times or to store the
      * whole result for later use.
      * 
    
-     * Note that this method can only be used if you know that the statement that
-     * yielded this result returns a finite stream. Some statements can yield
+     * Note that this method can only be used if you know that the query that
+     * yielded this result returns a finite stream. Some queries can yield
      * infinite results, in which case calling this method will lead to running
      * out of memory.
      * 
    
@@ -141,8 +141,8 @@ public interface ResultCursor
      * This can be used if you want to iterate over the stream multiple times or to store the
      * whole result for later use.
      * 
    
-     * Note that this method can only be used if you know that the statement that
-     * yielded this result returns a finite stream. Some statements can yield
+     * Note that this method can only be used if you know that the query that
+     * yielded this result returns a finite stream. Some queries can yield
      * infinite results, in which case calling this method will lead to running
      * out of memory.
      * 
    
diff --git a/driver/src/main/java/org/neo4j/driver/exceptions/ResultConsumedException.java b/driver/src/main/java/org/neo4j/driver/exceptions/ResultConsumedException.java
index f250b22388..10ac4c1b5e 100644
--- a/driver/src/main/java/org/neo4j/driver/exceptions/ResultConsumedException.java
+++ b/driver/src/main/java/org/neo4j/driver/exceptions/ResultConsumedException.java
@@ -18,12 +18,12 @@
  */
 package org.neo4j.driver.exceptions;
 
-import org.neo4j.driver.StatementRunner;
+import org.neo4j.driver.QueryRunner;
 
 /**
  * A user is trying to access resources that are no longer valid due to
  * the resources have already been consumed or
- * the {@link StatementRunner} where the resources are created has already been closed.
+ * the {@link QueryRunner} where the resources are created has already been closed.
  */
 public class ResultConsumedException extends ClientException
 {
diff --git a/driver/src/main/java/org/neo4j/driver/internal/AbstractStatementRunner.java b/driver/src/main/java/org/neo4j/driver/internal/AbstractQueryRunner.java
similarity index 66%
rename from driver/src/main/java/org/neo4j/driver/internal/AbstractStatementRunner.java
rename to driver/src/main/java/org/neo4j/driver/internal/AbstractQueryRunner.java
index 0acd3894e5..683e26f912 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/AbstractStatementRunner.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/AbstractQueryRunner.java
@@ -21,38 +21,38 @@
 import java.util.Map;
 
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Result;
-import org.neo4j.driver.StatementRunner;
+import org.neo4j.driver.QueryRunner;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.Values;
 import org.neo4j.driver.internal.util.Extract;
 import org.neo4j.driver.internal.value.MapValue;
 
-public abstract class AbstractStatementRunner implements StatementRunner
+public abstract class AbstractQueryRunner implements QueryRunner
 {
     @Override
-    public final Result run(String statementTemplate, Value parameters )
+    public final Result run(String query, Value parameters )
     {
-        return run( new Statement( statementTemplate, parameters ) );
+        return run( new Query( query, parameters ) );
     }
 
     @Override
-    public final Result run(String statementTemplate, Map statementParameters )
+    public final Result run(String query, Map parameters)
     {
-        return run( statementTemplate, parameters( statementParameters ) );
+        return run(query, parameters(parameters) );
     }
 
     @Override
-    public final Result run(String statementTemplate, Record statementParameters )
+    public final Result run(String query, Record parameters)
     {
-        return run( statementTemplate, parameters( statementParameters ) );
+        return run(query, parameters(parameters) );
     }
 
     @Override
-    public final Result run(String statementText )
+    public final Result run(String query)
     {
-        return run( statementText, Values.EmptyMap );
+        return run(query, Values.EmptyMap );
     }
 
     public static Value parameters( Record record )
diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java b/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java
index 3fcc63a3cb..15c4d4a359 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java
@@ -22,8 +22,8 @@
 
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Bookmark;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.TransactionConfig;
@@ -36,7 +36,7 @@
 
 import static java.util.Collections.emptyMap;
 
-public class InternalSession extends AbstractStatementRunner implements Session
+public class InternalSession extends AbstractQueryRunner implements Session
 {
     private final NetworkSession session;
 
@@ -46,27 +46,27 @@ public InternalSession( NetworkSession session )
     }
 
     @Override
-    public Result run(Statement statement )
+    public Result run(Query query)
     {
-        return run( statement, TransactionConfig.empty() );
+        return run(query, TransactionConfig.empty() );
     }
 
     @Override
-    public Result run(String statement, TransactionConfig config )
+    public Result run(String query, TransactionConfig config )
     {
-        return run( statement, emptyMap(), config );
+        return run(query, emptyMap(), config );
     }
 
     @Override
-    public Result run(String statement, Map parameters, TransactionConfig config )
+    public Result run(String query, Map parameters, TransactionConfig config )
     {
-        return run( new Statement( statement, parameters ), config );
+        return run( new Query(query, parameters ), config );
     }
 
     @Override
-    public Result run(Statement statement, TransactionConfig config )
+    public Result run(Query query, TransactionConfig config )
     {
-        ResultCursor cursor = Futures.blockingGet( session.runAsync( statement, config, false ),
+        ResultCursor cursor = Futures.blockingGet( session.runAsync(query, config, false ),
                 () -> terminateConnectionOnThreadInterrupt( "Thread interrupted while running query in session" ) );
 
         // query executed, it is safe to obtain a connection in a blocking way
diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalTransaction.java b/driver/src/main/java/org/neo4j/driver/internal/InternalTransaction.java
index cd37d832e2..6e78377f73 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/InternalTransaction.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/InternalTransaction.java
@@ -18,14 +18,14 @@
  */
 package org.neo4j.driver.internal;
 
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.internal.async.UnmanagedTransaction;
 import org.neo4j.driver.internal.util.Futures;
 
-public class InternalTransaction extends AbstractStatementRunner implements Transaction
+public class InternalTransaction extends AbstractQueryRunner implements Transaction
 {
     private final UnmanagedTransaction tx;
     public InternalTransaction( UnmanagedTransaction tx )
@@ -55,9 +55,9 @@ public void close()
     }
 
     @Override
-    public Result run(Statement statement )
+    public Result run(Query query)
     {
-        ResultCursor cursor = Futures.blockingGet( tx.runAsync( statement, false ),
+        ResultCursor cursor = Futures.blockingGet( tx.runAsync(query, false ),
                 () -> terminateConnectionOnThreadInterrupt( "Thread interrupted while running query in transaction" ) );
         return new InternalResult( tx.connection(), cursor );
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/AsyncAbstractStatementRunner.java b/driver/src/main/java/org/neo4j/driver/internal/async/AsyncAbstractQueryRunner.java
similarity index 51%
rename from driver/src/main/java/org/neo4j/driver/internal/async/AsyncAbstractStatementRunner.java
rename to driver/src/main/java/org/neo4j/driver/internal/async/AsyncAbstractQueryRunner.java
index b3a8f5308d..ed2fc0a737 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/AsyncAbstractStatementRunner.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/AsyncAbstractQueryRunner.java
@@ -22,37 +22,37 @@
 import java.util.concurrent.CompletionStage;
 
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.Values;
-import org.neo4j.driver.async.AsyncStatementRunner;
+import org.neo4j.driver.async.AsyncQueryRunner;
 import org.neo4j.driver.async.ResultCursor;
 
-import static org.neo4j.driver.internal.AbstractStatementRunner.parameters;
+import static org.neo4j.driver.internal.AbstractQueryRunner.parameters;
 
-public abstract class AsyncAbstractStatementRunner implements AsyncStatementRunner
+public abstract class AsyncAbstractQueryRunner implements AsyncQueryRunner
 {
     @Override
-    public final CompletionStage runAsync(String statementTemplate, Value parameters )
+    public final CompletionStage runAsync(String query, Value parameters )
     {
-        return runAsync( new Statement( statementTemplate, parameters ) );
+        return runAsync( new Query(query, parameters ) );
     }
 
     @Override
-    public final CompletionStage runAsync(String statementTemplate, Map statementParameters )
+    public final CompletionStage runAsync(String query, Map parameters)
     {
-        return runAsync( statementTemplate, parameters( statementParameters ) );
+        return runAsync(query, parameters(parameters) );
     }
 
     @Override
-    public final CompletionStage runAsync(String statementTemplate, Record statementParameters )
+    public final CompletionStage runAsync(String query, Record parameters)
     {
-        return runAsync( statementTemplate, parameters( statementParameters ) );
+        return runAsync(query, parameters(parameters) );
     }
 
     @Override
-    public final CompletionStage runAsync(String statementText )
+    public final CompletionStage runAsync(String query)
     {
-        return runAsync( statementText, Values.EmptyMap );
+        return runAsync(query, Values.EmptyMap );
     }
 }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncSession.java b/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncSession.java
index f7b8a39d11..c634141fcf 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncSession.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncSession.java
@@ -23,7 +23,7 @@
 import java.util.concurrent.CompletionStage;
 
 import org.neo4j.driver.AccessMode;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.async.AsyncSession;
 import org.neo4j.driver.async.AsyncTransaction;
@@ -36,7 +36,7 @@
 import static org.neo4j.driver.internal.util.Futures.completedWithNull;
 import static org.neo4j.driver.internal.util.Futures.failedFuture;
 
-public class InternalAsyncSession extends AsyncAbstractStatementRunner implements AsyncSession
+public class InternalAsyncSession extends AsyncAbstractQueryRunner implements AsyncSession
 {
     private final NetworkSession session;
 
@@ -46,27 +46,27 @@ public InternalAsyncSession( NetworkSession session )
     }
 
     @Override
-    public CompletionStage runAsync(Statement statement )
+    public CompletionStage runAsync(Query query)
     {
-        return runAsync( statement, TransactionConfig.empty() );
+        return runAsync(query, TransactionConfig.empty() );
     }
 
     @Override
-    public CompletionStage runAsync(String statement, TransactionConfig config )
+    public CompletionStage runAsync(String query, TransactionConfig config )
     {
-        return runAsync( statement, emptyMap(), config );
+        return runAsync(query, emptyMap(), config );
     }
 
     @Override
-    public CompletionStage runAsync(String statement, Map parameters, TransactionConfig config )
+    public CompletionStage runAsync(String query, Map parameters, TransactionConfig config )
     {
-        return runAsync( new Statement( statement, parameters ), config );
+        return runAsync( new Query(query, parameters ), config );
     }
 
     @Override
-    public CompletionStage runAsync(Statement statement, TransactionConfig config )
+    public CompletionStage runAsync(Query query, TransactionConfig config )
     {
-        return session.runAsync( statement, config, true );
+        return session.runAsync(query, config, true );
     }
 
     @Override
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncTransaction.java b/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncTransaction.java
index 5bf1467b11..bf8a14577b 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncTransaction.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncTransaction.java
@@ -20,11 +20,11 @@
 
 import java.util.concurrent.CompletionStage;
 
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.async.AsyncTransaction;
 import org.neo4j.driver.async.ResultCursor;
 
-public class InternalAsyncTransaction extends AsyncAbstractStatementRunner implements AsyncTransaction
+public class InternalAsyncTransaction extends AsyncAbstractQueryRunner implements AsyncTransaction
 {
     private final UnmanagedTransaction tx;
     public InternalAsyncTransaction( UnmanagedTransaction tx )
@@ -45,9 +45,9 @@ public CompletionStage rollbackAsync()
     }
 
     @Override
-    public CompletionStage runAsync(Statement statement )
+    public CompletionStage runAsync(Query query)
     {
-        return tx.runAsync( statement, true );
+        return tx.runAsync(query, true );
     }
 
     public void markTerminated()
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/NetworkSession.java b/driver/src/main/java/org/neo4j/driver/internal/async/NetworkSession.java
index ac40a8c6bb..3a33538516 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/NetworkSession.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/NetworkSession.java
@@ -26,7 +26,7 @@
 import org.neo4j.driver.Bookmark;
 import org.neo4j.driver.Logger;
 import org.neo4j.driver.Logging;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
@@ -76,19 +76,19 @@ public NetworkSession( ConnectionProvider connectionProvider, RetryLogic retryLo
         this.fetchSize = fetchSize;
     }
 
-    public CompletionStage runAsync(Statement statement, TransactionConfig config, boolean waitForRunResponse )
+    public CompletionStage runAsync(Query query, TransactionConfig config, boolean waitForRunResponse )
     {
         CompletionStage newResultCursorStage =
-                buildResultCursorFactory( statement, config, waitForRunResponse ).thenCompose( ResultCursorFactory::asyncResult );
+                buildResultCursorFactory(query, config, waitForRunResponse ).thenCompose( ResultCursorFactory::asyncResult );
 
         resultCursorStage = newResultCursorStage.exceptionally( error -> null );
         return newResultCursorStage.thenApply( cursor -> cursor ); // convert the return type
     }
 
-    public CompletionStage runRx(Statement statement, TransactionConfig config )
+    public CompletionStage runRx(Query query, TransactionConfig config )
     {
         CompletionStage newResultCursorStage =
-                buildResultCursorFactory( statement, config, true ).thenCompose( ResultCursorFactory::rxResult );
+                buildResultCursorFactory(query, config, true ).thenCompose( ResultCursorFactory::rxResult );
 
         resultCursorStage = newResultCursorStage.exceptionally( error -> null );
         return newResultCursorStage;
@@ -223,7 +223,7 @@ protected CompletionStage currentConnectionIsOpen()
                 connection.isOpen() ); // and it's still open
     }
 
-    private CompletionStage buildResultCursorFactory(Statement statement, TransactionConfig config, boolean waitForRunResponse )
+    private CompletionStage buildResultCursorFactory(Query query, TransactionConfig config, boolean waitForRunResponse )
     {
         ensureSessionIsOpen();
 
@@ -233,7 +233,7 @@ private CompletionStage buildResultCursorFactory(Statement
                     try
                     {
                         ResultCursorFactory factory = connection.protocol()
-                                .runInAutoCommitTransaction( connection, statement, bookmarkHolder, config, waitForRunResponse, fetchSize );
+                                .runInAutoCommitTransaction( connection, query, bookmarkHolder, config, waitForRunResponse, fetchSize );
                         return completedFuture( factory );
                     }
                     catch ( Throwable e )
@@ -307,7 +307,7 @@ private CompletionStage closeTransactionAndReleaseConnection()
 
     private CompletionStage ensureNoOpenTxBeforeRunningQuery()
     {
-        return ensureNoOpenTx( "Statements cannot be run directly on a session with an open transaction; " +
+        return ensureNoOpenTx( "Queries cannot be run directly on a session with an open transaction; " +
                                "either run from within the transaction or use a different session." );
     }
 
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/UnmanagedTransaction.java b/driver/src/main/java/org/neo4j/driver/internal/async/UnmanagedTransaction.java
index 462cc5a9f8..fedf786864 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/UnmanagedTransaction.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/UnmanagedTransaction.java
@@ -23,8 +23,8 @@
 import java.util.function.BiFunction;
 
 import org.neo4j.driver.Bookmark;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
@@ -138,20 +138,20 @@ else if ( state == State.ROLLED_BACK )
         }
     }
 
-    public CompletionStage runAsync(Statement statement, boolean waitForRunResponse )
+    public CompletionStage runAsync(Query query, boolean waitForRunResponse )
     {
         ensureCanRunQueries();
         CompletionStage cursorStage =
-                protocol.runInExplicitTransaction( connection, statement, this, waitForRunResponse, fetchSize ).asyncResult();
+                protocol.runInExplicitTransaction( connection, query, this, waitForRunResponse, fetchSize ).asyncResult();
         resultCursors.add( cursorStage );
         return cursorStage.thenApply( cursor -> cursor );
     }
 
-    public CompletionStage runRx(Statement statement )
+    public CompletionStage runRx(Query query)
     {
         ensureCanRunQueries();
         CompletionStage cursorStage =
-                protocol.runInExplicitTransaction( connection, statement, this, false, fetchSize ).rxResult();
+                protocol.runInExplicitTransaction( connection, query, this, false, fetchSize ).rxResult();
         resultCursors.add( cursorStage );
         return cursorStage;
     }
@@ -175,15 +175,15 @@ private void ensureCanRunQueries()
     {
         if ( state == State.COMMITTED )
         {
-            throw new ClientException( "Cannot run more statements in this transaction, it has been committed" );
+            throw new ClientException( "Cannot run more queries in this transaction, it has been committed" );
         }
         else if ( state == State.ROLLED_BACK )
         {
-            throw new ClientException( "Cannot run more statements in this transaction, it has been rolled back" );
+            throw new ClientException( "Cannot run more queries in this transaction, it has been rolled back" );
         }
         else if ( state == State.TERMINATED )
         {
-            throw new ClientException( "Cannot run more statements in this transaction, " +
+            throw new ClientException( "Cannot run more queries in this transaction, " +
                     "it has either experienced an fatal error or was explicitly terminated" );
         }
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/MultiDatabasesRoutingProcedureRunner.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/MultiDatabasesRoutingProcedureRunner.java
index bf5644915c..1d7c584fec 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cluster/MultiDatabasesRoutingProcedureRunner.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cluster/MultiDatabasesRoutingProcedureRunner.java
@@ -22,7 +22,7 @@
 
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Bookmark;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.internal.BookmarkHolder;
 import org.neo4j.driver.internal.DatabaseName;
@@ -51,12 +51,12 @@ BookmarkHolder bookmarkHolder( Bookmark bookmark )
     }
 
     @Override
-    Statement procedureStatement( ServerVersion serverVersion, DatabaseName databaseName )
+    Query procedureQuery(ServerVersion serverVersion, DatabaseName databaseName )
     {
         HashMap map = new HashMap<>();
         map.put( ROUTING_CONTEXT, value( context.asMap() ) );
         map.put( DATABASE_NAME, value( (Object) databaseName.databaseName().orElse( null ) ) );
-        return new Statement( MULTI_DB_GET_ROUTING_TABLE, value( map ) );
+        return new Query( MULTI_DB_GET_ROUTING_TABLE, value( map ) );
     }
 
     @Override
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProvider.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProvider.java
index e34a5d50de..1dbbefaac1 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProvider.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProvider.java
@@ -24,7 +24,7 @@
 
 import org.neo4j.driver.Bookmark;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.exceptions.ProtocolException;
 import org.neo4j.driver.exceptions.value.ValueException;
 import org.neo4j.driver.internal.DatabaseName;
@@ -120,7 +120,7 @@ private ClusterComposition processRoutingResponse( RoutingProcedureResponse resp
 
     private static String invokedProcedureString( RoutingProcedureResponse response )
     {
-        Statement statement = response.procedure();
-        return statement.text() + " " + statement.parameters();
+        Query query = response.procedure();
+        return query.text() + " " + query.parameters();
     }
 }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureResponse.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureResponse.java
index 8997ad13f2..ff307d3c75 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureResponse.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureResponse.java
@@ -20,26 +20,26 @@
 
 import java.util.List;
 
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 
 public class RoutingProcedureResponse
 {
-    private final Statement procedure;
+    private final Query procedure;
     private final List records;
     private final Throwable error;
 
-    public RoutingProcedureResponse( Statement procedure, List records )
+    public RoutingProcedureResponse(Query procedure, List records )
     {
         this( procedure, records, null );
     }
 
-    public RoutingProcedureResponse( Statement procedure, Throwable error )
+    public RoutingProcedureResponse(Query procedure, Throwable error )
     {
         this( procedure, null, error );
     }
 
-    private RoutingProcedureResponse( Statement procedure, List records, Throwable error )
+    private RoutingProcedureResponse(Query procedure, List records, Throwable error )
     {
         this.procedure = procedure;
         this.records = records;
@@ -51,7 +51,7 @@ public boolean isSuccess()
         return records != null;
     }
 
-    public Statement procedure()
+    public Query procedure()
     {
         return procedure;
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureRunner.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureRunner.java
index 15ec1a4922..ce0df69130 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureRunner.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureRunner.java
@@ -24,8 +24,8 @@
 
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Bookmark;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
@@ -56,7 +56,7 @@ public RoutingProcedureRunner( RoutingContext context )
     public CompletionStage run( Connection connection, DatabaseName databaseName, Bookmark bookmark )
     {
         DirectConnection delegate = connection( connection );
-        Statement procedure = procedureStatement( connection.serverVersion(), databaseName );
+        Query procedure = procedureQuery( connection.serverVersion(), databaseName );
         BookmarkHolder bookmarkHolder = bookmarkHolder( bookmark );
         return runProcedure( delegate, procedure, bookmarkHolder )
                 .thenCompose( records -> releaseConnection( delegate, records ) )
@@ -68,7 +68,7 @@ DirectConnection connection( Connection connection )
         return new DirectConnection( connection, defaultDatabase(), AccessMode.WRITE );
     }
 
-    Statement procedureStatement( ServerVersion serverVersion, DatabaseName databaseName )
+    Query procedureQuery(ServerVersion serverVersion, DatabaseName databaseName )
     {
         if ( databaseName.databaseName().isPresent() )
         {
@@ -76,7 +76,7 @@ Statement procedureStatement( ServerVersion serverVersion, DatabaseName database
                     "Refreshing routing table for multi-databases is not supported in server version lower than 4.0. " +
                             "Current server version: %s. Database name: '%s'", serverVersion, databaseName.description() ) );
         }
-        return new Statement( GET_ROUTING_TABLE, parameters( ROUTING_CONTEXT, context.asMap() ) );
+        return new Query( GET_ROUTING_TABLE, parameters( ROUTING_CONTEXT, context.asMap() ) );
     }
 
     BookmarkHolder bookmarkHolder( Bookmark ignored )
@@ -84,7 +84,7 @@ BookmarkHolder bookmarkHolder( Bookmark ignored )
         return BookmarkHolder.NO_OP;
     }
 
-    CompletionStage> runProcedure( Connection connection, Statement procedure, BookmarkHolder bookmarkHolder )
+    CompletionStage> runProcedure(Connection connection, Query procedure, BookmarkHolder bookmarkHolder )
     {
         return connection.protocol()
                 .runInAutoCommitTransaction( connection, procedure, bookmarkHolder, TransactionConfig.empty(), true, UNLIMITED_FETCH_SIZE )
@@ -101,8 +101,8 @@ private CompletionStage> releaseConnection( Connection connection,
         return connection.release().thenApply( ignore -> records );
     }
 
-    private static RoutingProcedureResponse processProcedureResponse( Statement procedure, List records,
-            Throwable error )
+    private static RoutingProcedureResponse processProcedureResponse(Query procedure, List records,
+                                                                     Throwable error )
     {
         Throwable cause = Futures.completionExceptionCause( error );
         if ( cause != null )
@@ -115,7 +115,7 @@ private static RoutingProcedureResponse processProcedureResponse( Statement proc
         }
     }
 
-    private static RoutingProcedureResponse handleError( Statement procedure, Throwable error )
+    private static RoutingProcedureResponse handleError(Query procedure, Throwable error )
     {
         if ( error instanceof ClientException )
         {
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursorImpl.java b/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursorImpl.java
index fe33c55795..030e9b3561 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursorImpl.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursorImpl.java
@@ -45,7 +45,7 @@ public AsyncResultCursorImpl(RunResponseHandler runHandler, PullAllResponseHandl
     @Override
     public List keys()
     {
-        return runHandler.statementKeys();
+        return runHandler.queryKeys();
     }
 
     @Override
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/RxResultCursorImpl.java b/driver/src/main/java/org/neo4j/driver/internal/cursor/RxResultCursorImpl.java
index 71d74d4c65..0c1982d90f 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cursor/RxResultCursorImpl.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cursor/RxResultCursorImpl.java
@@ -65,7 +65,7 @@ public RxResultCursorImpl(Throwable runError, RunResponseHandler runHandler, Pul
     @Override
     public List keys()
     {
-        return runHandler.statementKeys();
+        return runHandler.queryKeys();
     }
 
     @Override
diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/LegacyPullAllResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/LegacyPullAllResponseHandler.java
index 36d507d544..b072bb85cc 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/handlers/LegacyPullAllResponseHandler.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/handlers/LegacyPullAllResponseHandler.java
@@ -27,8 +27,8 @@
 import java.util.concurrent.CompletionStage;
 import java.util.function.Function;
 
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.internal.InternalRecord;
 import org.neo4j.driver.internal.messaging.request.PullAllMessage;
@@ -54,7 +54,7 @@ public class LegacyPullAllResponseHandler implements PullAllResponseHandler
     static final int RECORD_BUFFER_LOW_WATERMARK = Integer.getInteger( "recordBufferLowWatermark", 300 );
     static final int RECORD_BUFFER_HIGH_WATERMARK = Integer.getInteger( "recordBufferHighWatermark", 1000 );
 
-    private final Statement statement;
+    private final Query query;
     private final RunResponseHandler runResponseHandler;
     protected final MetadataExtractor metadataExtractor;
     protected final Connection connection;
@@ -72,10 +72,10 @@ public class LegacyPullAllResponseHandler implements PullAllResponseHandler
     private CompletableFuture recordFuture;
     private CompletableFuture failureFuture;
 
-    public LegacyPullAllResponseHandler( Statement statement, RunResponseHandler runResponseHandler, Connection connection, MetadataExtractor metadataExtractor,
-            PullResponseCompletionListener completionListener )
+    public LegacyPullAllResponseHandler(Query query, RunResponseHandler runResponseHandler, Connection connection, MetadataExtractor metadataExtractor,
+                                        PullResponseCompletionListener completionListener )
     {
-        this.statement = requireNonNull( statement );
+        this.query = requireNonNull(query);
         this.runResponseHandler = requireNonNull( runResponseHandler );
         this.metadataExtractor = requireNonNull( metadataExtractor );
         this.connection = requireNonNull( connection );
@@ -134,7 +134,7 @@ public synchronized void onRecord( Value[] fields )
         }
         else
         {
-            Record record = new InternalRecord( runResponseHandler.statementKeys(), fields );
+            Record record = new InternalRecord( runResponseHandler.queryKeys(), fields );
             enqueueRecord( record );
             completeRecordFuture( record );
         }
@@ -335,7 +335,7 @@ private boolean completeFailureFuture( Throwable error )
     private ResultSummary extractResultSummary( Map metadata )
     {
         long resultAvailableAfter = runResponseHandler.resultAvailableAfter();
-        return metadataExtractor.extractSummary( statement, connection, resultAvailableAfter, metadata );
+        return metadataExtractor.extractSummary(query, connection, resultAvailableAfter, metadata );
     }
 
     private void enableAutoRead()
diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/PullHandlers.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/PullHandlers.java
index a26b00fcb4..b3c4bd7ba8 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/handlers/PullHandlers.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/handlers/PullHandlers.java
@@ -18,7 +18,7 @@
  */
 package org.neo4j.driver.internal.handlers;
 
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.internal.BookmarkHolder;
 import org.neo4j.driver.internal.async.UnmanagedTransaction;
 import org.neo4j.driver.internal.handlers.pulln.AutoPullResponseHandler;
@@ -30,37 +30,37 @@
 
 public class PullHandlers
 {
-    public static PullAllResponseHandler newBoltV1PullAllHandler( Statement statement, RunResponseHandler runHandler,
+    public static PullAllResponseHandler newBoltV1PullAllHandler(Query query, RunResponseHandler runHandler,
             Connection connection, UnmanagedTransaction tx )
     {
         PullResponseCompletionListener completionListener = createPullResponseCompletionListener( connection, BookmarkHolder.NO_OP, tx );
 
-        return new LegacyPullAllResponseHandler( statement, runHandler, connection, BoltProtocolV1.METADATA_EXTRACTOR, completionListener );
+        return new LegacyPullAllResponseHandler(query, runHandler, connection, BoltProtocolV1.METADATA_EXTRACTOR, completionListener );
     }
 
-    public static PullAllResponseHandler newBoltV3PullAllHandler( Statement statement, RunResponseHandler runHandler, Connection connection,
+    public static PullAllResponseHandler newBoltV3PullAllHandler(Query query, RunResponseHandler runHandler, Connection connection,
             BookmarkHolder bookmarkHolder, UnmanagedTransaction tx )
     {
         PullResponseCompletionListener completionListener = createPullResponseCompletionListener( connection, bookmarkHolder, tx );
 
-        return new LegacyPullAllResponseHandler( statement, runHandler, connection, BoltProtocolV3.METADATA_EXTRACTOR, completionListener );
+        return new LegacyPullAllResponseHandler(query, runHandler, connection, BoltProtocolV3.METADATA_EXTRACTOR, completionListener );
     }
 
-    public static PullAllResponseHandler newBoltV4AutoPullHandler(Statement statement, RunResponseHandler runHandler, Connection connection,
+    public static PullAllResponseHandler newBoltV4AutoPullHandler(Query query, RunResponseHandler runHandler, Connection connection,
                                                                   BookmarkHolder bookmarkHolder, UnmanagedTransaction tx, long fetchSize )
     {
         PullResponseCompletionListener completionListener = createPullResponseCompletionListener( connection, bookmarkHolder, tx );
 
-        return new AutoPullResponseHandler( statement, runHandler, connection, BoltProtocolV3.METADATA_EXTRACTOR, completionListener, fetchSize );
+        return new AutoPullResponseHandler(query, runHandler, connection, BoltProtocolV3.METADATA_EXTRACTOR, completionListener, fetchSize );
     }
 
 
-    public static PullResponseHandler newBoltV4BasicPullHandler( Statement statement, RunResponseHandler runHandler, Connection connection,
+    public static PullResponseHandler newBoltV4BasicPullHandler(Query query, RunResponseHandler runHandler, Connection connection,
             BookmarkHolder bookmarkHolder, UnmanagedTransaction tx )
     {
         PullResponseCompletionListener completionListener = createPullResponseCompletionListener( connection, bookmarkHolder, tx );
 
-        return new BasicPullResponseHandler( statement, runHandler, connection, BoltProtocolV3.METADATA_EXTRACTOR, completionListener );
+        return new BasicPullResponseHandler(query, runHandler, connection, BoltProtocolV3.METADATA_EXTRACTOR, completionListener );
     }
 
     private static PullResponseCompletionListener createPullResponseCompletionListener( Connection connection, BookmarkHolder bookmarkHolder,
diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/RunResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/RunResponseHandler.java
index d9eb994e64..04fec27062 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/handlers/RunResponseHandler.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/handlers/RunResponseHandler.java
@@ -32,9 +32,9 @@ public class RunResponseHandler implements ResponseHandler
 {
     private final CompletableFuture runCompletedFuture;
     private final MetadataExtractor metadataExtractor;
-    private long statementId = MetadataExtractor.ABSENT_QUERY_ID;
+    private long queryId = MetadataExtractor.ABSENT_QUERY_ID;
 
-    private List statementKeys = emptyList();
+    private List queryKeys = emptyList();
     private long resultAvailableAfter = -1;
 
     public RunResponseHandler( MetadataExtractor metadataExtractor )
@@ -51,9 +51,9 @@ public RunResponseHandler( CompletableFuture runCompletedFuture, Meta
     @Override
     public void onSuccess( Map metadata )
     {
-        statementKeys = metadataExtractor.extractStatementKeys( metadata );
+        queryKeys = metadataExtractor.extractQueryKeys( metadata );
         resultAvailableAfter = metadataExtractor.extractResultAvailableAfter( metadata );
-        statementId = metadataExtractor.extractQueryId( metadata );
+        queryId = metadataExtractor.extractQueryId( metadata );
 
         completeRunFuture( null );
     }
@@ -70,9 +70,9 @@ public void onRecord( Value[] fields )
         throw new UnsupportedOperationException();
     }
 
-    public List statementKeys()
+    public List queryKeys()
     {
-        return statementKeys;
+        return queryKeys;
     }
 
     public long resultAvailableAfter()
@@ -80,15 +80,15 @@ public long resultAvailableAfter()
         return resultAvailableAfter;
     }
 
-    public long statementId()
+    public long queryId()
     {
-        return statementId;
+        return queryId;
     }
 
     /**
      * Complete the given future with error if the future was failed.
      * Future is never completed exceptionally.
-     * Async API needs to wait for RUN because it needs to access statement keys.
+     * Async API needs to wait for RUN because it needs to access query keys.
      * Reactive API needs to know if RUN failed by checking the error.
      */
     private void completeRunFuture( Throwable error )
diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/AutoPullResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/AutoPullResponseHandler.java
index 65eed3f086..1c2c88f476 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/AutoPullResponseHandler.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/AutoPullResponseHandler.java
@@ -26,8 +26,8 @@
 import java.util.concurrent.CompletionStage;
 import java.util.function.Function;
 
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.internal.handlers.PullAllResponseHandler;
 import org.neo4j.driver.internal.handlers.PullResponseCompletionListener;
 import org.neo4j.driver.internal.handlers.RunResponseHandler;
@@ -59,10 +59,10 @@ public class AutoPullResponseHandler extends BasicPullResponseHandler implements
     private CompletableFuture recordFuture;
     private CompletableFuture summaryFuture;
 
-    public AutoPullResponseHandler( Statement statement, RunResponseHandler runResponseHandler, Connection connection, MetadataExtractor metadataExtractor,
-            PullResponseCompletionListener completionListener, long fetchSize )
+    public AutoPullResponseHandler(Query query, RunResponseHandler runResponseHandler, Connection connection, MetadataExtractor metadataExtractor,
+                                   PullResponseCompletionListener completionListener, long fetchSize )
     {
-        super( statement, runResponseHandler, connection, metadataExtractor, completionListener );
+        super(query, runResponseHandler, connection, metadataExtractor, completionListener );
         this.fetchSize = fetchSize;
         installRecordAndSummaryConsumers();
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/BasicPullResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/BasicPullResponseHandler.java
index 29eaee281a..233d0a326d 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/BasicPullResponseHandler.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/BasicPullResponseHandler.java
@@ -21,8 +21,8 @@
 import java.util.Map;
 import java.util.function.BiConsumer;
 
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.internal.InternalRecord;
 import org.neo4j.driver.internal.handlers.PullResponseCompletionListener;
@@ -55,7 +55,7 @@
  */
 public class BasicPullResponseHandler implements PullResponseHandler
 {
-    private final Statement statement;
+    private final Query query;
     protected final RunResponseHandler runResponseHandler;
     protected final MetadataExtractor metadataExtractor;
     protected final Connection connection;
@@ -66,10 +66,10 @@ public class BasicPullResponseHandler implements PullResponseHandler
     private BiConsumer recordConsumer = null;
     private BiConsumer summaryConsumer = null;
 
-    public BasicPullResponseHandler( Statement statement, RunResponseHandler runResponseHandler, Connection connection, MetadataExtractor metadataExtractor,
-            PullResponseCompletionListener completionListener )
+    public BasicPullResponseHandler(Query query, RunResponseHandler runResponseHandler, Connection connection, MetadataExtractor metadataExtractor,
+                                    PullResponseCompletionListener completionListener )
     {
-        this.statement = requireNonNull( statement );
+        this.query = requireNonNull(query);
         this.runResponseHandler = requireNonNull( runResponseHandler );
         this.metadataExtractor = requireNonNull( metadataExtractor );
         this.connection = requireNonNull( connection );
@@ -106,7 +106,7 @@ public synchronized void onRecord( Value[] fields )
         assertRecordAndSummaryConsumerInstalled();
         if ( isStreaming() )
         {
-            Record record = new InternalRecord( runResponseHandler.statementKeys(), fields );
+            Record record = new InternalRecord( runResponseHandler.queryKeys(), fields );
             recordConsumer.accept( record, null );
         }
     }
@@ -118,7 +118,7 @@ public synchronized void request( long size )
         if ( isStreamingPaused() )
         {
             status = Status.STREAMING;
-            connection.writeAndFlush( new PullMessage( size, runResponseHandler.statementId() ), this );
+            connection.writeAndFlush( new PullMessage( size, runResponseHandler.queryId() ), this );
         }
         else if ( isStreaming() )
         {
@@ -134,7 +134,7 @@ public synchronized void cancel()
         {
             status = Status.CANCELED;
             // Reactive API does not provide a way to discard N. Only discard all.
-            connection.writeAndFlush( newDiscardAllMessage( runResponseHandler.statementId() ), this );
+            connection.writeAndFlush( newDiscardAllMessage( runResponseHandler.queryId() ), this );
         }
         else if ( isStreaming() )
         {
@@ -210,7 +210,7 @@ else if ( this.status == Status.STREAMING )
     private ResultSummary extractResultSummary( Map metadata )
     {
         long resultAvailableAfter = runResponseHandler.resultAvailableAfter();
-        return metadataExtractor.extractSummary( statement, connection, resultAvailableAfter, metadata );
+        return metadataExtractor.extractSummary(query, connection, resultAvailableAfter, metadata );
     }
 
     private void addToRequest( long toAdd )
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java
index 01be1df31e..24ea5a2785 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java
@@ -25,8 +25,8 @@
 import java.util.concurrent.CompletionStage;
 
 import org.neo4j.driver.Bookmark;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.Value;
@@ -94,34 +94,34 @@ public interface BoltProtocol
     CompletionStage rollbackTransaction( Connection connection );
 
     /**
-     * Execute the given statement in an aut-commit transaction, i.e. {@link Session#run(Statement)}.
+     * Execute the given query in an auto-commit transaction, i.e. {@link Session#run(Query)}.
      *
      * @param connection the network connection to use.
-     * @param statement the cypher to execute.
+     * @param query the cypher to execute.
      * @param bookmarkHolder the bookmarksHolder that keeps track of the current bookmark and can be updated with a new bookmark.
      * @param config the transaction config for the implicitly started auto-commit transaction.
      * @param waitForRunResponse {@code true} for async query execution and {@code false} for blocking query
-     * execution. Makes returned cursor stage be chained after the RUN response arrives. Needed to have statement
+     * execution. Makes returned cursor stage be chained after the RUN response arrives. Needed to have query
      * keys populated.
      * @param fetchSize the record fetch size for PULL message.
      * @return stage with cursor.
      */
-    ResultCursorFactory runInAutoCommitTransaction(Connection connection, Statement statement, BookmarkHolder bookmarkHolder,
+    ResultCursorFactory runInAutoCommitTransaction(Connection connection, Query query, BookmarkHolder bookmarkHolder,
                                                    TransactionConfig config, boolean waitForRunResponse, long fetchSize );
 
     /**
-     * Execute the given statement in a running explicit transaction, i.e. {@link Transaction#run(Statement)}.
+     * Execute the given query in a running explicit transaction, i.e. {@link Transaction#run(Query)}.
      *
      * @param connection the network connection to use.
-     * @param statement the cypher to execute.
+     * @param query the cypher to execute.
      * @param tx the transaction which executes the query.
      * @param waitForRunResponse {@code true} for async query execution and {@code false} for blocking query
-     * execution. Makes returned cursor stage be chained after the RUN response arrives. Needed to have statement
+     * execution. Makes returned cursor stage be chained after the RUN response arrives. Needed to have query
      * keys populated.
      * @param fetchSize the record fetch size for PULL message.
      * @return stage with cursor.
      */
-    ResultCursorFactory runInExplicitTransaction(Connection connection, Statement statement, UnmanagedTransaction tx, boolean waitForRunResponse,
+    ResultCursorFactory runInExplicitTransaction(Connection connection, Query query, UnmanagedTransaction tx, boolean waitForRunResponse,
                                                  long fetchSize );
 
     /**
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RunMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RunMessageEncoder.java
index 46f4e0ca7a..2fdf68bc24 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RunMessageEncoder.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RunMessageEncoder.java
@@ -35,7 +35,7 @@ public void encode( Message message, ValuePacker packer ) throws IOException
         checkArgument( message, RunMessage.class );
         RunMessage runMessage = (RunMessage) message;
         packer.packStructHeader( 2, runMessage.signature() );
-        packer.pack( runMessage.statement() );
+        packer.pack( runMessage.query() );
         packer.pack( runMessage.parameters() );
     }
 }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RunWithMetadataMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RunWithMetadataMessageEncoder.java
index 877d27cfa8..d69d34d6dc 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RunWithMetadataMessageEncoder.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RunWithMetadataMessageEncoder.java
@@ -35,7 +35,7 @@ public void encode( Message message, ValuePacker packer ) throws IOException
         checkArgument( message, RunWithMetadataMessage.class );
         RunWithMetadataMessage runMessage = (RunWithMetadataMessage) message;
         packer.packStructHeader( 3, runMessage.signature() );
-        packer.pack( runMessage.statement() );
+        packer.pack( runMessage.query() );
         packer.pack( runMessage.parameters() );
         packer.pack( runMessage.metadata() );
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RunMessage.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RunMessage.java
index 11e589d694..925146a2a8 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RunMessage.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RunMessage.java
@@ -29,30 +29,30 @@
 /**
  * RUN request message
  * 
    
- * Sent by clients to start a new Tank job for a given statement and
+ * Sent by clients to start a new Tank job for a given query and
  * parameter set.
  */
 public class RunMessage implements Message
 {
     public final static byte SIGNATURE = 0x10;
 
-    private final String statement;
+    private final String query;
     private final Map parameters;
 
-    public RunMessage( String statement )
+    public RunMessage( String query)
     {
-        this( statement, Collections.emptyMap() );
+        this(query, Collections.emptyMap() );
     }
 
-    public RunMessage( String statement, Map parameters )
+    public RunMessage(String query, Map parameters )
     {
-        this.statement = statement;
+        this.query = query;
         this.parameters = parameters;
     }
 
-    public String statement()
+    public String query()
     {
-        return statement;
+        return query;
     }
 
     public Map parameters()
@@ -69,7 +69,7 @@ public byte signature()
     @Override
     public String toString()
     {
-        return format( "RUN \"%s\" %s", statement, parameters );
+        return format( "RUN \"%s\" %s", query, parameters );
     }
 
     @Override
@@ -87,14 +87,14 @@ public boolean equals( Object o )
         RunMessage that = (RunMessage) o;
 
         return !(parameters != null ? !parameters.equals( that.parameters ) : that.parameters != null) &&
-               !(statement != null ? !statement.equals( that.statement ) : that.statement != null);
+               !(query != null ? !query.equals( that.query) : that.query != null);
 
     }
 
     @Override
     public int hashCode()
     {
-        int result = statement != null ? statement.hashCode() : 0;
+        int result = query != null ? query.hashCode() : 0;
         result = 31 * result + (parameters != null ? parameters.hashCode() : 0);
         return result;
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RunWithMetadataMessage.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RunWithMetadataMessage.java
index 1542bd9fe2..f616d69447 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RunWithMetadataMessage.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RunWithMetadataMessage.java
@@ -24,7 +24,7 @@
 
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Bookmark;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.internal.DatabaseName;
@@ -37,37 +37,37 @@ public class RunWithMetadataMessage extends MessageWithMetadata
 {
     public final static byte SIGNATURE = 0x10;
 
-    private final String statement;
+    private final String query;
     private final Map parameters;
 
-    public static RunWithMetadataMessage autoCommitTxRunMessage( Statement statement, TransactionConfig config, DatabaseName databaseName, AccessMode mode,
+    public static RunWithMetadataMessage autoCommitTxRunMessage(Query query, TransactionConfig config, DatabaseName databaseName, AccessMode mode,
             Bookmark bookmark )
     {
-        return autoCommitTxRunMessage( statement, config.timeout(), config.metadata(), databaseName, mode, bookmark );
+        return autoCommitTxRunMessage(query, config.timeout(), config.metadata(), databaseName, mode, bookmark );
     }
 
-    public static RunWithMetadataMessage autoCommitTxRunMessage( Statement statement, Duration txTimeout, Map txMetadata, DatabaseName databaseName,
+    public static RunWithMetadataMessage autoCommitTxRunMessage(Query query, Duration txTimeout, Map txMetadata, DatabaseName databaseName,
             AccessMode mode, Bookmark bookmark )
     {
         Map metadata = buildMetadata( txTimeout, txMetadata, databaseName, mode, bookmark );
-        return new RunWithMetadataMessage( statement.text(), statement.parameters().asMap( ofValue() ), metadata );
+        return new RunWithMetadataMessage( query.text(), query.parameters().asMap( ofValue() ), metadata );
     }
 
-    public static RunWithMetadataMessage explicitTxRunMessage( Statement statement )
+    public static RunWithMetadataMessage explicitTxRunMessage( Query query)
     {
-        return new RunWithMetadataMessage( statement.text(), statement.parameters().asMap( ofValue() ), emptyMap() );
+        return new RunWithMetadataMessage( query.text(), query.parameters().asMap( ofValue() ), emptyMap() );
     }
 
-    private RunWithMetadataMessage( String statement, Map parameters, Map metadata )
+    private RunWithMetadataMessage(String query, Map parameters, Map metadata )
     {
         super( metadata );
-        this.statement = statement;
+        this.query = query;
         this.parameters = parameters;
     }
 
-    public String statement()
+    public String query()
     {
-        return statement;
+        return query;
     }
 
     public Map parameters()
@@ -93,18 +93,18 @@ public boolean equals( Object o )
             return false;
         }
         RunWithMetadataMessage that = (RunWithMetadataMessage) o;
-        return Objects.equals( statement, that.statement ) && Objects.equals( parameters, that.parameters ) && Objects.equals( metadata(), that.metadata() );
+        return Objects.equals(query, that.query) && Objects.equals( parameters, that.parameters ) && Objects.equals( metadata(), that.metadata() );
     }
 
     @Override
     public int hashCode()
     {
-        return Objects.hash( statement, parameters, metadata() );
+        return Objects.hash(query, parameters, metadata() );
     }
 
     @Override
     public String toString()
     {
-        return "RUN \"" + statement + "\" " + parameters + " " + metadata();
+        return "RUN \"" + query + "\" " + parameters + " " + metadata();
     }
 }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1.java
index 43aa1ba40d..cb748c8168 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1.java
@@ -27,7 +27,7 @@
 import java.util.concurrent.CompletionStage;
 
 import org.neo4j.driver.Bookmark;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.exceptions.ClientException;
@@ -159,19 +159,19 @@ public CompletionStage rollbackTransaction( Connection connection )
     }
 
     @Override
-    public ResultCursorFactory runInAutoCommitTransaction(Connection connection, Statement statement, BookmarkHolder bookmarkHolder,
+    public ResultCursorFactory runInAutoCommitTransaction(Connection connection, Query query, BookmarkHolder bookmarkHolder,
                                                           TransactionConfig config, boolean waitForRunResponse, long ignored )
     {
         // bookmarks are ignored for auto-commit transactions in this version of the protocol
         verifyBeforeTransaction( config, connection.databaseName() );
-        return buildResultCursorFactory( connection, statement, null, waitForRunResponse );
+        return buildResultCursorFactory( connection, query, null, waitForRunResponse );
     }
 
     @Override
-    public ResultCursorFactory runInExplicitTransaction(Connection connection, Statement statement, UnmanagedTransaction tx,
+    public ResultCursorFactory runInExplicitTransaction(Connection connection, Query query, UnmanagedTransaction tx,
                                                         boolean waitForRunResponse, long ignored )
     {
-        return buildResultCursorFactory( connection, statement, tx, waitForRunResponse );
+        return buildResultCursorFactory( connection, query, tx, waitForRunResponse );
     }
 
     @Override
@@ -180,15 +180,15 @@ public int version()
         return VERSION;
     }
 
-    private static ResultCursorFactory buildResultCursorFactory(Connection connection, Statement statement,
+    private static ResultCursorFactory buildResultCursorFactory(Connection connection, Query query,
                                                                 UnmanagedTransaction tx, boolean waitForRunResponse )
     {
-        String query = statement.text();
-        Map params = statement.parameters().asMap( ofValue() );
+        String queryText = query.text();
+        Map params = query.parameters().asMap( ofValue() );
 
-        RunMessage runMessage = new RunMessage( query, params );
+        RunMessage runMessage = new RunMessage( queryText, params );
         RunResponseHandler runHandler = new RunResponseHandler( METADATA_EXTRACTOR );
-        PullAllResponseHandler pullAllHandler = PullHandlers.newBoltV1PullAllHandler( statement, runHandler, connection, tx );
+        PullAllResponseHandler pullAllHandler = PullHandlers.newBoltV1PullAllHandler( query, runHandler, connection, tx );
 
         return new AsyncResultCursorOnlyFactory( connection, runMessage, runHandler, pullAllHandler, waitForRunResponse );
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java
index 677b3ea3c9..89b85db82d 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java
@@ -26,7 +26,7 @@
 import java.util.concurrent.CompletionStage;
 
 import org.neo4j.driver.Bookmark;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.internal.BookmarkHolder;
@@ -137,28 +137,28 @@ public CompletionStage rollbackTransaction( Connection connection )
     }
 
     @Override
-    public ResultCursorFactory runInAutoCommitTransaction(Connection connection, Statement statement, BookmarkHolder bookmarkHolder,
+    public ResultCursorFactory runInAutoCommitTransaction(Connection connection, Query query, BookmarkHolder bookmarkHolder,
                                                           TransactionConfig config, boolean waitForRunResponse, long fetchSize )
     {
         verifyDatabaseNameBeforeTransaction( connection.databaseName() );
         RunWithMetadataMessage runMessage =
-                autoCommitTxRunMessage( statement, config, connection.databaseName(), connection.mode(), bookmarkHolder.getBookmark() );
-        return buildResultCursorFactory( connection, statement, bookmarkHolder, null, runMessage, waitForRunResponse, fetchSize );
+                autoCommitTxRunMessage(query, config, connection.databaseName(), connection.mode(), bookmarkHolder.getBookmark() );
+        return buildResultCursorFactory( connection, query, bookmarkHolder, null, runMessage, waitForRunResponse, fetchSize );
     }
 
     @Override
-    public ResultCursorFactory runInExplicitTransaction(Connection connection, Statement statement, UnmanagedTransaction tx,
+    public ResultCursorFactory runInExplicitTransaction(Connection connection, Query query, UnmanagedTransaction tx,
                                                         boolean waitForRunResponse, long fetchSize )
     {
-        RunWithMetadataMessage runMessage = explicitTxRunMessage( statement );
-        return buildResultCursorFactory( connection, statement, BookmarkHolder.NO_OP, tx, runMessage, waitForRunResponse, fetchSize );
+        RunWithMetadataMessage runMessage = explicitTxRunMessage(query);
+        return buildResultCursorFactory( connection, query, BookmarkHolder.NO_OP, tx, runMessage, waitForRunResponse, fetchSize );
     }
 
-    protected ResultCursorFactory buildResultCursorFactory(Connection connection, Statement statement, BookmarkHolder bookmarkHolder,
+    protected ResultCursorFactory buildResultCursorFactory(Connection connection, Query query, BookmarkHolder bookmarkHolder,
                                                            UnmanagedTransaction tx, RunWithMetadataMessage runMessage, boolean waitForRunResponse, long ignored )
     {
         RunResponseHandler runHandler = new RunResponseHandler( METADATA_EXTRACTOR );
-        PullAllResponseHandler pullHandler = newBoltV3PullAllHandler( statement, runHandler, connection, bookmarkHolder, tx );
+        PullAllResponseHandler pullHandler = newBoltV3PullAllHandler(query, runHandler, connection, bookmarkHolder, tx );
 
         return new AsyncResultCursorOnlyFactory( connection, runMessage, runHandler, pullHandler, waitForRunResponse );
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4.java
index cd87fe80f2..a6625fd5b7 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4.java
@@ -18,7 +18,7 @@
  */
 package org.neo4j.driver.internal.messaging.v4;
 
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.internal.BookmarkHolder;
 import org.neo4j.driver.internal.DatabaseName;
 import org.neo4j.driver.internal.async.UnmanagedTransaction;
@@ -48,13 +48,13 @@ public MessageFormat createMessageFormat()
     }
 
     @Override
-    protected ResultCursorFactory buildResultCursorFactory(Connection connection, Statement statement, BookmarkHolder bookmarkHolder,
+    protected ResultCursorFactory buildResultCursorFactory(Connection connection, Query query, BookmarkHolder bookmarkHolder,
                                                            UnmanagedTransaction tx, RunWithMetadataMessage runMessage, boolean waitForRunResponse, long fetchSize )
     {
         RunResponseHandler runHandler = new RunResponseHandler( METADATA_EXTRACTOR );
 
-        PullAllResponseHandler pullAllHandler = newBoltV4AutoPullHandler( statement, runHandler, connection, bookmarkHolder, tx, fetchSize );
-        PullResponseHandler pullHandler = newBoltV4BasicPullHandler( statement, runHandler, connection, bookmarkHolder, tx );
+        PullAllResponseHandler pullAllHandler = newBoltV4AutoPullHandler(query, runHandler, connection, bookmarkHolder, tx, fetchSize );
+        PullResponseHandler pullHandler = newBoltV4BasicPullHandler(query, runHandler, connection, bookmarkHolder, tx );
 
         return new ResultCursorFactoryImpl( connection, runMessage, runHandler, pullHandler, pullAllHandler, waitForRunResponse );
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/reactive/AbstractRxStatementRunner.java b/driver/src/main/java/org/neo4j/driver/internal/reactive/AbstractRxQueryRunner.java
similarity index 53%
rename from driver/src/main/java/org/neo4j/driver/internal/reactive/AbstractRxStatementRunner.java
rename to driver/src/main/java/org/neo4j/driver/internal/reactive/AbstractRxQueryRunner.java
index 8aad1bf459..ab6be1ee1e 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/reactive/AbstractRxStatementRunner.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/reactive/AbstractRxQueryRunner.java
@@ -20,37 +20,37 @@
 
 import java.util.Map;
 
+import org.neo4j.driver.Query;
 import org.neo4j.driver.reactive.RxResult;
-import org.neo4j.driver.reactive.RxStatementRunner;
+import org.neo4j.driver.reactive.RxQueryRunner;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Value;
 
-import static org.neo4j.driver.internal.AbstractStatementRunner.parameters;
+import static org.neo4j.driver.internal.AbstractQueryRunner.parameters;
 
-public abstract class AbstractRxStatementRunner implements RxStatementRunner
+public abstract class AbstractRxQueryRunner implements RxQueryRunner
 {
     @Override
-    public final RxResult run(String statementTemplate, Value parameters )
+    public final RxResult run(String query, Value parameters )
     {
-        return run( new Statement( statementTemplate, parameters ) );
+        return run( new Query( query, parameters ) );
     }
 
     @Override
-    public final RxResult run(String statementTemplate, Map statementParameters )
+    public final RxResult run(String query, Map parameters )
     {
-        return run( statementTemplate, parameters( statementParameters ) );
+        return run( query, parameters( parameters ) );
     }
 
     @Override
-    public final RxResult run(String statementTemplate, Record statementParameters )
+    public final RxResult run(String query, Record parameters )
     {
-        return run( statementTemplate, parameters( statementParameters ) );
+        return run( query, parameters( parameters ) );
     }
 
     @Override
-    public final RxResult run(String statementTemplate )
+    public final RxResult run(String query )
     {
-        return run( new Statement( statementTemplate ) );
+        return run( new Query( query ) );
     }
 }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxSession.java b/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxSession.java
index 8826a8a842..13b83c82ec 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxSession.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxSession.java
@@ -18,6 +18,7 @@
  */
 package org.neo4j.driver.internal.reactive;
 
+import org.neo4j.driver.Query;
 import org.reactivestreams.Publisher;
 import reactor.core.publisher.Flux;
 
@@ -25,7 +26,6 @@
 import java.util.concurrent.CompletableFuture;
 
 import org.neo4j.driver.AccessMode;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.Bookmark;
 import org.neo4j.driver.exceptions.TransactionNestingException;
@@ -40,7 +40,7 @@
 import static org.neo4j.driver.internal.reactive.RxUtils.createEmptyPublisher;
 import static org.neo4j.driver.internal.reactive.RxUtils.createMono;
 
-public class InternalRxSession extends AbstractRxStatementRunner implements RxSession
+public class InternalRxSession extends AbstractRxQueryRunner implements RxSession
 {
     private final NetworkSession session;
 
@@ -129,29 +129,29 @@ private  Publisher runTransaction( AccessMode mode, RxTransactionWork parameters, TransactionConfig config )
+    public RxResult run(String query, Map parameters, TransactionConfig config )
     {
-        return run( new Statement( statement, parameters ), config );
+        return run( new Query( query, parameters ), config );
     }
 
     @Override
-    public RxResult run(Statement statement )
+    public RxResult run(Query query)
     {
-        return run( statement, TransactionConfig.empty() );
+        return run(query, TransactionConfig.empty() );
     }
 
     @Override
-    public RxResult run(Statement statement, TransactionConfig config )
+    public RxResult run(Query query, TransactionConfig config )
     {
         return new InternalRxResult( () -> {
             CompletableFuture resultCursorFuture = new CompletableFuture<>();
-            session.runRx( statement, config ).whenComplete( ( cursor, completionError ) -> {
+            session.runRx(query, config ).whenComplete( (cursor, completionError ) -> {
                 if ( cursor != null )
                 {
                     resultCursorFuture.complete( cursor );
diff --git a/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxTransaction.java b/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxTransaction.java
index f8b6f2fc07..1bda412435 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxTransaction.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxTransaction.java
@@ -18,11 +18,11 @@
  */
 package org.neo4j.driver.internal.reactive;
 
+import org.neo4j.driver.Query;
 import org.reactivestreams.Publisher;
 
 import java.util.concurrent.CompletableFuture;
 
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.internal.async.UnmanagedTransaction;
 import org.neo4j.driver.internal.cursor.RxResultCursor;
 import org.neo4j.driver.internal.util.Futures;
@@ -31,7 +31,7 @@
 
 import static org.neo4j.driver.internal.reactive.RxUtils.createEmptyPublisher;
 
-public class InternalRxTransaction extends AbstractRxStatementRunner implements RxTransaction
+public class InternalRxTransaction extends AbstractRxQueryRunner implements RxTransaction
 {
     private final UnmanagedTransaction tx;
 
@@ -41,11 +41,11 @@ public InternalRxTransaction( UnmanagedTransaction tx )
     }
 
     @Override
-    public RxResult run(Statement statement )
+    public RxResult run(Query query)
     {
         return new InternalRxResult( () -> {
             CompletableFuture cursorFuture = new CompletableFuture<>();
-            tx.runRx( statement ).whenComplete( ( cursor, completionError ) -> {
+            tx.runRx(query).whenComplete( (cursor, completionError ) -> {
                 if ( cursor != null )
                 {
                     cursorFuture.complete( cursor );
diff --git a/driver/src/main/java/org/neo4j/driver/internal/summary/InternalPlan.java b/driver/src/main/java/org/neo4j/driver/internal/summary/InternalPlan.java
index dbe842e008..f0034e1247 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/summary/InternalPlan.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/summary/InternalPlan.java
@@ -131,7 +131,7 @@ public Plan create( String operatorType, Map arguments, List EXPLAIN_PLAN_FROM_VALUE = new Converter<>(EXPLAIN_PLAN);
 
     /**
diff --git a/driver/src/main/java/org/neo4j/driver/internal/summary/InternalProfiledPlan.java b/driver/src/main/java/org/neo4j/driver/internal/summary/InternalProfiledPlan.java
index d3b18194fd..f88daa18e9 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/summary/InternalProfiledPlan.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/summary/InternalProfiledPlan.java
@@ -102,7 +102,7 @@ public ProfiledPlan create( String operatorType, Map arguments, Li
     };
 
     /**
-     * Builds a regular plan without profiling information - eg. a plan that came as a result of an `EXPLAIN` statement
+     * Builds a regular plan without profiling information - eg. a plan that came as a result of an `EXPLAIN` query
      */
     public static final Function PROFILED_PLAN_FROM_VALUE = new Converter<>( PROFILED_PLAN );
 }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/summary/InternalResultSummary.java b/driver/src/main/java/org/neo4j/driver/internal/summary/InternalResultSummary.java
index ba7484109d..d7a12bc75c 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/summary/InternalResultSummary.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/summary/InternalResultSummary.java
@@ -23,21 +23,21 @@
 import java.util.Objects;
 import java.util.concurrent.TimeUnit;
 
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.summary.DatabaseInfo;
 import org.neo4j.driver.summary.Notification;
 import org.neo4j.driver.summary.Plan;
 import org.neo4j.driver.summary.ProfiledPlan;
 import org.neo4j.driver.summary.ResultSummary;
 import org.neo4j.driver.summary.ServerInfo;
-import org.neo4j.driver.summary.StatementType;
+import org.neo4j.driver.summary.QueryType;
 import org.neo4j.driver.summary.SummaryCounters;
 
 public class InternalResultSummary implements ResultSummary
 {
-    private final Statement statement;
+    private final Query query;
     private final ServerInfo serverInfo;
-    private final StatementType statementType;
+    private final QueryType queryType;
     private final SummaryCounters counters;
     private final Plan plan;
     private final ProfiledPlan profile;
@@ -46,13 +46,13 @@ public class InternalResultSummary implements ResultSummary
     private final long resultConsumedAfter;
     private final DatabaseInfo databaseInfo;
 
-    public InternalResultSummary( Statement statement, ServerInfo serverInfo, DatabaseInfo databaseInfo, StatementType statementType,
-            SummaryCounters counters, Plan plan, ProfiledPlan profile, List notifications, long resultAvailableAfter, long resultConsumedAfter )
+    public InternalResultSummary(Query query, ServerInfo serverInfo, DatabaseInfo databaseInfo, QueryType queryType,
+                                 SummaryCounters counters, Plan plan, ProfiledPlan profile, List notifications, long resultAvailableAfter, long resultConsumedAfter )
     {
-        this.statement = statement;
+        this.query = query;
         this.serverInfo = serverInfo;
         this.databaseInfo = databaseInfo;
-        this.statementType = statementType;
+        this.queryType = queryType;
         this.counters = counters;
         this.plan = resolvePlan( plan, profile );
         this.profile = profile;
@@ -62,9 +62,9 @@ public InternalResultSummary( Statement statement, ServerInfo serverInfo, Databa
     }
 
     @Override
-    public Statement statement()
+    public Query query()
     {
-        return statement;
+        return query;
     }
 
     @Override
@@ -74,9 +74,9 @@ public SummaryCounters counters()
     }
 
     @Override
-    public StatementType statementType()
+    public QueryType queryType()
     {
-        return statementType;
+        return queryType;
     }
 
     @Override
@@ -149,9 +149,9 @@ public boolean equals( Object o )
         InternalResultSummary that = (InternalResultSummary) o;
         return resultAvailableAfter == that.resultAvailableAfter &&
                resultConsumedAfter == that.resultConsumedAfter &&
-               Objects.equals( statement, that.statement ) &&
+               Objects.equals(query, that.query) &&
                Objects.equals( serverInfo, that.serverInfo ) &&
-               statementType == that.statementType &&
+               queryType == that.queryType &&
                Objects.equals( counters, that.counters ) &&
                Objects.equals( plan, that.plan ) &&
                Objects.equals( profile, that.profile ) &&
@@ -161,7 +161,7 @@ public boolean equals( Object o )
     @Override
     public int hashCode()
     {
-        return Objects.hash( statement, serverInfo, statementType, counters, plan, profile, notifications,
+        return Objects.hash(query, serverInfo, queryType, counters, plan, profile, notifications,
                 resultAvailableAfter, resultConsumedAfter );
     }
 
@@ -169,10 +169,10 @@ public int hashCode()
     public String toString()
     {
         return "InternalResultSummary{" +
-               "statement=" + statement +
+               "query=" + query +
                ", serverInfo=" + serverInfo +
                ", databaseInfo=" + databaseInfo +
-               ", statementType=" + statementType +
+               ", queryType=" + queryType +
                ", counters=" + counters +
                ", plan=" + plan +
                ", profile=" + profile +
diff --git a/driver/src/main/java/org/neo4j/driver/internal/util/ErrorUtil.java b/driver/src/main/java/org/neo4j/driver/internal/util/ErrorUtil.java
index bf157e3f1c..610de3c4f1 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/util/ErrorUtil.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/util/ErrorUtil.java
@@ -57,7 +57,7 @@ public static ServiceUnavailableException newConnectionTerminatedError()
     public static ResultConsumedException newResultConsumedError()
     {
         return new ResultConsumedException( "Cannot access records on this result any more as the result has already been consumed " +
-                "or the statement runner where the result is created has already been closed." );
+                "or the query runner where the result is created has already been closed." );
     }
 
     public static Neo4jException newNeo4jError( String code, String message )
diff --git a/driver/src/main/java/org/neo4j/driver/internal/util/MetadataExtractor.java b/driver/src/main/java/org/neo4j/driver/internal/util/MetadataExtractor.java
index ab5db795c3..881defe690 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/util/MetadataExtractor.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/util/MetadataExtractor.java
@@ -24,7 +24,7 @@
 import java.util.Map;
 
 import org.neo4j.driver.Bookmark;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.exceptions.UntrustedServerException;
 import org.neo4j.driver.internal.InternalBookmark;
@@ -42,7 +42,7 @@
 import org.neo4j.driver.summary.ProfiledPlan;
 import org.neo4j.driver.summary.ResultSummary;
 import org.neo4j.driver.summary.ServerInfo;
-import org.neo4j.driver.summary.StatementType;
+import org.neo4j.driver.summary.QueryType;
 
 import static java.util.Collections.emptyList;
 import static org.neo4j.driver.internal.summary.InternalDatabaseInfo.DEFAULT_DATABASE_INFO;
@@ -60,7 +60,7 @@ public MetadataExtractor( String resultAvailableAfterMetadataKey, String resultC
         this.resultConsumedAfterMetadataKey = resultConsumedAfterMetadataKey;
     }
 
-    public List extractStatementKeys( Map metadata )
+    public List extractQueryKeys(Map metadata )
     {
         Value keysValue = metadata.get( "fields" );
         if ( keysValue != null )
@@ -81,10 +81,10 @@ public List extractStatementKeys( Map metadata )
 
     public long extractQueryId( Map metadata )
     {
-        Value statementId = metadata.get( "qid" );
-        if ( statementId != null )
+        Value queryId = metadata.get( "qid" );
+        if ( queryId != null )
         {
-            return statementId.asLong();
+            return queryId.asLong();
         }
         return ABSENT_QUERY_ID;
     }
@@ -100,11 +100,11 @@ public long extractResultAvailableAfter( Map metadata )
         return -1;
     }
 
-    public ResultSummary extractSummary( Statement statement, Connection connection, long resultAvailableAfter, Map metadata )
+    public ResultSummary extractSummary(Query query, Connection connection, long resultAvailableAfter, Map metadata )
     {
         ServerInfo serverInfo = new InternalServerInfo( connection.serverAddress(), connection.serverVersion() );
         DatabaseInfo dbInfo = extractDatabaseInfo( metadata );
-        return new InternalResultSummary( statement, serverInfo, dbInfo, extractStatementType( metadata ), extractCounters( metadata ), extractPlan( metadata ),
+        return new InternalResultSummary(query, serverInfo, dbInfo, extractQueryType( metadata ), extractCounters( metadata ), extractPlan( metadata ),
                 extractProfiledPlan( metadata ), extractNotifications( metadata ), resultAvailableAfter,
                 extractResultConsumedAfter( metadata, resultConsumedAfterMetadataKey ) );
     }
@@ -153,12 +153,12 @@ public static ServerVersion extractNeo4jServerVersion( Map metadat
         }
     }
 
-    private static StatementType extractStatementType( Map metadata )
+    private static QueryType extractQueryType(Map metadata )
     {
         Value typeValue = metadata.get( "type" );
         if ( typeValue != null )
         {
-            return StatementType.fromCode( typeValue.asString() );
+            return QueryType.fromCode( typeValue.asString() );
         }
         return null;
     }
diff --git a/driver/src/main/java/org/neo4j/driver/reactive/RxStatementRunner.java b/driver/src/main/java/org/neo4j/driver/reactive/RxQueryRunner.java
similarity index 58%
rename from driver/src/main/java/org/neo4j/driver/reactive/RxStatementRunner.java
rename to driver/src/main/java/org/neo4j/driver/reactive/RxQueryRunner.java
index 72a869f949..4ce00c7b39 100644
--- a/driver/src/main/java/org/neo4j/driver/reactive/RxStatementRunner.java
+++ b/driver/src/main/java/org/neo4j/driver/reactive/RxQueryRunner.java
@@ -20,26 +20,26 @@
 
 import java.util.Map;
 
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.Values;
 
 /**
- * Common interface for components that can execute Neo4j statements using Reactive API.
+ * Common interface for components that can execute Neo4j queries using Reactive API.
  * @see RxSession
  * @see RxTransaction
  * @since 2.0
  */
-public interface RxStatementRunner
+public interface RxQueryRunner
 {
     /**
-     * Register running of a statement and return a reactive result stream.
-     * The statement is not executed when the reactive result is returned.
-     * Instead, the publishers in the result will actually start the execution of the statement.
+     * Register running of a query and return a reactive result stream.
+     * The query is not executed when the reactive result is returned.
+     * Instead, the publishers in the result will actually start the execution of the query.
      *
      * This method takes a set of parameters that will be injected into the
-     * statement by Neo4j. Using parameters is highly encouraged, it helps avoid
+     * query by Neo4j. Using parameters is highly encouraged, it helps avoid
      * dangerous cypher injection attacks and improves database performance as
      * Neo4j can re-use query plans more often.
      *
@@ -50,19 +50,19 @@ public interface RxStatementRunner
      * If you are creating parameters programmatically, {@link #run(String, Map)}
      * might be more helpful, it converts your map to a {@link Value} for you.
      *
-     * @param statementTemplate text of a Neo4j statement
+     * @param query text of a Neo4j query
      * @param parameters input parameters, should be a map Value, see {@link Values#parameters(Object...)}.
      * @return a reactive result.
      */
-    RxResult run(String statementTemplate, Value parameters );
+    RxResult run(String query, Value parameters );
 
     /**
-     * Register running of a statement and return a reactive result stream.
-     * The statement is not executed when the reactive result is returned.
-     * Instead, the publishers in the result will actually start the execution of the statement.
+     * Register running of a query and return a reactive result stream.
+     * The query is not executed when the reactive result is returned.
+     * Instead, the publishers in the result will actually start the execution of the query.
      *
      * This method takes a set of parameters that will be injected into the
-     * statement by Neo4j. Using parameters is highly encouraged, it helps avoid
+     * query by Neo4j. Using parameters is highly encouraged, it helps avoid
      * dangerous cypher injection attacks and improves database performance as
      * Neo4j can re-use query plans more often.
      *
@@ -70,48 +70,48 @@ public interface RxStatementRunner
      * must be values that can be converted to Neo4j types. See {@link Values#parameters(Object...)} for
      * a list of allowed types.
      *
-     * @param statementTemplate text of a Neo4j statement
-     * @param statementParameters input data for the statement
+     * @param query text of a Neo4j query
+     * @param parameters input data for the query
      * @return a reactive result.
      */
-    RxResult run(String statementTemplate, Map statementParameters );
+    RxResult run(String query, Map parameters );
 
     /**
-     * Register running of a statement and return a reactive result stream.
-     * The statement is not executed when the reactive result is returned.
-     * Instead, the publishers in the result will actually start the execution of the statement.
+     * Register running of a query and return a reactive result stream.
+     * The query is not executed when the reactive result is returned.
+     * Instead, the publishers in the result will actually start the execution of the query.
      *
      * This method takes a set of parameters that will be injected into the
-     * statement by Neo4j. Using parameters is highly encouraged, it helps avoid
+     * query by Neo4j. Using parameters is highly encouraged, it helps avoid
      * dangerous cypher injection attacks and improves database performance as
      * Neo4j can re-use query plans more often.
      *
      * This version of run takes a {@link Record} of parameters, which can be useful
-     * if you want to use the output of one statement as input for another.
+     * if you want to use the output of one query as input for another.
      *
-     * @param statementTemplate text of a Neo4j statement
-     * @param statementParameters input data for the statement
+     * @param query text of a Neo4j query
+     * @param parameters input data for the query
      * @return a reactive result.
      */
-    RxResult run(String statementTemplate, Record statementParameters );
+    RxResult run(String query, Record parameters );
 
     /**
-     * Register running of a statement and return a reactive result stream.
-     * The statement is not executed when the reactive result is returned.
-     * Instead, the publishers in the result will actually start the execution of the statement.
+     * Register running of a query and return a reactive result stream.
+     * The query is not executed when the reactive result is returned.
+     * Instead, the publishers in the result will actually start the execution of the query.
      *
-     * @param statementTemplate text of a Neo4j statement
+     * @param query text of a Neo4j query
      * @return a reactive result.
      */
-    RxResult run(String statementTemplate );
+    RxResult run(String query );
 
     /**
-     * Register running of a statement and return a reactive result stream.
-     * The statement is not executed when the reactive result is returned.
-     * Instead, the publishers in the result will actually start the execution of the statement.
+     * Register running of a query and return a reactive result stream.
+     * The query is not executed when the reactive result is returned.
+     * Instead, the publishers in the result will actually start the execution of the query.
      *
-     * @param statement a Neo4j statement
+     * @param query a Neo4j query
      * @return a reactive result.
      */
-    RxResult run(Statement statement );
+    RxResult run(Query query);
 }
diff --git a/driver/src/main/java/org/neo4j/driver/reactive/RxResult.java b/driver/src/main/java/org/neo4j/driver/reactive/RxResult.java
index d1fbc85daf..e830ad8f11 100644
--- a/driver/src/main/java/org/neo4j/driver/reactive/RxResult.java
+++ b/driver/src/main/java/org/neo4j/driver/reactive/RxResult.java
@@ -18,6 +18,7 @@
  */
 package org.neo4j.driver.reactive;
 
+import org.neo4j.driver.Query;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
@@ -25,14 +26,13 @@
 import java.util.List;
 
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.exceptions.ResultConsumedException;
 import org.neo4j.driver.summary.ResultSummary;
 
 /**
  * A reactive result provides a reactive way to execute query on the server and receives records back.
  * This reactive result consists of a result key publisher, a record publisher and a result summary publisher.
- * The reactive result is created via {@link RxSession#run(Statement)} and {@link RxTransaction#run(Statement)} for example.
+ * The reactive result is created via {@link RxSession#run(Query)} and {@link RxTransaction#run(Query)} for example.
  * On the creation of the result, the query submitted to create this result will not be executed until one of the publishers in this class is subscribed.
  * The records or the summary stream has to be consumed and finished (completed or errored) to ensure the resources used by this result to be freed correctly.
  *
@@ -47,11 +47,11 @@ public interface RxResult
      * Returns a cold publisher of keys.
      * This publisher always publishes one item - a list of keys. The list could be empty which indicates no keys in the result.
      * 
    
-     * When this publisher is {@linkplain Publisher#subscribe(Subscriber) subscribed}, the statement is sent to the server and executed.
-     * This method does not start the record streaming nor publish statement execution result.
+     * When this publisher is {@linkplain Publisher#subscribe(Subscriber) subscribed}, the query is sent to the server and executed.
+     * This method does not start the record streaming nor publish query execution result.
      * To retrieve the execution result, either {@link #records()} or {@link #consume()} can be used.
-     * {@link #records()} starts record streaming and reports statement execution result.
-     * {@link #consume()} skips record streaming and directly reports statement execution result.
+     * {@link #records()} starts record streaming and reports query execution result.
+     * {@link #consume()} skips record streaming and directly reports query execution result.
      * 
    
      * Consuming of execution result ensures the resources (such as network connections) used by this result is freed correctly.
      * Consuming the keys without consuming the execution result will result in resource leak.
@@ -69,16 +69,16 @@ public interface RxResult
      * Returns a cold unicast publisher of records.
      * 
    
      * When the record publisher is {@linkplain Publisher#subscribe(Subscriber) subscribed},
-     * the query statement is executed and the result is streamed back as a record stream followed by a result summary.
+     * the query is executed and the result is streamed back as a record stream followed by a result summary.
      * This record publisher publishes all records in the result and signals the completion.
      * However before completion or error reporting if any, a cleanup of result resources such as network connection will be carried out automatically.
      * 
    
      * Therefore the {@link Subscriber} of this record publisher shall wait for the termination signal (complete or error)
      * to ensure that the resources used by this result are released correctly.
-     * Then the session is ready to be used to run more statements.
+     * Then the session is ready to be used to run more queries.
      * 
    
      * Cancelling of the record streaming will immediately terminate the propagation of new records.
-     * But it will not cancel statement execution on the server.
+     * But it will not cancel query execution on the server.
      * When the execution is finished, the {@link Subscriber} will be notified with a termination signal (complete or error).
      * 
    
      * The record publishing event by default runs in an Network IO thread, as a result no blocking operation is allowed in this thread.
@@ -95,12 +95,12 @@ public interface RxResult
     /**
      * Returns a cold publisher of result summary which arrives after all records.
      * 
    
-     * {@linkplain Publisher#subscribe(Subscriber) Subscribing} the summary publisher results in the execution of the statement followed by the result summary being returned.
-     * The summary publisher cancels record publishing if not yet subscribed and directly streams back the summary on statement execution completion.
+     * {@linkplain Publisher#subscribe(Subscriber) Subscribing} the summary publisher results in the execution of the query followed by the result summary being returned.
+     * The summary publisher cancels record publishing if not yet subscribed and directly streams back the summary on query execution completion.
      * As a result, the invocation of {@link #records()} after this method, would receive an {@link ResultConsumedException}.
      * 
    
-     * If subscribed after {@link #keys()}, then the result summary will be published after the statement execution without streaming any record to client.
-     * If subscribed after {@link #records()}, then the result summary will be published after the statement execution and the streaming of records.
+     * If subscribed after {@link #keys()}, then the result summary will be published after the query execution without streaming any record to client.
+     * If subscribed after {@link #records()}, then the result summary will be published after the query execution and the streaming of records.
      * 
    
      * Usually, this method shall be chained after {@link #records()} to ensure that all records are processed before summary.
      * 
    
diff --git a/driver/src/main/java/org/neo4j/driver/reactive/RxSession.java b/driver/src/main/java/org/neo4j/driver/reactive/RxSession.java
index 1fce5fd888..a7812c09de 100644
--- a/driver/src/main/java/org/neo4j/driver/reactive/RxSession.java
+++ b/driver/src/main/java/org/neo4j/driver/reactive/RxSession.java
@@ -18,6 +18,7 @@
  */
 package org.neo4j.driver.reactive;
 
+import org.neo4j.driver.Query;
 import org.reactivestreams.Publisher;
 
 import java.util.Map;
@@ -25,7 +26,6 @@
 
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.Values;
 import org.neo4j.driver.Bookmark;
@@ -38,7 +38,7 @@
  * @see Publisher
  * @since 2.0
  */
-public interface RxSession extends RxStatementRunner
+public interface RxSession extends RxQueryRunner
 {
     /**
      * Begin a new explicit {@linkplain RxTransaction transaction}. At
@@ -153,22 +153,22 @@ public interface RxSession extends RxStatementRunner
      Publisher writeTransaction( RxTransactionWork> work, TransactionConfig config );
 
     /**
-     * Run a statement with parameters in an auto-commit transaction with specified {@link TransactionConfig} and return a reactive result stream.
-     * The statement is not executed when the reactive result is returned.
-     * Instead, the publishers in the result will actually start the execution of the statement.
+     * Run a query with parameters in an auto-commit transaction with specified {@link TransactionConfig} and return a reactive result stream.
+     * The query is not executed when the reactive result is returned.
+     * Instead, the publishers in the result will actually start the execution of the query.
      *
-     * @param statement text of a Neo4j statement.
+     * @param query text of a Neo4j query.
      * @param config configuration for the new transaction.
      * @return a reactive result.
      */
-    RxResult run(String statement, TransactionConfig config );
+    RxResult run(String query, TransactionConfig config );
 
     /**
-     * Run a statement with parameters in an auto-commit transaction with specified {@link TransactionConfig} and return a reactive result stream.
-     * The statement is not executed when the reactive result is returned.
-     * Instead, the publishers in the result will actually start the execution of the statement.
+     * Run a query with parameters in an auto-commit transaction with specified {@link TransactionConfig} and return a reactive result stream.
+     * The query is not executed when the reactive result is returned.
+     * Instead, the publishers in the result will actually start the execution of the query.
      * 
    
-     * This method takes a set of parameters that will be injected into the statement by Neo4j.
+     * This method takes a set of parameters that will be injected into the query by Neo4j.
      * Using parameters is highly encouraged, it helps avoid dangerous cypher injection attacks
      * and improves database performance as Neo4j can re-use query plans more often.
      * 
    
@@ -194,17 +194,17 @@ public interface RxSession extends RxStatementRunner
      * }
      * 
      *
-     * @param statement text of a Neo4j statement.
-     * @param parameters input data for the statement.
+     * @param query text of a Neo4j query.
+     * @param parameters input data for the query.
      * @param config configuration for the new transaction.
      * @return a reactive result.
      */
-    RxResult run(String statement, Map parameters, TransactionConfig config );
+    RxResult run(String query, Map parameters, TransactionConfig config );
 
     /**
-     * Run a statement in an auto-commit transaction with specified {@link TransactionConfig configuration} and return a reactive result stream.
-     * The statement is not executed when the reactive result is returned.
-     * Instead, the publishers in the result will actually start the execution of the statement.
+     * Run a query in an auto-commit transaction with specified {@link TransactionConfig configuration} and return a reactive result stream.
+     * The query is not executed when the reactive result is returned.
+     * Instead, the publishers in the result will actually start the execution of the query.
      * 
    Example
    
      * 
          * {@code
@@ -216,21 +216,21 @@ public interface RxSession extends RxStatementRunner
      *                 .withMetadata(metadata)
      *                 .build();
      *
-     * Statement statement = new Statement("MATCH (n) WHERE n.name=$myNameParam RETURN n.age");
-     * RxResult result = rxSession.run(statement.withParameters(Values.parameters("myNameParam", "Bob")));
+     * Query query = new Query("MATCH (n) WHERE n.name=$myNameParam RETURN n.age");
+     * RxResult result = rxSession.run(query.withParameters(Values.parameters("myNameParam", "Bob")));
      * }
      * 
    
      *
-     * @param statement a Neo4j statement.
+     * @param query a Neo4j query.
      * @param config configuration for the new transaction.
      * @return a reactive result.
      */
-    RxResult run(Statement statement, TransactionConfig config );
+    RxResult run(Query query, TransactionConfig config );
 
     /**
-     * Return the bookmark received following the last completed statement within this session.
-     * The last completed statement can be run in a {@linkplain RxTransaction transaction}
-     * started using {@linkplain #beginTransaction() beginTransaction} or directly via {@link #run(Statement) run}.
+     * Return the bookmark received following the last completed query within this session.
+     * The last completed query can be run in a {@linkplain RxTransaction transaction}
+     * started using {@linkplain #beginTransaction() beginTransaction} or directly via {@link #run(Query) run}.
      *
      * @return a reference to a previous transaction.
      */
@@ -244,9 +244,9 @@ public interface RxSession extends RxStatementRunner
      * 2) all transactions opened by this session have been either committed or rolled back.
      * 
    
      * This method is a fallback if you failed to fulfill the two requirements above.
-     * This publisher is completed when all outstanding statements in the session have completed,
+     * This publisher is completed when all outstanding queries in the session have completed,
      * meaning any writes you performed are guaranteed to be durably stored.
-     * It might be completed exceptionally when there are unconsumed errors from previous statements or transactions.
+     * It might be completed exceptionally when there are unconsumed errors from previous queries or transactions.
      *
      * @param  makes it easier to be chained.
      * @return an empty publisher that represents the reactive close.
diff --git a/driver/src/main/java/org/neo4j/driver/reactive/RxTransaction.java b/driver/src/main/java/org/neo4j/driver/reactive/RxTransaction.java
index b5b239df5b..c2b4583c98 100644
--- a/driver/src/main/java/org/neo4j/driver/reactive/RxTransaction.java
+++ b/driver/src/main/java/org/neo4j/driver/reactive/RxTransaction.java
@@ -29,7 +29,7 @@
  * @see Publisher
  * @since 2.0
  */
-public interface RxTransaction extends RxStatementRunner
+public interface RxTransaction extends RxQueryRunner
 {
     /**
      * Commits the transaction.
diff --git a/driver/src/main/java/org/neo4j/driver/summary/InputPosition.java b/driver/src/main/java/org/neo4j/driver/summary/InputPosition.java
index 3314f20520..0e3601a80e 100644
--- a/driver/src/main/java/org/neo4j/driver/summary/InputPosition.java
+++ b/driver/src/main/java/org/neo4j/driver/summary/InputPosition.java
@@ -21,7 +21,7 @@
 import org.neo4j.driver.util.Immutable;
 
 /**
- * An input position refers to a specific character in a statement.
+ * An input position refers to a specific character in a query.
  * @since 1.0
  */
 @Immutable
diff --git a/driver/src/main/java/org/neo4j/driver/summary/Notification.java b/driver/src/main/java/org/neo4j/driver/summary/Notification.java
index 8efc27e14d..ef19a06e10 100644
--- a/driver/src/main/java/org/neo4j/driver/summary/Notification.java
+++ b/driver/src/main/java/org/neo4j/driver/summary/Notification.java
@@ -21,9 +21,9 @@
 import org.neo4j.driver.util.Immutable;
 
 /**
- * Representation for notifications found when executing a statement.
+ * Representation for notifications found when executing a query.
  *
- * A notification can be visualized in a client pinpointing problems or other information about the statement.
+ * A notification can be visualized in a client pinpointing problems or other information about the query.
  * @since 1.0
  */
 @Immutable
@@ -48,10 +48,10 @@ public interface Notification
     String description();
 
     /**
-     * The position in the statement where this notification points to.
+     * The position in the query where this notification points to.
      * Not all notifications have a unique position to point to and in that case the position would be set to null.
      *
-     * @return the position in the statement where the issue was found, or null if no position is associated with this
+     * @return the position in the query where the issue was found, or null if no position is associated with this
      * notification.
      */
     InputPosition position();
diff --git a/driver/src/main/java/org/neo4j/driver/summary/Plan.java b/driver/src/main/java/org/neo4j/driver/summary/Plan.java
index f37257268e..780ffe124d 100644
--- a/driver/src/main/java/org/neo4j/driver/summary/Plan.java
+++ b/driver/src/main/java/org/neo4j/driver/summary/Plan.java
@@ -25,11 +25,11 @@
 import org.neo4j.driver.util.Immutable;
 
 /**
- * This describes the plan that the database planner produced and used (or will use) to execute your statement.
- * This can be extremely helpful in understanding what a statement is doing, and how to optimize it. For more
+ * This describes the plan that the database planner produced and used (or will use) to execute your query.
+ * This can be extremely helpful in understanding what a query is doing, and how to optimize it. For more
  * details, see the Neo4j Manual.
  *
- * The plan for the statement is a tree of plans - each sub-tree containing zero or more child plans. The statement
+ * The plan for the query is a tree of plans - each sub-tree containing zero or more child plans. The query
  * starts with the root plan. Each sub-plan is of a specific {@link #operatorType() operator type}, which describes
  * what that part of the plan does - for instance, perform an index lookup or filter results. The Neo4j Manual contains
  * a reference of the available operator types, and these may differ across Neo4j versions.
diff --git a/driver/src/main/java/org/neo4j/driver/summary/StatementType.java b/driver/src/main/java/org/neo4j/driver/summary/QueryType.java
similarity index 72%
rename from driver/src/main/java/org/neo4j/driver/summary/StatementType.java
rename to driver/src/main/java/org/neo4j/driver/summary/QueryType.java
index cd29c7c601..73f345037d 100644
--- a/driver/src/main/java/org/neo4j/driver/summary/StatementType.java
+++ b/driver/src/main/java/org/neo4j/driver/summary/QueryType.java
@@ -21,30 +21,30 @@
 import org.neo4j.driver.exceptions.ClientException;
 
 /**
- * The type of statement executed.
+ * The type of query executed.
  * @since 1.0
  */
-public enum StatementType
+public enum QueryType
 {
     READ_ONLY,
     READ_WRITE,
     WRITE_ONLY,
     SCHEMA_WRITE;
 
-    public static StatementType fromCode( String type )
+    public static QueryType fromCode(String type )
     {
         switch ( type )
         {
         case "r":
-            return StatementType.READ_ONLY;
+            return QueryType.READ_ONLY;
         case "rw":
-            return StatementType.READ_WRITE;
+            return QueryType.READ_WRITE;
         case "w":
-            return StatementType.WRITE_ONLY;
+            return QueryType.WRITE_ONLY;
         case "s":
-            return StatementType.SCHEMA_WRITE;
+            return QueryType.SCHEMA_WRITE;
         default:
-            throw new ClientException( "Unknown statement type: `" + type + "`." );
+            throw new ClientException( "Unknown query type: `" + type + "`." );
         }
     }
 }
diff --git a/driver/src/main/java/org/neo4j/driver/summary/ResultSummary.java b/driver/src/main/java/org/neo4j/driver/summary/ResultSummary.java
index afa1260740..e47b2f2ccb 100644
--- a/driver/src/main/java/org/neo4j/driver/summary/ResultSummary.java
+++ b/driver/src/main/java/org/neo4j/driver/summary/ResultSummary.java
@@ -21,11 +21,11 @@
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.util.Immutable;
 
 /**
- * The result summary of running a statement. The result summary interface can be used to investigate
+ * The result summary of running a query. The result summary interface can be used to investigate
  * details about the result, like the type of query run, how many and which kinds of updates have been executed,
  * and query plan and profiling information if available.
  *
@@ -38,57 +38,57 @@
 public interface ResultSummary
 {
     /**
-     * @return statement that has been executed
+     * @return query that has been executed
      */
-    Statement statement();
+    Query query();
 
     /**
-     * @return counters for operations the statement triggered
+     * @return counters for operations the query triggered
      */
     SummaryCounters counters();
 
     /**
-     * @return type of statement that has been executed
+     * @return type of query that has been executed
      */
-    StatementType statementType();
+    QueryType queryType();
 
     /**
-     * @return true if the result contained a statement plan, i.e. is the summary of a Cypher "PROFILE" or "EXPLAIN" statement
+     * @return true if the result contained a query plan, i.e. is the summary of a Cypher "PROFILE" or "EXPLAIN" query
      */
     boolean hasPlan();
 
     /**
-     * @return true if the result contained profiling information, i.e. is the summary of a Cypher "PROFILE" statement
+     * @return true if the result contained profiling information, i.e. is the summary of a Cypher "PROFILE" query
      */
     boolean hasProfile();
 
     /**
-     * This describes how the database will execute your statement.
+     * This describes how the database will execute your query.
      *
-     * @return statement plan for the executed statement if available, otherwise null
+     * @return query plan for the executed query if available, otherwise null
      */
     Plan plan();
 
     /**
-     * This describes how the database did execute your statement.
+     * This describes how the database did execute your query.
      *
-     * If the statement you executed {@link #hasProfile() was profiled}, the statement plan will contain detailed
-     * information about what each step of the plan did. That more in-depth version of the statement plan becomes
+     * If the query you executed {@link #hasProfile() was profiled}, the query plan will contain detailed
+     * information about what each step of the plan did. That more in-depth version of the query plan becomes
      * available here.
      *
-     * @return profiled statement plan for the executed statement if available, otherwise null
+     * @return profiled query plan for the executed query if available, otherwise null
      */
     ProfiledPlan profile();
 
     /**
-     * A list of notifications that might arise when executing the statement.
-     * Notifications can be warnings about problematic statements or other valuable information that can be presented
+     * A list of notifications that might arise when executing the query.
+     * Notifications can be warnings about problematic queries or other valuable information that can be presented
      * in a client.
      *
-     * Unlike failures or errors, notifications do not affect the execution of a statement.
+     * Unlike failures or errors, notifications do not affect the execution of a query.
      *
-     * @return a list of notifications produced while executing the statement. The list will be empty if no
-     * notifications produced while executing the statement.
+     * @return a list of notifications produced while executing the query. The list will be empty if no
+     * notifications produced while executing the query.
      */
     List notifications();
 
diff --git a/driver/src/main/java/org/neo4j/driver/summary/SummaryCounters.java b/driver/src/main/java/org/neo4j/driver/summary/SummaryCounters.java
index 76e82e9c7e..8a64b4fdac 100644
--- a/driver/src/main/java/org/neo4j/driver/summary/SummaryCounters.java
+++ b/driver/src/main/java/org/neo4j/driver/summary/SummaryCounters.java
@@ -21,7 +21,7 @@
 import org.neo4j.driver.util.Immutable;
 
 /**
- * Contains counters for various operations that a statement triggered.
+ * Contains counters for various operations that a query triggered.
  * @since 1.0
  */
 @Immutable
@@ -29,7 +29,7 @@ public interface SummaryCounters
 {
     /**
      * Whether there were any updates at all, eg. any of the counters are greater than 0.
-     * @return true if the statement made any updates
+     * @return true if the query made any updates
      */
     boolean containsUpdates();
 
diff --git a/driver/src/test/java/org/neo4j/driver/StatementTest.java b/driver/src/test/java/org/neo4j/driver/QueryTest.java
similarity index 56%
rename from driver/src/test/java/org/neo4j/driver/StatementTest.java
rename to driver/src/test/java/org/neo4j/driver/QueryTest.java
index bd5a251aee..766f71a836 100644
--- a/driver/src/test/java/org/neo4j/driver/StatementTest.java
+++ b/driver/src/test/java/org/neo4j/driver/QueryTest.java
@@ -23,70 +23,66 @@
 import java.util.HashMap;
 import java.util.Map;
 
-import org.neo4j.driver.Statement;
-import org.neo4j.driver.Value;
-import org.neo4j.driver.Values;
-
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.junit.MatcherAssert.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.neo4j.driver.Values.parameters;
 
-class StatementTest
+class QueryTest
 {
     @Test
-    void shouldConstructStatementWithParameters()
+    void shouldConstructQueryWithParameters()
     {
         // given
         String text = "MATCH (n) RETURN n";
 
         // when
-        Statement statement = new Statement( text, Values.EmptyMap );
+        Query query = new Query( text, Values.EmptyMap );
 
         // then
-        assertThat( statement.text(), equalTo( text ) );
-        assertThat( statement.parameters(), equalTo( Values.EmptyMap ) );
+        assertThat( query.text(), equalTo( text ) );
+        assertThat( query.parameters(), equalTo( Values.EmptyMap ) );
     }
 
     @Test
-    void shouldConstructStatementWithNoParameters()
+    void shouldConstructQueryWithNoParameters()
     {
         // given
         String text = "MATCH (n) RETURN n";
 
         // when
-        Statement statement = new Statement( text );
+        Query query = new Query( text );
 
         // then
-        assertThat( statement.text(), equalTo( text ) );
-        assertThat( statement.parameters(), equalTo( Values.EmptyMap ) );
+        assertThat( query.text(), equalTo( text ) );
+        assertThat( query.parameters(), equalTo( Values.EmptyMap ) );
     }
 
     @Test
-    void shouldUpdateStatementText()
+    void shouldUpdateQueryText()
     {
         // when
-        Statement statement =
-                new Statement( "MATCH (n) RETURN n" )
+        Query query =
+                new Query( "MATCH (n) RETURN n" )
                 .withText( "BOO" );
 
         // then
-        assertThat( statement.text(), equalTo( "BOO" ) );
-        assertThat( statement.parameters(), equalTo( Values.EmptyMap ) );
+        assertThat( query.text(), equalTo( "BOO" ) );
+        assertThat( query.parameters(), equalTo( Values.EmptyMap ) );
     }
 
 
     @Test
-    void shouldReplaceStatementParameters()
+    void shouldReplaceQueryParameters()
     {
         // when
         String text = "MATCH (n) RETURN n";
         Value initialParameters = parameters( "a", 1, "b", 2 );
-        Statement statement = new Statement( "MATCH (n) RETURN n" ).withParameters( initialParameters );
+        Query query = new Query( "MATCH (n) RETURN n" ).withParameters( initialParameters );
 
         // then
-        assertThat( statement.text(), equalTo( text ) );
-        assertThat( statement.parameters(), equalTo( initialParameters ) );
+        assertThat( query.text(), equalTo( text ) );
+        assertThat( query.parameters(), equalTo( initialParameters ) );
     }
 
     @Test
@@ -96,37 +92,37 @@ void shouldReplaceMapParameters()
         String text = "MATCH (n) RETURN n";
         Map parameters = new HashMap<>();
         parameters.put( "a", 1 );
-        Statement statement = new Statement( "MATCH (n) RETURN n" ).withParameters( parameters );
+        Query query = new Query( "MATCH (n) RETURN n" ).withParameters( parameters );
 
         // then
-        assertThat( statement.text(), equalTo( text ) );
-        assertThat( statement.parameters(), equalTo( Values.value( parameters ) ) );
+        assertThat( query.text(), equalTo( text ) );
+        assertThat( query.parameters(), equalTo( Values.value( parameters ) ) );
     }
 
     @Test
-    void shouldUpdateStatementParameters()
+    void shouldUpdateQueryParameters()
     {
         // when
         String text = "MATCH (n) RETURN n";
         Value initialParameters = parameters( "a", 1, "b", 2, "c", 3 );
-        Statement statement =
-                new Statement( "MATCH (n) RETURN n", initialParameters )
+        Query query =
+                new Query( "MATCH (n) RETURN n", initialParameters )
                 .withUpdatedParameters( parameters( "a", 0, "b", Values.NULL ) );
 
         // then
-        assertThat( statement.text(), equalTo( text ) );
-        assertThat( statement.parameters(), equalTo( parameters( "a", 0, "c", 3 ) ) );
+        assertThat( query.text(), equalTo( text ) );
+        assertThat( query.parameters(), equalTo( parameters( "a", 0, "c", 3 ) ) );
     }
 
     @Test
     void shouldProhibitNullQuery()
     {
-        assertThrows( IllegalArgumentException.class, () -> new Statement( null ) );
+        assertThrows( IllegalArgumentException.class, () -> new Query( null ) );
     }
 
     @Test
     void shouldProhibitEmptyQuery()
     {
-        assertThrows( IllegalArgumentException.class, () -> new Statement( "" ) );
+        assertThrows( IllegalArgumentException.class, () -> new Query( "" ) );
     }
 }
diff --git a/driver/src/test/java/org/neo4j/driver/integration/ConnectionHandlingIT.java b/driver/src/test/java/org/neo4j/driver/integration/ConnectionHandlingIT.java
index b5308d09de..e27cd2bc03 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/ConnectionHandlingIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/ConnectionHandlingIT.java
@@ -40,7 +40,7 @@
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
 import org.neo4j.driver.Result;
-import org.neo4j.driver.StatementRunner;
+import org.neo4j.driver.QueryRunner;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.internal.BoltServerAddress;
@@ -432,9 +432,9 @@ private Result createNodesInNewSession(int nodesToCreate )
         return createNodes( nodesToCreate, driver.session() );
     }
 
-    private Result createNodes(int nodesToCreate, StatementRunner statementRunner )
+    private Result createNodes(int nodesToCreate, QueryRunner queryRunner)
     {
-        return statementRunner.run( "UNWIND range(1, $nodesToCreate) AS i CREATE (n {index: i}) RETURN n",
+        return queryRunner.run( "UNWIND range(1, $nodesToCreate) AS i CREATE (n {index: i}) RETURN n",
                 parameters( "nodesToCreate", nodesToCreate ) );
     }
 
diff --git a/driver/src/test/java/org/neo4j/driver/integration/ErrorIT.java b/driver/src/test/java/org/neo4j/driver/integration/ErrorIT.java
index 59af0ad000..4c596ff0ec 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/ErrorIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/ErrorIT.java
@@ -80,7 +80,7 @@ void shouldThrowHelpfulSyntaxError()
     {
         ClientException e = assertThrows( ClientException.class, () ->
         {
-            Result result = session.run( "invalid statement" );
+            Result result = session.run( "invalid query" );
             result.consume();
         } );
 
@@ -102,11 +102,11 @@ void shouldNotAllowMoreTxAfterClientException()
             Result cursor = tx.run( "RETURN 1" );
             cursor.single().get( "1" ).asInt();
         } );
-        assertThat( e.getMessage(), startsWith( "Cannot run more statements in this transaction" ) );
+        assertThat( e.getMessage(), startsWith( "Cannot run more queries in this transaction" ) );
     }
 
     @Test
-    void shouldAllowNewStatementAfterRecoverableError()
+    void shouldAllowNewQueryAfterRecoverableError()
     {
         // Given an error has occurred
         try { session.run( "invalid" ).consume(); } catch ( ClientException e ) {/*empty*/}
diff --git a/driver/src/test/java/org/neo4j/driver/integration/NestedQueries.java b/driver/src/test/java/org/neo4j/driver/integration/NestedQueries.java
index 4b5315129b..1aeb1955a0 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/NestedQueries.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/NestedQueries.java
@@ -26,7 +26,7 @@
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
 import org.neo4j.driver.Result;
-import org.neo4j.driver.StatementRunner;
+import org.neo4j.driver.QueryRunner;
 import org.neo4j.driver.Transaction;
 
 import static org.junit.Assert.assertEquals;
@@ -97,11 +97,11 @@ default void shouldAllowNestedQueriesInSessionConsumedAsIteratorAndList() throws
         }
     }
 
-    default void testNestedQueriesConsumedAsIterators( StatementRunner statementRunner ) throws Exception
+    default void testNestedQueriesConsumedAsIterators( QueryRunner queryRunner) throws Exception
     {
         int recordsSeen = 0;
 
-        Result result1 = statementRunner.run( OUTER_QUERY );
+        Result result1 = queryRunner.run( OUTER_QUERY );
         Thread.sleep( 1000 ); // allow some result records to arrive and be buffered
 
         while ( result1.hasNext() )
@@ -110,7 +110,7 @@ default void testNestedQueriesConsumedAsIterators( StatementRunner statementRunn
             assertFalse( record1.get( "x" ).isNull() );
             recordsSeen++;
 
-            Result result2 = statementRunner.run( INNER_QUERY );
+            Result result2 = queryRunner.run( INNER_QUERY );
             while ( result2.hasNext() )
             {
                 Record record2 = result2.next();
@@ -122,11 +122,11 @@ default void testNestedQueriesConsumedAsIterators( StatementRunner statementRunn
         assertEquals( EXPECTED_RECORDS, recordsSeen );
     }
 
-    default void testNestedQueriesConsumedAsLists( StatementRunner statementRunner ) throws Exception
+    default void testNestedQueriesConsumedAsLists( QueryRunner queryRunner) throws Exception
     {
         int recordsSeen = 0;
 
-        Result result1 = statementRunner.run( OUTER_QUERY );
+        Result result1 = queryRunner.run( OUTER_QUERY );
         Thread.sleep( 1000 ); // allow some result records to arrive and be buffered
 
         List records1 = result1.list();
@@ -135,7 +135,7 @@ default void testNestedQueriesConsumedAsLists( StatementRunner statementRunner )
             assertFalse( record1.get( "x" ).isNull() );
             recordsSeen++;
 
-            Result result2 = statementRunner.run( "UNWIND range(1, 10) AS y RETURN y" );
+            Result result2 = queryRunner.run( "UNWIND range(1, 10) AS y RETURN y" );
             List records2 = result2.list();
             for ( Record record2 : records2 )
             {
@@ -147,11 +147,11 @@ default void testNestedQueriesConsumedAsLists( StatementRunner statementRunner )
         assertEquals( EXPECTED_RECORDS, recordsSeen );
     }
 
-    default void testNestedQueriesConsumedAsIteratorAndList( StatementRunner statementRunner ) throws Exception
+    default void testNestedQueriesConsumedAsIteratorAndList( QueryRunner queryRunner) throws Exception
     {
         int recordsSeen = 0;
 
-        Result result1 = statementRunner.run( OUTER_QUERY );
+        Result result1 = queryRunner.run( OUTER_QUERY );
         Thread.sleep( 1000 ); // allow some result records to arrive and be buffered
 
         while ( result1.hasNext() )
@@ -160,7 +160,7 @@ default void testNestedQueriesConsumedAsIteratorAndList( StatementRunner stateme
             assertFalse( record1.get( "x" ).isNull() );
             recordsSeen++;
 
-            Result result2 = statementRunner.run( "UNWIND range(1, 10) AS y RETURN y" );
+            Result result2 = queryRunner.run( "UNWIND range(1, 10) AS y RETURN y" );
             List records2 = result2.list();
             for ( Record record2 : records2 )
             {
diff --git a/driver/src/test/java/org/neo4j/driver/integration/StatementIT.java b/driver/src/test/java/org/neo4j/driver/integration/QueryIT.java
similarity index 94%
rename from driver/src/test/java/org/neo4j/driver/integration/StatementIT.java
rename to driver/src/test/java/org/neo4j/driver/integration/QueryIT.java
index 449a9406d1..d422e345cc 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/StatementIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/QueryIT.java
@@ -40,7 +40,7 @@
 import static org.neo4j.driver.Values.parameters;
 
 @ParallelizableIT
-class StatementIT
+class QueryIT
 {
     @RegisterExtension
     static final SessionExtension session = new SessionExtension();
@@ -48,7 +48,7 @@ class StatementIT
     @Test
     void shouldRunWithResult()
     {
-        // When I execute a statement that yields a result
+        // When I execute a query that yields a result
         List result = session.run( "UNWIND [1,2,3] AS k RETURN k" ).list();
 
         // Then the result object should contain the returned values
@@ -156,14 +156,14 @@ void shouldRunParameterizedWithResult()
         assertThat( result.size(), equalTo( 3 ) );
     }
 
-    @SuppressWarnings({"StatementWithEmptyBody", "ConstantConditions"})
+    @SuppressWarnings({"QueryWithEmptyBody", "ConstantConditions"})
     @Test
-    void shouldRunSimpleStatement()
+    void shouldRunSimpleQuery()
     {
-        // When I run a simple write statement
+        // When I run a simple write query
         session.run( "CREATE (a {name:'Adam'})" );
 
-        // And I run a read statement
+        // And I run a read query
         Result result2 = session.run( "MATCH (a) RETURN a.name" );
 
         // Then I expect to get the name back
diff --git a/driver/src/test/java/org/neo4j/driver/integration/StatementRunnerCloseIT.java b/driver/src/test/java/org/neo4j/driver/integration/QueryRunnerCloseIT.java
similarity index 99%
rename from driver/src/test/java/org/neo4j/driver/integration/StatementRunnerCloseIT.java
rename to driver/src/test/java/org/neo4j/driver/integration/QueryRunnerCloseIT.java
index e0c0b5e8b7..12e52b502a 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/StatementRunnerCloseIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/QueryRunnerCloseIT.java
@@ -40,7 +40,7 @@
 import static org.neo4j.driver.util.TestUtil.await;
 
 @ParallelizableIT
-class StatementRunnerCloseIT
+class QueryRunnerCloseIT
 {
     @RegisterExtension
     static final DatabaseExtension neo4j = new DatabaseExtension();
diff --git a/driver/src/test/java/org/neo4j/driver/integration/ScalarTypeIT.java b/driver/src/test/java/org/neo4j/driver/integration/ScalarTypeIT.java
index e62ea598b8..4a85dc3d6b 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/ScalarTypeIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/ScalarTypeIT.java
@@ -71,10 +71,10 @@ static Stream typesToTest()
 
     @ParameterizedTest
     @MethodSource( "typesToTest" )
-    void shouldHandleType( String statement, Value expectedValue )
+    void shouldHandleType( String query, Value expectedValue )
     {
         // When
-        Result cursor = session.run( statement );
+        Result cursor = session.run( query );
 
         // Then
         assertThat( cursor.single().get( "v" ), equalTo( expectedValue ) );
diff --git a/driver/src/test/java/org/neo4j/driver/integration/SessionIT.java b/driver/src/test/java/org/neo4j/driver/integration/SessionIT.java
index 62ada8e703..caac156406 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/SessionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/SessionIT.java
@@ -44,7 +44,7 @@
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
 import org.neo4j.driver.Result;
-import org.neo4j.driver.StatementRunner;
+import org.neo4j.driver.QueryRunner;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.TransactionWork;
 import org.neo4j.driver.exceptions.AuthenticationException;
@@ -62,7 +62,7 @@
 import org.neo4j.driver.reactive.RxSession;
 import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.summary.ResultSummary;
-import org.neo4j.driver.summary.StatementType;
+import org.neo4j.driver.summary.QueryType;
 import org.neo4j.driver.util.DatabaseExtension;
 import org.neo4j.driver.util.ParallelizableIT;
 import org.neo4j.driver.util.TestUtil;
@@ -919,8 +919,8 @@ void shouldNotAllowAccessingRecordsAfterSummary()
             Result result = session.run( query );
 
             ResultSummary summary = result.consume();
-            assertEquals( query, summary.statement().text() );
-            assertEquals( StatementType.READ_ONLY, summary.statementType() );
+            assertEquals( query, summary.query().text() );
+            assertEquals( QueryType.READ_ONLY, summary.queryType() );
 
             assertThrows( ResultConsumedException.class, result::list );
         }
@@ -1083,7 +1083,7 @@ void shouldAllowConsumingEmptyResult()
             Result result = session.run( "UNWIND [] AS x RETURN x" );
             ResultSummary summary = result.consume();
             assertNotNull( summary );
-            assertEquals( StatementType.READ_ONLY, summary.statementType() );
+            assertEquals( QueryType.READ_ONLY, summary.queryType() );
         }
     }
 
@@ -1109,7 +1109,7 @@ void shouldReportFailureInSummary()
             assertThat( e, is( arithmeticError() ) );
 
             ResultSummary summary = result.consume();
-            assertEquals( query, summary.statement().text() );
+            assertEquals( query, summary.query().text() );
         }
     }
 
@@ -1451,9 +1451,9 @@ private void createNodeWithId( int id )
         }
     }
 
-    private static Result updateNodeId(StatementRunner statementRunner, int currentId, int newId )
+    private static Result updateNodeId(QueryRunner queryRunner, int currentId, int newId )
     {
-        return statementRunner.run( "MATCH (n {id: $currentId}) SET n.id = $newId",
+        return queryRunner.run( "MATCH (n {id: $currentId}) SET n.id = $newId",
                 parameters( "currentId", currentId, "newId", newId ) );
     }
 
diff --git a/driver/src/test/java/org/neo4j/driver/integration/SessionMixIT.java b/driver/src/test/java/org/neo4j/driver/integration/SessionMixIT.java
index aa072a41be..dc996c64ce 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/SessionMixIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/SessionMixIT.java
@@ -29,7 +29,7 @@
 
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Result;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.async.AsyncSession;
@@ -229,8 +229,8 @@ record -> record.get( 0 ).asLong() );
 
     private int countNodes( Object id )
     {
-        Statement statement = new Statement( "MATCH (n:Node {id: $id}) RETURN count(n)", parameters( "id", id ) );
-        Record record = session.run( statement ).single();
+        Query query = new Query( "MATCH (n:Node {id: $id}) RETURN count(n)", parameters( "id", id ) );
+        Record record = session.run(query).single();
         return record.get( 0 ).asInt();
     }
 }
diff --git a/driver/src/test/java/org/neo4j/driver/integration/SessionResetIT.java b/driver/src/test/java/org/neo4j/driver/integration/SessionResetIT.java
index 6ae9a1a75e..02ae6761e0 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/SessionResetIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/SessionResetIT.java
@@ -52,7 +52,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Session;
 import org.neo4j.driver.Result;
-import org.neo4j.driver.StatementRunner;
+import org.neo4j.driver.QueryRunner;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.exceptions.Neo4jException;
@@ -188,9 +188,9 @@ void shouldNotAllowBeginTxIfResetFailureIsNotConsumed() throws Throwable
             assertThat( e1.getMessage(), containsString( "You cannot begin a transaction on a session with an open transaction" ) );
 
             ClientException e2 = assertThrows( ClientException.class, () -> tx1.run( "RETURN 1" ) );
-            assertThat( e2.getMessage(), containsString( "Cannot run more statements in this transaction" ) );
+            assertThat( e2.getMessage(), containsString( "Cannot run more queries in this transaction" ) );
 
-            // Make sure failure from the terminated long running statement is propagated
+            // Make sure failure from the terminated long running query is propagated
             Neo4jException e3 = assertThrows( Neo4jException.class, result::consume );
             assertThat( e3.getMessage(), containsString( "The transaction has been terminated" ) );
         }
@@ -244,7 +244,7 @@ void shouldBeAbleToBeginTxAfterResetFailureIsConsumed() throws Throwable
     }
 
     @Test
-    void shouldKillLongRunningStatement() throws Throwable
+    void shouldKillLongRunningQuery() throws Throwable
     {
         neo4j.ensureProcedures( "longRunningStatement.jar" );
 
@@ -264,7 +264,7 @@ void shouldKillLongRunningStatement() throws Throwable
 
                 // When
                 startTime.set( System.currentTimeMillis() );
-                result.consume(); // blocking to run the statement
+                result.consume(); // blocking to run the query
             }
         } );
 
@@ -319,7 +319,7 @@ private void resetSessionAfterTimeout( Session session, int timeout )
         {
             try
             {
-                Thread.sleep( timeout * 1000 ); // let the statement executing for timeout seconds
+                Thread.sleep( timeout * 1000 ); // let the query execute for timeout seconds
             }
             catch ( InterruptedException ignore )
             {
@@ -332,7 +332,7 @@ private void resetSessionAfterTimeout( Session session, int timeout )
     }
 
     @Test
-    void shouldAllowMoreStatementAfterSessionReset()
+    void shouldAllowMoreQueriesAfterSessionReset()
     {
         // Given
         try ( Session session = neo4j.driver().session() )
@@ -343,7 +343,7 @@ void shouldAllowMoreStatementAfterSessionReset()
             // When reset the state of this session
             session.reset();
 
-            // Then can run successfully more statements without any error
+            // Then can run successfully more queries without any error
             session.run( "RETURN 2" ).consume();
         }
     }
@@ -388,7 +388,7 @@ void shouldMarkTxAsFailedAndDisallowRunAfterSessionReset()
                 tx.run( "RETURN 1" );
                 tx.commit();
             } );
-            assertThat( e.getMessage(), startsWith( "Cannot run more statements in this transaction" ) );
+            assertThat( e.getMessage(), startsWith( "Cannot run more queries in this transaction" ) );
         }
     }
 
@@ -485,7 +485,7 @@ public void performUpdate( Driver driver, int nodeId, int newNodeId,
     }
 
     @Test
-    void shouldBeAbleToRunMoreStatementsAfterResetOnNoErrorState()
+    void shouldBeAbleToRunMoreQueriesAfterResetOnNoErrorState()
     {
         try ( Session session = neo4j.driver().session() )
         {
@@ -497,7 +497,7 @@ void shouldBeAbleToRunMoreStatementsAfterResetOnNoErrorState()
             tx.run( "CREATE (n:FirstNode)" );
             tx.commit();
 
-            // Then the outcome of both statements should be visible
+            // Then the outcome of both queries should be visible
             Result result = session.run( "MATCH (n) RETURN count(n)" );
             long nodes = result.single().get( "count(n)" ).asLong();
             assertThat( nodes, equalTo( 1L ) );
@@ -513,7 +513,7 @@ void shouldHandleResetBeforeRun()
             session.reset();
 
             ClientException e = assertThrows( ClientException.class, () -> tx.run( "CREATE (n:FirstNode)" ) );
-            assertThat( e.getMessage(), containsString( "Cannot run more statements in this transaction" ) );
+            assertThat( e.getMessage(), containsString( "Cannot run more queries in this transaction" ) );
         }
     }
 
@@ -612,9 +612,9 @@ private void createNodeWithId( int id )
         }
     }
 
-    private static Result updateNodeId(StatementRunner statementRunner, int currentId, int newId )
+    private static Result updateNodeId(QueryRunner queryRunner, int currentId, int newId )
     {
-        return statementRunner.run( "MATCH (n {id: $currentId}) SET n.id = $newId",
+        return queryRunner.run( "MATCH (n {id: $currentId}) SET n.id = $newId",
                 parameters( "currentId", currentId, "newId", newId ) );
     }
 
diff --git a/driver/src/test/java/org/neo4j/driver/integration/SummaryIT.java b/driver/src/test/java/org/neo4j/driver/integration/SummaryIT.java
index 0135e0b7b2..00b373c476 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/SummaryIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/SummaryIT.java
@@ -36,7 +36,7 @@
 import org.neo4j.driver.summary.Plan;
 import org.neo4j.driver.summary.ProfiledPlan;
 import org.neo4j.driver.summary.ResultSummary;
-import org.neo4j.driver.summary.StatementType;
+import org.neo4j.driver.summary.QueryType;
 import org.neo4j.driver.util.DatabaseExtension;
 import org.neo4j.driver.util.ParallelizableIT;
 
@@ -78,11 +78,11 @@ void tearDown()
     void shouldContainBasicMetadata()
     {
         // Given
-        Value statementParameters = Values.parameters( "limit", 10 );
-        String statementText = "UNWIND [1, 2, 3, 4] AS n RETURN n AS number LIMIT $limit";
+        Value parameters = Values.parameters( "limit", 10 );
+        String query = "UNWIND [1, 2, 3, 4] AS n RETURN n AS number LIMIT $limit";
 
         // When
-        Result result = session.run( statementText, statementParameters );
+        Result result = session.run( query, parameters );
 
         // Then
         assertTrue( result.hasNext() );
@@ -91,9 +91,9 @@ void shouldContainBasicMetadata()
         ResultSummary summary = result.consume();
 
         // Then
-        assertThat( summary.statementType(), equalTo( StatementType.READ_ONLY ) );
-        assertThat( summary.statement().text(), equalTo( statementText ) );
-        assertThat( summary.statement().parameters(), equalTo( statementParameters ) );
+        assertThat( summary.queryType(), equalTo( QueryType.READ_ONLY ) );
+        assertThat( summary.query().text(), equalTo( query ) );
+        assertThat( summary.query().parameters(), equalTo( parameters ) );
         assertFalse( summary.hasPlan() );
         assertFalse( summary.hasProfile() );
         assertThat( summary, equalTo( result.consume() ) );
@@ -147,12 +147,12 @@ void shouldGetSystemUpdates() throws Throwable
     }
 
     @Test
-    void shouldContainCorrectStatementType()
+    void shouldContainCorrectQueryType()
     {
-        assertThat( session.run("MATCH (n) RETURN 1").consume().statementType(), equalTo( StatementType.READ_ONLY ));
-        assertThat( session.run("CREATE (n)").consume().statementType(), equalTo( StatementType.WRITE_ONLY ));
-        assertThat( session.run("CREATE (n) RETURN (n)").consume().statementType(), equalTo( StatementType.READ_WRITE ));
-        assertThat( session.run("CREATE INDEX ON :User(p)").consume().statementType(), equalTo( StatementType.SCHEMA_WRITE ));
+        assertThat( session.run("MATCH (n) RETURN 1").consume().queryType(), equalTo( QueryType.READ_ONLY ));
+        assertThat( session.run("CREATE (n)").consume().queryType(), equalTo( QueryType.WRITE_ONLY ));
+        assertThat( session.run("CREATE (n) RETURN (n)").consume().queryType(), equalTo( QueryType.READ_WRITE ));
+        assertThat( session.run("CREATE INDEX ON :User(p)").consume().queryType(), equalTo( QueryType.SCHEMA_WRITE ));
     }
 
     @Test
diff --git a/driver/src/test/java/org/neo4j/driver/integration/TransactionIT.java b/driver/src/test/java/org/neo4j/driver/integration/TransactionIT.java
index 58234d5fe1..8645768e6d 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/TransactionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/TransactionIT.java
@@ -114,7 +114,7 @@ void shouldRetrieveResults()
     }
 
     @Test
-    void shouldNotAllowSessionLevelStatementsWhenThereIsATransaction()
+    void shouldNotAllowSessionLevelQueriesWhenThereIsATransaction()
     {
         session.beginTransaction();
 
@@ -453,10 +453,10 @@ void shouldDisallowQueriesAfterFailureWhenResultsAreConsumed()
             assertThat( error1.code(), containsString( "SyntaxError" ) );
 
             ClientException error2 = assertThrows( ClientException.class, () -> tx.run( "CREATE (:OtherNode)" ).consume() );
-            assertThat( error2.getMessage(), startsWith( "Cannot run more statements in this transaction" ) );
+            assertThat( error2.getMessage(), startsWith( "Cannot run more queries in this transaction" ) );
 
             ClientException error3 = assertThrows( ClientException.class, () -> tx.run( "RETURN 42" ).consume() );
-            assertThat( error3.getMessage(), startsWith( "Cannot run more statements in this transaction" ) );
+            assertThat( error3.getMessage(), startsWith( "Cannot run more queries in this transaction" ) );
         }
 
         assertEquals( 0, countNodesByLabel( "Node" ) );
@@ -464,7 +464,7 @@ void shouldDisallowQueriesAfterFailureWhenResultsAreConsumed()
     }
 
     @Test
-    void shouldRollbackWhenMarkedSuccessfulButOneStatementFails()
+    void shouldRollbackWhenMarkedSuccessfulButOneQueryFails()
     {
         ClientException error = assertThrows( ClientException.class, () ->
         {
@@ -502,7 +502,7 @@ private void shouldRunAndCloseAfterAction( Consumer txConsumer, boo
             txConsumer.accept( tx );
         }
 
-        // Then the outcome of both statements should be visible
+        // Then the outcome of both queries should be visible
         Result result = session.run( "MATCH (n) RETURN count(n)" );
         long nodes = result.single().get( "count(n)" ).asLong();
         if (isCommit)
@@ -532,7 +532,7 @@ private void shouldFailToRunQueryAfterTxAction( Consumer txConsumer
         txConsumer.accept( tx );
 
         ClientException e = assertThrows( ClientException.class, () -> tx.run( "CREATE (:MyOtherLabel)" ) );
-        assertThat( e.getMessage(), startsWith( "Cannot run more statements in this transaction" ) );
+        assertThat( e.getMessage(), startsWith( "Cannot run more queries in this transaction" ) );
     }
 
     private static int countNodesByLabel( String label )
diff --git a/driver/src/test/java/org/neo4j/driver/integration/UnmanagedTransactionIT.java b/driver/src/test/java/org/neo4j/driver/integration/UnmanagedTransactionIT.java
index e8d36e15cf..9f3b88a3d9 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/UnmanagedTransactionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/UnmanagedTransactionIT.java
@@ -31,7 +31,7 @@
 
 import org.neo4j.driver.Config;
 import org.neo4j.driver.Driver;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
@@ -89,14 +89,14 @@ private UnmanagedTransaction beginTransaction(NetworkSession session )
         return await( session.beginTransactionAsync( TransactionConfig.empty() ) );
     }
 
-    private ResultCursor sessionRun(NetworkSession session, Statement statement )
+    private ResultCursor sessionRun(NetworkSession session, Query query)
     {
-        return await( session.runAsync( statement, TransactionConfig.empty(), true ) );
+        return await( session.runAsync(query, TransactionConfig.empty(), true ) );
     }
 
-    private ResultCursor txRun(UnmanagedTransaction tx, String statement )
+    private ResultCursor txRun(UnmanagedTransaction tx, String query )
     {
-        return await( tx.runAsync( new Statement( statement ), true ) );
+        return await( tx.runAsync( new Query( query ), true ) );
     }
 
     @Test
@@ -175,7 +175,7 @@ void shouldFailToRunQueryWhenTerminated()
         tx.markTerminated();
 
         ClientException e = assertThrows( ClientException.class, () -> txRun( tx, "CREATE (:MyOtherLabel)" ) );
-        assertThat( e.getMessage(), startsWith( "Cannot run more statements in this transaction" ) );
+        assertThat( e.getMessage(), startsWith( "Cannot run more queries in this transaction" ) );
     }
 
     @Test
@@ -189,7 +189,7 @@ void shouldBePossibleToRunMoreTransactionsAfterOneIsTerminated()
         assertThat( e.getMessage(), startsWith( "Transaction can't be committed" ) );
 
         await( session.beginTransactionAsync( TransactionConfig.empty() )
-                .thenCompose( tx -> tx.runAsync( new Statement( "CREATE (:Node {id: 42})" ), true )
+                .thenCompose( tx -> tx.runAsync( new Query( "CREATE (:Node {id: 42})" ), true )
                         .thenCompose( ResultCursor::consumeAsync )
                         .thenApply( ignore -> tx )
                 ).thenCompose( UnmanagedTransaction::commitAsync ) );
@@ -211,8 +211,8 @@ void shouldPropagateRollbackFailureAfterFatalError()
 
     private int countNodes( Object id )
     {
-        Statement statement = new Statement( "MATCH (n:Node {id: $id}) RETURN count(n)", parameters( "id", id ) );
-        ResultCursor cursor = sessionRun( session, statement );
+        Query query = new Query( "MATCH (n:Node {id: $id}) RETURN count(n)", parameters( "id", id ) );
+        ResultCursor cursor = sessionRun( session, query);
         return await( cursor.singleAsync() ).get( 0 ).asInt();
     }
 
diff --git a/driver/src/test/java/org/neo4j/driver/integration/async/AsyncSessionIT.java b/driver/src/test/java/org/neo4j/driver/integration/async/AsyncSessionIT.java
index eb62d7915c..d2ee902657 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/async/AsyncSessionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/async/AsyncSessionIT.java
@@ -36,8 +36,8 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.neo4j.driver.Bookmark;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.async.AsyncSession;
 import org.neo4j.driver.async.AsyncTransaction;
@@ -55,7 +55,7 @@
 import org.neo4j.driver.internal.util.EnabledOnNeo4jWith;
 import org.neo4j.driver.internal.util.Futures;
 import org.neo4j.driver.summary.ResultSummary;
-import org.neo4j.driver.summary.StatementType;
+import org.neo4j.driver.summary.QueryType;
 import org.neo4j.driver.types.Node;
 import org.neo4j.driver.util.DatabaseExtension;
 import org.neo4j.driver.util.ParallelizableIT;
@@ -264,7 +264,7 @@ void shouldAllowMultipleAsyncRunsWithoutConsumingResults()
     }
 
     @Test
-    void shouldExposeStatementKeysForColumnsWithAliases()
+    void shouldExposeQueryKeysForColumnsWithAliases()
     {
         ResultCursor cursor = await( session.runAsync( "RETURN 1 AS one, 2 AS two, 3 AS three, 4 AS five" ) );
 
@@ -272,7 +272,7 @@ void shouldExposeStatementKeysForColumnsWithAliases()
     }
 
     @Test
-    void shouldExposeStatementKeysForColumnsWithoutAliases()
+    void shouldExposeQueryKeysForColumnsWithoutAliases()
     {
         ResultCursor cursor = await( session.runAsync( "RETURN 1, 2, 3, 5" ) );
 
@@ -288,12 +288,12 @@ void shouldExposeResultSummaryForSimpleQuery()
         ResultCursor cursor = await( session.runAsync( query, params ) );
         ResultSummary summary = await( cursor.consumeAsync() );
 
-        assertEquals( new Statement( query, params ), summary.statement() );
+        assertEquals( new Query( query, params ), summary.query() );
         assertEquals( 1, summary.counters().nodesCreated() );
         assertEquals( 1, summary.counters().labelsAdded() );
         assertEquals( 2, summary.counters().propertiesSet() );
         assertEquals( 0, summary.counters().relationshipsCreated() );
-        assertEquals( StatementType.WRITE_ONLY, summary.statementType() );
+        assertEquals( QueryType.WRITE_ONLY, summary.queryType() );
         assertFalse( summary.hasPlan() );
         assertFalse( summary.hasProfile() );
         assertNull( summary.plan() );
@@ -310,11 +310,11 @@ void shouldExposeResultSummaryForExplainQuery()
         ResultCursor cursor = await( session.runAsync( query ) );
         ResultSummary summary = await( cursor.consumeAsync() );
 
-        assertEquals( new Statement( query ), summary.statement() );
+        assertEquals( new Query( query ), summary.query() );
         assertEquals( 0, summary.counters().nodesCreated() );
         assertEquals( 0, summary.counters().propertiesSet() );
         assertEquals( 0, summary.counters().relationshipsCreated() );
-        assertEquals( StatementType.READ_WRITE, summary.statementType() );
+        assertEquals( QueryType.READ_WRITE, summary.queryType() );
         assertTrue( summary.hasPlan() );
         assertFalse( summary.hasProfile() );
         assertNotNull( summary.plan() );
@@ -336,11 +336,11 @@ void shouldExposeResultSummaryForProfileQuery()
         ResultCursor cursor = await( session.runAsync( query ) );
         ResultSummary summary = await( cursor.consumeAsync() );
 
-        assertEquals( new Statement( query ), summary.statement() );
+        assertEquals( new Query( query ), summary.query() );
         assertEquals( 2, summary.counters().nodesCreated() );
         assertEquals( 0, summary.counters().propertiesSet() );
         assertEquals( 1, summary.counters().relationshipsCreated() );
-        assertEquals( StatementType.READ_WRITE, summary.statementType() );
+        assertEquals( QueryType.READ_WRITE, summary.queryType() );
         assertTrue( summary.hasPlan() );
         assertTrue( summary.hasProfile() );
         assertNotNull( summary.plan() );
@@ -847,7 +847,7 @@ void shouldCloseCleanlyAfterFailure()
                 .thenCompose( tx -> session.runAsync( "RETURN 1" ) );
 
         ClientException e = assertThrows( ClientException.class, () -> await( runWithOpenTx ) );
-        assertThat( e.getMessage(), startsWith( "Statements cannot be run directly on a session with an open transaction" ) );
+        assertThat( e.getMessage(), startsWith( "Queries cannot be run directly on a session with an open transaction" ) );
 
         await( session.closeAsync() );
     }
@@ -855,12 +855,12 @@ void shouldCloseCleanlyAfterFailure()
     @Test
     void shouldPropagateFailureFromFirstIllegalQuery()
     {
-        CompletionStage allStatements = session.runAsync( "CREATE (:Node1)" )
+        CompletionStage allQueries = session.runAsync( "CREATE (:Node1)" )
                 .thenCompose( ignore -> session.runAsync( "CREATE (:Node2)" ) )
                 .thenCompose( ignore -> session.runAsync( "RETURN invalid" ) )
                 .thenCompose( ignore -> session.runAsync( "CREATE (:Node3)" ) );
 
-        ClientException e = assertThrows( ClientException.class, () -> await( allStatements ) );
+        ClientException e = assertThrows( ClientException.class, () -> await( allQueries ) );
         assertThat( e, is( syntaxError( "Variable `invalid` not defined" ) ) );
 
         assertEquals( 1, countNodesByLabel( "Node1" ) );
@@ -951,8 +951,8 @@ private void testForEach( String query, int expectedSeenRecords )
         ResultSummary summary = await( forEachDone );
 
         assertNotNull( summary );
-        assertEquals( query, summary.statement().text() );
-        assertEquals( emptyMap(), summary.statement().parameters().asMap() );
+        assertEquals( query, summary.query().text() );
+        assertEquals( emptyMap(), summary.query().parameters().asMap() );
         assertEquals( expectedSeenRecords, recordsSeen.get() );
     }
 
@@ -974,8 +974,8 @@ private void testConsume( String query )
         ResultSummary summary = await( cursor.consumeAsync() );
 
         assertNotNull( summary );
-        assertEquals( query, summary.statement().text() );
-        assertEquals( emptyMap(), summary.statement().parameters().asMap() );
+        assertEquals( query, summary.query().text() );
+        assertEquals( emptyMap(), summary.query().parameters().asMap() );
 
         // no records should be available, they should all be consumed
         assertThrows( ResultConsumedException.class, () -> await( cursor.nextAsync() ) );
diff --git a/driver/src/test/java/org/neo4j/driver/integration/async/AsyncTransactionIT.java b/driver/src/test/java/org/neo4j/driver/integration/async/AsyncTransactionIT.java
index e783b2304c..eb45990740 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/async/AsyncTransactionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/async/AsyncTransactionIT.java
@@ -33,8 +33,8 @@
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.async.AsyncSession;
 import org.neo4j.driver.async.AsyncTransaction;
@@ -45,7 +45,7 @@
 import org.neo4j.driver.Bookmark;
 import org.neo4j.driver.exceptions.ResultConsumedException;
 import org.neo4j.driver.summary.ResultSummary;
-import org.neo4j.driver.summary.StatementType;
+import org.neo4j.driver.summary.QueryType;
 import org.neo4j.driver.types.Node;
 import org.neo4j.driver.util.DatabaseExtension;
 import org.neo4j.driver.util.ParallelizableIT;
@@ -118,7 +118,7 @@ void shouldBePossibleToRollbackEmptyTx()
     }
 
     @Test
-    void shouldBePossibleToRunSingleStatementAndCommit()
+    void shouldBePossibleToRunSingleQueryAndCommit()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
@@ -136,7 +136,7 @@ void shouldBePossibleToRunSingleStatementAndCommit()
     }
 
     @Test
-    void shouldBePossibleToRunSingleStatementAndRollback()
+    void shouldBePossibleToRunSingleQueryAndRollback()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
@@ -153,7 +153,7 @@ void shouldBePossibleToRunSingleStatementAndRollback()
     }
 
     @Test
-    void shouldBePossibleToRunMultipleStatementsAndCommit()
+    void shouldBePossibleToRunMultipleQueriesAndCommit()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
@@ -172,7 +172,7 @@ void shouldBePossibleToRunMultipleStatementsAndCommit()
     }
 
     @Test
-    void shouldBePossibleToRunMultipleStatementsAndCommitWithoutWaiting()
+    void shouldBePossibleToRunMultipleQueriesAndCommitWithoutWaiting()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
@@ -186,7 +186,7 @@ void shouldBePossibleToRunMultipleStatementsAndCommitWithoutWaiting()
     }
 
     @Test
-    void shouldBePossibleToRunMultipleStatementsAndRollback()
+    void shouldBePossibleToRunMultipleQueriesAndRollback()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
@@ -202,7 +202,7 @@ void shouldBePossibleToRunMultipleStatementsAndRollback()
     }
 
     @Test
-    void shouldBePossibleToRunMultipleStatementsAndRollbackWithoutWaiting()
+    void shouldBePossibleToRunMultipleQueriesAndRollbackWithoutWaiting()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
@@ -215,7 +215,7 @@ void shouldBePossibleToRunMultipleStatementsAndRollbackWithoutWaiting()
     }
 
     @Test
-    void shouldFailToCommitAfterSingleWrongStatement()
+    void shouldFailToCommitAfterSingleWrongQuery()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
@@ -228,7 +228,7 @@ void shouldFailToCommitAfterSingleWrongStatement()
     }
 
     @Test
-    void shouldAllowRollbackAfterSingleWrongStatement()
+    void shouldAllowRollbackAfterSingleWrongQuery()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
@@ -240,7 +240,7 @@ void shouldAllowRollbackAfterSingleWrongStatement()
     }
 
     @Test
-    void shouldFailToCommitAfterCoupleCorrectAndSingleWrongStatement()
+    void shouldFailToCommitAfterCoupleCorrectAndSingleWrongQuery()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
@@ -263,7 +263,7 @@ void shouldFailToCommitAfterCoupleCorrectAndSingleWrongStatement()
     }
 
     @Test
-    void shouldAllowRollbackAfterCoupleCorrectAndSingleWrongStatement()
+    void shouldAllowRollbackAfterCoupleCorrectAndSingleWrongQuery()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
@@ -285,7 +285,7 @@ void shouldAllowRollbackAfterCoupleCorrectAndSingleWrongStatement()
     }
 
     @Test
-    void shouldNotAllowNewStatementsAfterAnIncorrectStatement()
+    void shouldNotAllowNewQueriesAfterAnIncorrectQuery()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
 
@@ -295,7 +295,7 @@ void shouldNotAllowNewStatementsAfterAnIncorrectStatement()
         assertThat( e1, is( syntaxError( "Unexpected end of input" ) ) );
 
         ClientException e2 = assertThrows( ClientException.class, () -> tx.runAsync( "CREATE ()" ) );
-        assertThat( e2.getMessage(), startsWith( "Cannot run more statements in this transaction" ) );
+        assertThat( e2.getMessage(), startsWith( "Cannot run more queries in this transaction" ) );
     }
 
     @Test
@@ -355,7 +355,7 @@ void shouldFailToRollbackWhenCommitted()
     }
 
     @Test
-    void shouldExposeStatementKeysForColumnsWithAliases()
+    void shouldExposeQueryKeysForColumnsWithAliases()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
         ResultCursor cursor = await( tx.runAsync( "RETURN 1 AS one, 2 AS two, 3 AS three, 4 AS five" ) );
@@ -364,7 +364,7 @@ void shouldExposeStatementKeysForColumnsWithAliases()
     }
 
     @Test
-    void shouldExposeStatementKeysForColumnsWithoutAliases()
+    void shouldExposeQueryKeysForColumnsWithoutAliases()
     {
         AsyncTransaction tx = await( session.beginTransactionAsync() );
         ResultCursor cursor = await( tx.runAsync( "RETURN 1, 2, 3, 5" ) );
@@ -382,12 +382,12 @@ void shouldExposeResultSummaryForSimpleQuery()
         ResultCursor cursor = await( tx.runAsync( query, params ) );
         ResultSummary summary = await( cursor.consumeAsync() );
 
-        assertEquals( new Statement( query, params ), summary.statement() );
+        assertEquals( new Query( query, params ), summary.query() );
         assertEquals( 2, summary.counters().nodesCreated() );
         assertEquals( 2, summary.counters().labelsAdded() );
         assertEquals( 2, summary.counters().propertiesSet() );
         assertEquals( 1, summary.counters().relationshipsCreated() );
-        assertEquals( StatementType.READ_WRITE, summary.statementType() );
+        assertEquals( QueryType.READ_WRITE, summary.queryType() );
         assertFalse( summary.hasPlan() );
         assertFalse( summary.hasProfile() );
         assertNull( summary.plan() );
@@ -405,10 +405,10 @@ void shouldExposeResultSummaryForExplainQuery()
         ResultCursor cursor = await( tx.runAsync( query ) );
         ResultSummary summary = await( cursor.consumeAsync() );
 
-        assertEquals( new Statement( query ), summary.statement() );
+        assertEquals( new Query( query ), summary.query() );
         assertEquals( 0, summary.counters().nodesCreated() );
         assertEquals( 0, summary.counters().propertiesSet() );
-        assertEquals( StatementType.READ_ONLY, summary.statementType() );
+        assertEquals( QueryType.READ_ONLY, summary.queryType() );
         assertTrue( summary.hasPlan() );
         assertFalse( summary.hasProfile() );
         assertNotNull( summary.plan() );
@@ -433,11 +433,11 @@ void shouldExposeResultSummaryForProfileQuery()
         ResultCursor cursor = await( tx.runAsync( query, params ) );
         ResultSummary summary = await( cursor.consumeAsync() );
 
-        assertEquals( new Statement( query, params ), summary.statement() );
+        assertEquals( new Query( query, params ), summary.query() );
         assertEquals( 1, summary.counters().nodesCreated() );
         assertEquals( 2, summary.counters().propertiesSet() );
         assertEquals( 0, summary.counters().relationshipsCreated() );
-        assertEquals( StatementType.WRITE_ONLY, summary.statementType() );
+        assertEquals( QueryType.WRITE_ONLY, summary.queryType() );
         assertTrue( summary.hasPlan() );
         assertTrue( summary.hasProfile() );
         assertNotNull( summary.plan() );
@@ -634,7 +634,7 @@ void shouldFailToRunQueryAfterCommit()
         assertEquals( 1, await( cursor.singleAsync() ).get( 0 ).asInt() );
 
         ClientException e = assertThrows( ClientException.class, () -> await( tx.runAsync( "CREATE (:MyOtherLabel)" ) ) );
-        assertEquals( "Cannot run more statements in this transaction, it has been committed", e.getMessage() );
+        assertEquals( "Cannot run more queries in this transaction, it has been committed", e.getMessage() );
     }
 
     @Test
@@ -648,7 +648,7 @@ void shouldFailToRunQueryAfterRollback()
         assertEquals( 0, await( cursor.singleAsync() ).get( 0 ).asInt() );
 
         ClientException e = assertThrows( ClientException.class, () -> await( tx.runAsync( "CREATE (:MyOtherLabel)" ) ) );
-        assertEquals( "Cannot run more statements in this transaction, it has been rolled back", e.getMessage() );
+        assertEquals( "Cannot run more queries in this transaction, it has been rolled back", e.getMessage() );
     }
 
     @Test
@@ -845,8 +845,8 @@ private void testForEach( String query, int expectedSeenRecords )
         ResultSummary summary = await( forEachDone );
 
         assertNotNull( summary );
-        assertEquals( query, summary.statement().text() );
-        assertEquals( emptyMap(), summary.statement().parameters().asMap() );
+        assertEquals( query, summary.query().text() );
+        assertEquals( emptyMap(), summary.query().parameters().asMap() );
         assertEquals( expectedSeenRecords, recordsSeen.get() );
     }
 
@@ -870,8 +870,8 @@ private void testConsume( String query )
         ResultSummary summary = await( cursor.consumeAsync() );
 
         assertNotNull( summary );
-        assertEquals( query, summary.statement().text() );
-        assertEquals( emptyMap(), summary.statement().parameters().asMap() );
+        assertEquals( query, summary.query().text() );
+        assertEquals( emptyMap(), summary.query().parameters().asMap() );
 
         // no records should be available, they should all be consumed
         assertThrows( ResultConsumedException.class, () -> await( cursor.nextAsync() ) );
diff --git a/driver/src/test/java/org/neo4j/driver/integration/reactive/RxResultIT.java b/driver/src/test/java/org/neo4j/driver/integration/reactive/RxResultIT.java
index 03bdb9f36e..52ff46217f 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/reactive/RxResultIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/reactive/RxResultIT.java
@@ -32,7 +32,7 @@
 import org.neo4j.driver.reactive.RxSession;
 import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.summary.ResultSummary;
-import org.neo4j.driver.summary.StatementType;
+import org.neo4j.driver.summary.QueryType;
 import org.neo4j.driver.util.DatabaseExtension;
 import org.neo4j.driver.util.ParallelizableIT;
 
@@ -228,7 +228,7 @@ void shouldOnlyErrorRecordAfterFailure()
 
         StepVerifier.create( summaryMono )
                 .assertNext( summary -> {
-                    assertThat( summary.statement().text(), equalTo( "INVALID" ) );
+                    assertThat( summary.query().text(), equalTo( "INVALID" ) );
                     assertNotNull( summary.server().address() );
                     assertNotNull( summary.server().version() );
                 } ).verifyComplete();
@@ -281,7 +281,7 @@ void shouldDiscardRecords()
                 .assertNext( summary -> {
                     // Then
                     assertThat( summary, notNullValue() );
-                    assertThat( summary.statementType(), equalTo( StatementType.READ_ONLY ) );
+                    assertThat( summary.queryType(), equalTo( QueryType.READ_ONLY ) );
                 } ).expectComplete().verify();
     }
 
@@ -354,7 +354,7 @@ void shouldErrorToAccessRecordAfterTxClose()
                 Flux.from( session.beginTransaction() ).single()
                         .flatMap( tx -> Flux.from( tx.rollback() ).singleOrEmpty().thenReturn( tx ) )
                         .flatMapMany( tx -> tx.run( "UNWIND [1,2] AS a RETURN a" ).records() ) )
-                .expectErrorSatisfies( error -> assertThat( error.getMessage(), containsString( "Cannot run more statements" ) ) )
+                .expectErrorSatisfies( error -> assertThat( error.getMessage(), containsString( "Cannot run more queries" ) ) )
                 .verify();
     }
 
@@ -370,7 +370,7 @@ void shouldErrorToAccessKeysAfterTxClose()
                 Flux.from( session.beginTransaction() ).single()
                         .flatMap( tx -> Flux.from( tx.rollback() ).singleOrEmpty().thenReturn( tx ) )
                         .flatMapMany( tx -> tx.run( "UNWIND [1,2] AS a RETURN a" ).keys() ) )
-                .expectErrorSatisfies( error -> assertThat( error.getMessage(), containsString( "Cannot run more statements" ) ) )
+                .expectErrorSatisfies( error -> assertThat( error.getMessage(), containsString( "Cannot run more queries" ) ) )
                 .verify();
     }
 
@@ -386,7 +386,7 @@ void shouldErrorToAccessSummaryAfterTxClose()
                 Flux.from( session.beginTransaction() ).single()
                         .flatMap( tx -> Flux.from( tx.rollback() ).singleOrEmpty().thenReturn( tx ) )
                         .flatMapMany( tx -> tx.run( "UNWIND [1,2] AS a RETURN a" ).consume() ) )
-                .expectErrorSatisfies( error -> assertThat( error.getMessage(), containsString( "Cannot run more statements" ) ) )
+                .expectErrorSatisfies( error -> assertThat( error.getMessage(), containsString( "Cannot run more queries" ) ) )
                 .verify();
     }
 
@@ -402,7 +402,7 @@ void throwErrorAfterKeys()
                 Flux.from( session.beginTransaction() ).single()
                         .flatMap( tx -> Flux.from( tx.rollback() ).singleOrEmpty().thenReturn( tx ) )
                         .flatMapMany( tx -> tx.run( "UNWIND [1,2] AS a RETURN a" ).consume() ) )
-                .expectErrorSatisfies( error -> assertThat( error.getMessage(), containsString( "Cannot run more statements" ) ) )
+                .expectErrorSatisfies( error -> assertThat( error.getMessage(), containsString( "Cannot run more queries" ) ) )
                 .verify();
     }
 
@@ -454,9 +454,9 @@ void throwResultConsumedErrorWhenCallingRecordsMultipleTimes()
     private void verifyCanAccessSummary( RxResult res )
     {
         StepVerifier.create( res.consume() ).assertNext( summary -> {
-            assertThat( summary.statement().text(), equalTo( "UNWIND [1,2,3,4] AS a RETURN a" ) );
+            assertThat( summary.query().text(), equalTo( "UNWIND [1,2,3,4] AS a RETURN a" ) );
             assertThat( summary.counters().nodesCreated(), equalTo( 0 ) );
-            assertThat( summary.statementType(), equalTo( StatementType.READ_ONLY ) );
+            assertThat( summary.queryType(), equalTo( QueryType.READ_ONLY ) );
         } ).verifyComplete();
     }
 
diff --git a/driver/src/test/java/org/neo4j/driver/integration/reactive/RxTransactionIT.java b/driver/src/test/java/org/neo4j/driver/integration/reactive/RxTransactionIT.java
index 083047a7e8..2fe6bcfab4 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/reactive/RxTransactionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/reactive/RxTransactionIT.java
@@ -39,7 +39,7 @@
 
 import org.neo4j.driver.Bookmark;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
@@ -48,7 +48,7 @@
 import org.neo4j.driver.reactive.RxResult;
 import org.neo4j.driver.reactive.RxTransaction;
 import org.neo4j.driver.summary.ResultSummary;
-import org.neo4j.driver.summary.StatementType;
+import org.neo4j.driver.summary.QueryType;
 import org.neo4j.driver.types.Node;
 import org.neo4j.driver.util.DatabaseExtension;
 import org.neo4j.driver.util.ParallelizableIT;
@@ -119,7 +119,7 @@ void shouldBePossibleToRollbackEmptyTx()
     }
 
     @Test
-    void shouldBePossibleToRunSingleStatementAndCommit()
+    void shouldBePossibleToRunSingleQueryAndCommit()
     {
         Flux ids = Flux.usingWhen( session.beginTransaction(),
                 tx -> Flux.from( tx.run( "CREATE (n:Node {id: 42}) RETURN n" ).records() )
@@ -131,7 +131,7 @@ void shouldBePossibleToRunSingleStatementAndCommit()
     }
 
     @Test
-    void shouldBePossibleToRunSingleStatementAndRollback()
+    void shouldBePossibleToRunSingleQueryAndRollback()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
         assertCanRunCreate( tx );
@@ -143,7 +143,7 @@ void shouldBePossibleToRunSingleStatementAndRollback()
 
     @ParameterizedTest
     @MethodSource( "commit" )
-    void shouldBePossibleToRunMultipleStatements( boolean commit )
+    void shouldBePossibleToRunMultipleQueries(boolean commit )
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
 
@@ -163,7 +163,7 @@ void shouldBePossibleToRunMultipleStatements( boolean commit )
 
     @ParameterizedTest
     @MethodSource( "commit" )
-    void shouldBePossibleToRunMultipleStatementsWithoutWaiting( boolean commit )
+    void shouldBePossibleToRunMultipleQueriesWithoutWaiting(boolean commit )
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
 
@@ -179,7 +179,7 @@ void shouldBePossibleToRunMultipleStatementsWithoutWaiting( boolean commit )
 
     @ParameterizedTest
     @MethodSource( "commit" )
-    void shouldRunStatementsOnResultPublish( boolean commit )
+    void shouldRunQueriesOnResultPublish(boolean commit )
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
 
@@ -216,7 +216,7 @@ void shouldDiscardOnCommitOrRollback( boolean commit )
 
     @ParameterizedTest
     @MethodSource( "commit" )
-    void shouldBePossibleToRunMultipleStatementsWithoutStreaming( boolean commit )
+    void shouldBePossibleToRunMultipleQueriesWithoutStreaming(boolean commit )
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
 
@@ -231,53 +231,53 @@ void shouldBePossibleToRunMultipleStatementsWithoutStreaming( boolean commit )
     }
 
     @Test
-    void shouldFailToCommitAfterSingleWrongStatement()
+    void shouldFailToCommitAfterSingleWrongQuery()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        assertFailToRunWrongStatement( tx );
+        assertFailToRunWrongQuery( tx );
         assertThrows( ClientException.class, () -> await( tx.commit() ) );
     }
 
     @Test
-    void shouldAllowRollbackAfterSingleWrongStatement()
+    void shouldAllowRollbackAfterSingleWrongQuery()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        assertFailToRunWrongStatement( tx );
+        assertFailToRunWrongQuery( tx );
         assertCanRollback( tx );
     }
 
     @Test
-    void shouldFailToCommitAfterCoupleCorrectAndSingleWrongStatement()
+    void shouldFailToCommitAfterCoupleCorrectAndSingleWrongQuery()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
 
         assertCanRunCreate( tx );
         assertCanRunReturnOne( tx );
-        assertFailToRunWrongStatement( tx );
+        assertFailToRunWrongQuery( tx );
 
         assertThrows( ClientException.class, () -> await( tx.commit() ) );
     }
 
     @Test
-    void shouldAllowRollbackAfterCoupleCorrectAndSingleWrongStatement()
+    void shouldAllowRollbackAfterCoupleCorrectAndSingleWrongQuery()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
         assertCanRunCreate( tx );
         assertCanRunReturnOne( tx );
-        assertFailToRunWrongStatement( tx );
+        assertFailToRunWrongQuery( tx );
 
         assertCanRollback( tx );
     }
 
     @Test
-    void shouldNotAllowNewStatementsAfterAnIncorrectStatement()
+    void shouldNotAllowNewQueriesAfterAnIncorrectQuery()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        assertFailToRunWrongStatement( tx );
+        assertFailToRunWrongQuery( tx );
 
         RxResult result = tx.run( "CREATE ()" );
         Exception e = assertThrows( Exception.class, () -> await( result.records() ) );
-        assertThat( e.getMessage(), startsWith( "Cannot run more statements in this transaction" ) );
+        assertThat( e.getMessage(), startsWith( "Cannot run more queries in this transaction" ) );
 
         assertCanRollback( tx );
     }
@@ -358,7 +358,7 @@ void shouldAllowRollbackAfterFailedCommit()
     }
 
     @Test
-    void shouldExposeStatementKeysForColumnsWithAliases()
+    void shouldExposeQueryKeysForColumnsWithAliases()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
         RxResult result = tx.run( "RETURN 1 AS one, 2 AS two, 3 AS three, 4 AS five" );
@@ -370,7 +370,7 @@ void shouldExposeStatementKeysForColumnsWithAliases()
     }
 
     @Test
-    void shouldExposeStatementKeysForColumnsWithoutAliases()
+    void shouldExposeQueryKeysForColumnsWithoutAliases()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
         RxResult result = tx.run( "RETURN 1, 2, 3, 5" );
@@ -393,12 +393,12 @@ void shouldExposeResultSummaryForSimpleQuery()
 
         ResultSummary summary = await( Mono.from( result.consume() ) );
 
-        assertEquals( new Statement( query, params ), summary.statement() );
+        assertEquals( new Query( query, params ), summary.query() );
         assertEquals( 2, summary.counters().nodesCreated() );
         assertEquals( 2, summary.counters().labelsAdded() );
         assertEquals( 2, summary.counters().propertiesSet() );
         assertEquals( 1, summary.counters().relationshipsCreated() );
-        assertEquals( StatementType.READ_WRITE, summary.statementType() );
+        assertEquals( QueryType.READ_WRITE, summary.queryType() );
         assertFalse( summary.hasPlan() );
         assertFalse( summary.hasProfile() );
         assertNull( summary.plan() );
@@ -421,10 +421,10 @@ void shouldExposeResultSummaryForExplainQuery()
 
         ResultSummary summary = await( Mono.from( result.consume() ) );
 
-        assertEquals( new Statement( query ), summary.statement() );
+        assertEquals( new Query( query ), summary.query() );
         assertEquals( 0, summary.counters().nodesCreated() );
         assertEquals( 0, summary.counters().propertiesSet() );
-        assertEquals( StatementType.READ_ONLY, summary.statementType() );
+        assertEquals( QueryType.READ_ONLY, summary.queryType() );
         assertTrue( summary.hasPlan() );
         assertFalse( summary.hasProfile() );
         assertNotNull( summary.plan() );
@@ -453,11 +453,11 @@ void shouldExposeResultSummaryForProfileQuery()
 
         ResultSummary summary = await( Mono.from( result.consume() ) );
 
-        assertEquals( new Statement( query, params ), summary.statement() );
+        assertEquals( new Query( query, params ), summary.query() );
         assertEquals( 1, summary.counters().nodesCreated() );
         assertEquals( 2, summary.counters().propertiesSet() );
         assertEquals( 0, summary.counters().relationshipsCreated() );
-        assertEquals( StatementType.WRITE_ONLY, summary.statementType() );
+        assertEquals( QueryType.WRITE_ONLY, summary.queryType() );
         assertTrue( summary.hasPlan() );
         assertTrue( summary.hasProfile() );
         assertNotNull( summary.plan() );
@@ -660,17 +660,17 @@ void shouldFailToRunQueryAfterCommit( boolean commit )
         }
 
         ClientException e = assertThrows( ClientException.class, () -> await( tx.run( "CREATE (:MyOtherLabel)" ).records() ) );
-        assertThat( e.getMessage(), containsString( "Cannot run more statements in this transaction, it has been " ) );
+        assertThat( e.getMessage(), containsString( "Cannot run more queries in this transaction, it has been " ) );
     }
 
     @Test
     void shouldFailToRunQueryWhenTerminated()
     {
         RxTransaction tx = await( Mono.from( session.beginTransaction() ) );
-        assertFailToRunWrongStatement( tx );
+        assertFailToRunWrongQuery( tx );
 
         ClientException e = assertThrows( ClientException.class, () -> await( tx.run( "CREATE (:MyOtherLabel)" ).records() ) );
-        assertThat( e.getMessage(), startsWith( "Cannot run more statements in this transaction" ) );
+        assertThat( e.getMessage(), startsWith( "Cannot run more queries in this transaction" ) );
 
         assertCanRollback( tx );
     }
@@ -806,8 +806,8 @@ private void testForEach( String query, int expectedSeenRecords )
                     .then( Mono.from( result.consume() ) )
                     .doOnSuccess( s -> {
                         assertNotNull( s );
-                        assertEquals( query, s.statement().text() );
-                        assertEquals( emptyMap(), s.statement().parameters().asMap() );
+                        assertEquals( query, s.query().text() );
+                        assertEquals( emptyMap(), s.query().parameters().asMap() );
                         assertEquals( expectedSeenRecords, recordsSeen.get() );
                     } );
         }, RxTransaction::commit, ( tx, error ) -> tx.rollback(), null );
@@ -895,7 +895,7 @@ private static void assertCanRunCreate( RxTransaction tx )
         assertEquals( 4242, node.get( "id" ).asInt() );
     }
 
-    private static void assertFailToRunWrongStatement( RxTransaction tx )
+    private static void assertFailToRunWrongQuery(RxTransaction tx )
     {
         RxResult result = tx.run( "RETURN" );
         Exception e = assertThrows( Exception.class, () -> await( result.records() ) );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/DirectDriverBoltKitTest.java b/driver/src/test/java/org/neo4j/driver/internal/DirectDriverBoltKitTest.java
index acf4dad1e1..68b66c7123 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/DirectDriverBoltKitTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/DirectDriverBoltKitTest.java
@@ -156,7 +156,7 @@ void shouldLogConnectionIdInDebugMode() throws Exception
     }
 
     @Test
-    void shouldSendReadAccessModeInStatementMetadata() throws Exception
+    void shouldSendReadAccessModeInQueryMetadata() throws Exception
     {
         StubServer server = StubServer.start( "hello_run_exit_read.script", 9001 );
 
@@ -174,7 +174,7 @@ void shouldSendReadAccessModeInStatementMetadata() throws Exception
     }
 
     @Test
-    void shouldNotSendWriteAccessModeInStatementMetadata() throws Exception
+    void shouldNotSendWriteAccessModeInQueryMetadata() throws Exception
     {
         StubServer server = StubServer.start( "hello_run_exit.script", 9001 );
 
diff --git a/driver/src/test/java/org/neo4j/driver/internal/InternalResultTest.java b/driver/src/test/java/org/neo4j/driver/internal/InternalResultTest.java
index 3fc5454a7c..58f9c7329d 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/InternalResultTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/InternalResultTest.java
@@ -26,7 +26,7 @@
 import java.util.concurrent.CompletableFuture;
 
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Result;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.exceptions.NoSuchRecordException;
@@ -356,12 +356,12 @@ private Result createResult(int numberOfRecords )
         RunResponseHandler runHandler = new RunResponseHandler( new CompletableFuture<>(), METADATA_EXTRACTOR );
         runHandler.onSuccess( singletonMap( "fields", value( Arrays.asList( "k1", "k2" ) ) ) );
 
-        Statement statement = new Statement( "" );
+        Query query = new Query( "" );
         Connection connection = mock( Connection.class );
         when( connection.serverAddress() ).thenReturn( LOCAL_DEFAULT );
         when( connection.serverVersion() ).thenReturn( anyServerVersion() );
         PullAllResponseHandler pullAllHandler =
-                new LegacyPullAllResponseHandler( statement, runHandler, connection, METADATA_EXTRACTOR, mock( PullResponseCompletionListener.class ) );
+                new LegacyPullAllResponseHandler(query, runHandler, connection, METADATA_EXTRACTOR, mock( PullResponseCompletionListener.class ) );
 
         for ( int i = 1; i <= numberOfRecords; i++ )
         {
diff --git a/driver/src/test/java/org/neo4j/driver/internal/InternalTransactionTest.java b/driver/src/test/java/org/neo4j/driver/internal/InternalTransactionTest.java
index 4b8b20b37d..903f2b8c36 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/InternalTransactionTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/InternalTransactionTest.java
@@ -27,7 +27,7 @@
 import java.util.function.Function;
 import java.util.stream.Stream;
 
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.Value;
@@ -82,7 +82,7 @@ private static Stream> allSessionRunMethods()
                 tx -> tx.run( "RETURN $x", singletonMap( "x", 1 ) ),
                 tx -> tx.run( "RETURN $x",
                         new InternalRecord( singletonList( "x" ), new Value[]{new IntegerValue( 1 )} ) ),
-                tx -> tx.run( new Statement( "RETURN $x", parameters( "x", 1 ) ) )
+                tx -> tx.run( new Query( "RETURN $x", parameters( "x", 1 ) ) )
         );
     }
 
@@ -95,7 +95,7 @@ void shouldFlushOnRun( Function runReturnOne ) throws Throw
         Result result = runReturnOne.apply( tx );
         ResultSummary summary = result.consume();
 
-        verifyRunAndPull( connection, summary.statement().text() );
+        verifyRunAndPull( connection, summary.query().text() );
     }
 
     @Test
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/AsyncResultCursorImplTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/AsyncResultCursorImplTest.java
index ac3eb85695..ac89dff550 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/AsyncResultCursorImplTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/AsyncResultCursorImplTest.java
@@ -28,7 +28,7 @@
 import java.util.function.Function;
 
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.exceptions.NoSuchRecordException;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
 import org.neo4j.driver.internal.BoltServerAddress;
@@ -41,7 +41,7 @@
 import org.neo4j.driver.internal.summary.InternalServerInfo;
 import org.neo4j.driver.internal.summary.InternalSummaryCounters;
 import org.neo4j.driver.summary.ResultSummary;
-import org.neo4j.driver.summary.StatementType;
+import org.neo4j.driver.summary.QueryType;
 
 import static java.util.Arrays.asList;
 import static java.util.Collections.emptyList;
@@ -68,7 +68,7 @@
 class AsyncResultCursorImplTest
 {
     @Test
-    void shouldReturnStatementKeys()
+    void shouldReturnQueryKeys()
     {
         RunResponseHandler runHandler = newRunResponseHandler();
         PullAllResponseHandler pullAllHandler = mock( PullAllResponseHandler.class );
@@ -86,8 +86,8 @@ void shouldReturnSummary()
     {
         PullAllResponseHandler pullAllHandler = mock( PullAllResponseHandler.class );
 
-        ResultSummary summary = new InternalResultSummary( new Statement( "RETURN 42" ),
-                new InternalServerInfo( BoltServerAddress.LOCAL_DEFAULT, anyServerVersion() ), DEFAULT_DATABASE_INFO, StatementType.SCHEMA_WRITE,
+        ResultSummary summary = new InternalResultSummary( new Query( "RETURN 42" ),
+                new InternalServerInfo( BoltServerAddress.LOCAL_DEFAULT, anyServerVersion() ), DEFAULT_DATABASE_INFO, QueryType.SCHEMA_WRITE,
                 new InternalSummaryCounters( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0 ),
                 null, null, emptyList(), 42, 42 );
         when( pullAllHandler.consumeAsync() ).thenReturn( completedFuture( summary ) );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncSessionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncSessionTest.java
index ed72a69018..bfd4e65a1d 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncSessionTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncSessionTest.java
@@ -30,7 +30,7 @@
 import java.util.stream.Stream;
 
 import org.neo4j.driver.AccessMode;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.async.AsyncSession;
@@ -105,8 +105,8 @@ private static Stream>> allS
                 session -> session.runAsync( "RETURN $x", singletonMap( "x", 1 ) ),
                 session -> session.runAsync( "RETURN $x",
                         new InternalRecord( singletonList( "x" ), new Value[]{new IntegerValue( 1 )} ) ),
-                session -> session.runAsync( new Statement( "RETURN $x", parameters( "x", 1 ) ) ),
-                session -> session.runAsync( new Statement( "RETURN $x", parameters( "x", 1 ) ), empty() ),
+                session -> session.runAsync( new Query( "RETURN $x", parameters( "x", 1 ) ) ),
+                session -> session.runAsync( new Query( "RETURN $x", parameters( "x", 1 ) ), empty() ),
                 session -> session.runAsync( "RETURN $x", singletonMap( "x", 1 ), empty() ),
                 session -> session.runAsync( "RETURN 1", empty() )
         );
@@ -138,7 +138,7 @@ void shouldFlushOnRun( Function> runR
 
         ResultCursor cursor = await( runReturnOne.apply( asyncSession ) );
 
-        verifyRunAndPull( connection, await( cursor.consumeAsync() ).statement().text() );
+        verifyRunAndPull( connection, await( cursor.consumeAsync() ).query().text() );
     }
 
     @ParameterizedTest
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncTransactionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncTransactionTest.java
index 5c521f3580..ae2a043589 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncTransactionTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncTransactionTest.java
@@ -27,7 +27,7 @@
 import java.util.function.Function;
 import java.util.stream.Stream;
 
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.async.AsyncTransaction;
 import org.neo4j.driver.async.ResultCursor;
@@ -85,7 +85,7 @@ private static Stream>>
                 tx -> tx.runAsync( "RETURN $x", singletonMap( "x", 1 ) ),
                 tx -> tx.runAsync( "RETURN $x",
                         new InternalRecord( singletonList( "x" ), new Value[]{new IntegerValue( 1 )} ) ),
-                tx -> tx.runAsync( new Statement( "RETURN $x", parameters( "x", 1 ) ) )
+                tx -> tx.runAsync( new Query( "RETURN $x", parameters( "x", 1 ) ) )
         );
     }
 
@@ -98,7 +98,7 @@ void shouldFlushOnRun( Function>
         ResultCursor result = await( runReturnOne.apply( tx ) );
         ResultSummary summary = await( result.consumeAsync() );
 
-        verifyRunAndPull( connection, summary.statement().text() );
+        verifyRunAndPull( connection, summary.query().text() );
     }
 
     @Test
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/NetworkSessionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/NetworkSessionTest.java
index 318ed476ef..03c1edefd2 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/NetworkSessionTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/NetworkSessionTest.java
@@ -26,7 +26,7 @@
 import org.mockito.InOrder;
 
 import org.neo4j.driver.AccessMode;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.async.ResultCursor;
 import org.neo4j.driver.exceptions.ClientException;
@@ -93,7 +93,7 @@ void setUp()
     void shouldFlushOnRunAsync( boolean waitForResponse )
     {
         setupSuccessfulRunAndPull( connection );
-        await( session.runAsync( new Statement( "RETURN 1" ), TransactionConfig.empty(), waitForResponse ) );
+        await( session.runAsync( new Query( "RETURN 1" ), TransactionConfig.empty(), waitForResponse ) );
 
         verifyRunAndPull( connection, "RETURN 1" );
     }
@@ -102,7 +102,7 @@ void shouldFlushOnRunAsync( boolean waitForResponse )
     void shouldFlushOnRunRx()
     {
         setupSuccessfulRunRx( connection );
-        await( session.runRx( new Statement( "RETURN 1" ), TransactionConfig.empty() ) );
+        await( session.runRx( new Query( "RETURN 1" ), TransactionConfig.empty() ) );
 
         verifyRunRx( connection, "RETURN 1" );
     }
@@ -254,7 +254,7 @@ void releasesConnectionWhenTxIsClosed()
         setupSuccessfulRunAndPull( connection, query );
 
         UnmanagedTransaction tx = beginTransaction( session );
-        await( tx.runAsync( new Statement( query ), false ) );
+        await( tx.runAsync( new Query( query ), false ) );
 
         verify( connectionProvider ).acquireConnection( any( ConnectionContext.class ) );
         verifyRunAndPull( connection, query );
@@ -453,9 +453,9 @@ void shouldMarkTransactionAsTerminatedAndThenResetConnectionOnReset()
         verify( connection ).reset();
     }
 
-    private static ResultCursor run(NetworkSession session, String statement )
+    private static ResultCursor run(NetworkSession session, String query )
     {
-        return await( session.runAsync( new Statement( statement ), TransactionConfig.empty(), false ) );
+        return await( session.runAsync( new Query( query ), TransactionConfig.empty(), false ) );
     }
 
     private static UnmanagedTransaction beginTransaction(NetworkSession session )
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/UnmanagedTransactionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/UnmanagedTransactionTest.java
index 4ead228ec7..01bb90fb47 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/UnmanagedTransactionTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/UnmanagedTransactionTest.java
@@ -26,7 +26,7 @@
 import java.util.function.Consumer;
 
 import org.neo4j.driver.Bookmark;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.internal.DefaultBookmarkHolder;
@@ -52,7 +52,7 @@
 import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE;
 import static org.neo4j.driver.util.TestUtil.await;
 import static org.neo4j.driver.util.TestUtil.connectionMock;
-import static org.neo4j.driver.util.TestUtil.runMessageWithStatementMatcher;
+import static org.neo4j.driver.util.TestUtil.runMessageWithQueryMatcher;
 import static org.neo4j.driver.util.TestUtil.setupSuccessfulRunAndPull;
 import static org.neo4j.driver.util.TestUtil.setupSuccessfulRunRx;
 import static org.neo4j.driver.util.TestUtil.verifyRunAndPull;
@@ -70,7 +70,7 @@ void shouldFlushOnRunAsync( boolean waitForResponse )
         setupSuccessfulRunAndPull( connection );
 
         // When
-        await( tx.runAsync( new Statement( "RETURN 1" ), waitForResponse ) );
+        await( tx.runAsync( new Query( "RETURN 1" ), waitForResponse ) );
 
         // Then
         verifyRunAndPull( connection, "RETURN 1" );
@@ -85,7 +85,7 @@ void shouldFlushOnRunRx()
         setupSuccessfulRunRx( connection );
 
         // When
-        await( tx.runRx( new Statement( "RETURN 1" ) ) );
+        await( tx.runRx( new Query( "RETURN 1" ) ) );
 
         // Then
         verifyRunRx( connection, "RETURN 1" );
@@ -247,7 +247,7 @@ private static Connection connectionWithBegin( Consumer beginBe
             ResponseHandler beginHandler = invocation.getArgument( 3 );
             beginBehaviour.accept( beginHandler );
             return null;
-        } ).when( connection ).writeAndFlush( argThat( runMessageWithStatementMatcher( "BEGIN" ) ), any(), any(), any() );
+        } ).when( connection ).writeAndFlush( argThat( runMessageWithQueryMatcher( "BEGIN" ) ), any(), any(), any() );
 
         return connection;
     }
diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/MultiDatabasesRoutingProcedureRunnerTest.java b/driver/src/test/java/org/neo4j/driver/internal/cluster/MultiDatabasesRoutingProcedureRunnerTest.java
index 36b7921b4f..705968a0c0 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/cluster/MultiDatabasesRoutingProcedureRunnerTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/cluster/MultiDatabasesRoutingProcedureRunnerTest.java
@@ -27,8 +27,8 @@
 import java.util.concurrent.CompletionStage;
 
 import org.neo4j.driver.AccessMode;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.internal.BookmarkHolder;
 import org.neo4j.driver.internal.ReadOnlyBookmarkHolder;
@@ -69,8 +69,8 @@ void shouldCallGetRoutingTableWithEmptyMapOnSystemDatabaseForDatabase( String db
         assertThat( runner.connection.databaseName(), equalTo( systemDatabase() ) );
         assertThat( runner.connection.mode(), equalTo( AccessMode.READ ) );
 
-        Statement statement = generateMultiDatabaseRoutingStatement( EMPTY_MAP, db );
-        assertThat( runner.procedure, equalTo( statement ) );
+        Query query = generateMultiDatabaseRoutingQuery( EMPTY_MAP, db );
+        assertThat( runner.procedure, equalTo(query) );
     }
 
     @ParameterizedTest
@@ -90,9 +90,9 @@ void shouldCallGetRoutingTableWithParamOnSystemDatabaseForDatabase( String db )
         assertThat( runner.connection.databaseName(), equalTo( systemDatabase() ) );
         assertThat( runner.connection.mode(), equalTo( AccessMode.READ ) );
 
-        Statement statement = generateMultiDatabaseRoutingStatement( context.asMap(), db );
-        assertThat( response.procedure(), equalTo( statement ) );
-        assertThat( runner.procedure, equalTo( statement ) );
+        Query query = generateMultiDatabaseRoutingQuery( context.asMap(), db );
+        assertThat( response.procedure(), equalTo(query) );
+        assertThat( runner.procedure, equalTo(query) );
     }
 
     @Override
@@ -107,17 +107,17 @@ RoutingProcedureRunner routingProcedureRunner( RoutingContext context, Completio
         return new TestRoutingProcedureRunner( context, runProcedureResult );
     }
 
-    private static Statement generateMultiDatabaseRoutingStatement( Map context, String db )
+    private static Query generateMultiDatabaseRoutingQuery(Map context, String db )
     {
         Value parameters = parameters( ROUTING_CONTEXT, context, DATABASE_NAME, db );
-        return new Statement( MULTI_DB_GET_ROUTING_TABLE, parameters );
+        return new Query( MULTI_DB_GET_ROUTING_TABLE, parameters );
     }
 
     private static class TestRoutingProcedureRunner extends MultiDatabasesRoutingProcedureRunner
     {
         final CompletionStage> runProcedureResult;
         private Connection connection;
-        private Statement procedure;
+        private Query procedure;
         private BookmarkHolder bookmarkHolder;
 
         TestRoutingProcedureRunner( RoutingContext context )
@@ -132,7 +132,7 @@ private static class TestRoutingProcedureRunner extends MultiDatabasesRoutingPro
         }
 
         @Override
-        CompletionStage> runProcedure( Connection connection, Statement procedure, BookmarkHolder bookmarkHolder )
+        CompletionStage> runProcedure(Connection connection, Query procedure, BookmarkHolder bookmarkHolder )
         {
             this.connection = connection;
             this.procedure = procedure;
diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProviderTest.java b/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProviderTest.java
index 858fb4870e..56f51ee800 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProviderTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProviderTest.java
@@ -25,8 +25,8 @@
 import java.util.Map;
 import java.util.Set;
 
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.exceptions.ProtocolException;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
@@ -293,12 +293,12 @@ private static MultiDatabasesRoutingProcedureRunner newMultiDBProcedureRunnerMoc
 
     private static RoutingProcedureResponse newRoutingResponse( Record... records )
     {
-        return new RoutingProcedureResponse( new Statement( "procedure" ), asList( records ) );
+        return new RoutingProcedureResponse( new Query( "procedure" ), asList( records ) );
     }
 
     private static RoutingProcedureResponse newRoutingResponse( Throwable error )
     {
-        return new RoutingProcedureResponse( new Statement( "procedure" ), error );
+        return new RoutingProcedureResponse( new Query( "procedure" ), error );
     }
     
     private static RoutingProcedureClusterCompositionProvider newClusterCompositionProvider( RoutingProcedureRunner runner, Connection connection )
diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureResponseTest.java b/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureResponseTest.java
index 98ed599852..e0eb6e4e99 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureResponseTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureResponseTest.java
@@ -23,7 +23,7 @@
 import org.neo4j.driver.internal.InternalRecord;
 import org.neo4j.driver.internal.value.StringValue;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Value;
 
 import static java.util.Arrays.asList;
@@ -34,7 +34,7 @@
 
 class RoutingProcedureResponseTest
 {
-    private static final Statement PROCEDURE = new Statement( "procedure" );
+    private static final Query PROCEDURE = new Query( "procedure" );
 
     private static final Record RECORD_1 = new InternalRecord( asList( "a", "b" ),
             new Value[]{new StringValue( "a" ), new StringValue( "b" )} );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureRunnerTest.java b/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureRunnerTest.java
index 71b8089b1e..d1fc101544 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureRunnerTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureRunnerTest.java
@@ -29,8 +29,8 @@
 import java.util.stream.Stream;
 
 import org.neo4j.driver.AccessMode;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.exceptions.FatalDiscoveryException;
 import org.neo4j.driver.internal.BookmarkHolder;
@@ -69,8 +69,8 @@ void shouldCallGetRoutingTableWithEmptyMap()
         assertThat( runner.connection.databaseName(), equalTo( defaultDatabase() ) );
         assertThat( runner.connection.mode(), equalTo( AccessMode.WRITE ) );
 
-        Statement statement = generateRoutingStatement( EMPTY_MAP );
-        assertThat( runner.procedure, equalTo( statement ) );
+        Query query = generateRoutingQuery( EMPTY_MAP );
+        assertThat( runner.procedure, equalTo(query) );
     }
 
     @Test
@@ -89,9 +89,9 @@ void shouldCallGetRoutingTableWithParam()
         assertThat( runner.connection.databaseName(), equalTo( defaultDatabase() ) );
         assertThat( runner.connection.mode(), equalTo( AccessMode.WRITE ) );
 
-        Statement statement = generateRoutingStatement( context.asMap() );
-        assertThat( response.procedure(), equalTo( statement ) );
-        assertThat( runner.procedure, equalTo( statement ) );
+        Query query = generateRoutingQuery( context.asMap() );
+        assertThat( response.procedure(), equalTo(query) );
+        assertThat( runner.procedure, equalTo(query) );
     }
 
     @ParameterizedTest
@@ -117,17 +117,17 @@ private static Stream invalidDatabaseNames()
         return Stream.of( SYSTEM_DATABASE_NAME, "This is a string", "null" );
     }
 
-    private static Statement generateRoutingStatement( Map context )
+    private static Query generateRoutingQuery(Map context )
     {
         Value parameters = parameters( ROUTING_CONTEXT, context );
-        return new Statement( GET_ROUTING_TABLE, parameters );
+        return new Query( GET_ROUTING_TABLE, parameters );
     }
 
     private static class TestRoutingProcedureRunner extends RoutingProcedureRunner
     {
         final CompletionStage> runProcedureResult;
         private Connection connection;
-        private Statement procedure;
+        private Query procedure;
         private BookmarkHolder bookmarkHolder;
 
         TestRoutingProcedureRunner( RoutingContext context )
@@ -142,7 +142,7 @@ private static class TestRoutingProcedureRunner extends RoutingProcedureRunner
         }
 
         @Override
-        CompletionStage> runProcedure( Connection connection, Statement procedure, BookmarkHolder bookmarkHolder )
+        CompletionStage> runProcedure(Connection connection, Query procedure, BookmarkHolder bookmarkHolder )
         {
             this.connection = connection;
             this.procedure = procedure;
diff --git a/driver/src/test/java/org/neo4j/driver/internal/cursor/RxResultCursorImplTest.java b/driver/src/test/java/org/neo4j/driver/internal/cursor/RxResultCursorImplTest.java
index 95f812278c..c64ee56c36 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/cursor/RxResultCursorImplTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/cursor/RxResultCursorImplTest.java
@@ -80,7 +80,7 @@ void shouldInstallSummaryConsumerWithoutReportingError() throws Throwable
     }
 
     @Test
-    void shouldReturnStatementKeys() throws Throwable
+    void shouldReturnQueryKeys() throws Throwable
     {
         // Given
         RunResponseHandler runHandler = newRunResponseHandler();
@@ -98,7 +98,7 @@ void shouldReturnStatementKeys() throws Throwable
     }
 
     @Test
-    void shouldSupportReturnStatementKeysMultipleTimes() throws Throwable
+    void shouldSupportReturnQueryKeysMultipleTimes() throws Throwable
     {
         // Given
         RunResponseHandler runHandler = newRunResponseHandler();
diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/LegacyPullAllResponseHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/LegacyPullAllResponseHandlerTest.java
index a9f243e676..cad49adf60 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/handlers/LegacyPullAllResponseHandlerTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/handlers/LegacyPullAllResponseHandlerTest.java
@@ -25,7 +25,7 @@
 import java.util.function.Function;
 
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.internal.spi.Connection;
 import org.neo4j.driver.summary.ResultSummary;
 
@@ -234,11 +234,11 @@ void shouldEnableAutoReadOnConnectionWhenSummaryRequestedButNotAvailable() throw
         assertNotNull( summaryFuture.get() );
     }
 
-    protected LegacyPullAllResponseHandler newHandler( Statement statement, List statementKeys,
-            Connection connection )
+    protected LegacyPullAllResponseHandler newHandler(Query query, List queryKeys,
+                                                      Connection connection )
     {
         RunResponseHandler runResponseHandler = new RunResponseHandler( new CompletableFuture<>(), METADATA_EXTRACTOR );
-        runResponseHandler.onSuccess( singletonMap( "fields", value( statementKeys ) ) );
-        return new LegacyPullAllResponseHandler( statement, runResponseHandler, connection, METADATA_EXTRACTOR, mock( PullResponseCompletionListener.class ) );
+        runResponseHandler.onSuccess( singletonMap( "fields", value( queryKeys ) ) );
+        return new LegacyPullAllResponseHandler(query, runResponseHandler, connection, METADATA_EXTRACTOR, mock( PullResponseCompletionListener.class ) );
     }
 }
diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/PullAllResponseHandlerTestBase.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/PullAllResponseHandlerTestBase.java
index 15ea22f33f..a7733e7629 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/handlers/PullAllResponseHandlerTestBase.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/handlers/PullAllResponseHandlerTestBase.java
@@ -27,8 +27,8 @@
 import java.util.concurrent.CompletionStage;
 import java.util.function.Function;
 
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
 import org.neo4j.driver.exceptions.SessionExpiredException;
@@ -36,7 +36,7 @@
 import org.neo4j.driver.internal.InternalRecord;
 import org.neo4j.driver.internal.spi.Connection;
 import org.neo4j.driver.summary.ResultSummary;
-import org.neo4j.driver.summary.StatementType;
+import org.neo4j.driver.summary.QueryType;
 
 import static java.util.Arrays.asList;
 import static java.util.Collections.emptyList;
@@ -160,8 +160,8 @@ void shouldReturnFailureOnlyOnceWhenFailedAfterFailureRequested()
     @Test
     void shouldReturnSummaryWhenAlreadyFailedAndFailureConsumed()
     {
-        Statement statement = new Statement( "CREATE ()" );
-        PullAllResponseHandler handler = newHandler( statement );
+        Query query = new Query( "CREATE ()" );
+        PullAllResponseHandler handler = newHandler(query);
 
         ServiceUnavailableException failure = new ServiceUnavailableException( "Neo4j unreachable" );
         handler.onFailure( failure );
@@ -170,27 +170,27 @@ void shouldReturnSummaryWhenAlreadyFailedAndFailureConsumed()
 
         ResultSummary summary = await( handler.consumeAsync() );
         assertNotNull( summary );
-        assertEquals( statement, summary.statement() );
+        assertEquals(query, summary.query() );
     }
 
     @Test
     void shouldReturnSummaryWhenAlreadySucceeded()
     {
-        Statement statement = new Statement( "CREATE () RETURN 42" );
-        PullAllResponseHandler handler = newHandler( statement );
+        Query query = new Query( "CREATE () RETURN 42" );
+        PullAllResponseHandler handler = newHandler(query);
         handler.onSuccess( singletonMap( "type", value( "rw" ) ) );
 
         ResultSummary summary = await( handler.consumeAsync() );
 
-        assertEquals( statement, summary.statement() );
-        assertEquals( StatementType.READ_WRITE, summary.statementType() );
+        assertEquals(query, summary.query() );
+        assertEquals( QueryType.READ_WRITE, summary.queryType() );
     }
 
     @Test
     void shouldReturnSummaryWhenSucceededAfterSummaryRequested()
     {
-        Statement statement = new Statement( "RETURN 'Hi!" );
-        PullAllResponseHandler handler = newHandler( statement );
+        Query query = new Query( "RETURN 'Hi!" );
+        PullAllResponseHandler handler = newHandler(query);
 
         CompletableFuture summaryFuture = handler.consumeAsync().toCompletableFuture();
         assertFalse( summaryFuture.isDone() );
@@ -200,8 +200,8 @@ void shouldReturnSummaryWhenSucceededAfterSummaryRequested()
         assertTrue( summaryFuture.isDone() );
         ResultSummary summary = await( summaryFuture );
 
-        assertEquals( statement, summary.statement() );
-        assertEquals( StatementType.READ_ONLY, summary.statementType() );
+        assertEquals(query, summary.query() );
+        assertEquals( QueryType.READ_ONLY, summary.queryType() );
     }
 
     @Test
@@ -258,8 +258,8 @@ void shouldFailSummaryWhenRequestedMultipleTimes()
     @Test
     void shouldPropagateFailureOnlyOnceFromSummary()
     {
-        Statement statement = new Statement( "CREATE INDEX ON :Person(name)" );
-        PullAllResponseHandler handler = newHandler( statement );
+        Query query = new Query( "CREATE INDEX ON :Person(name)" );
+        PullAllResponseHandler handler = newHandler(query);
 
         IllegalStateException failure = new IllegalStateException( "Some state is illegal :(" );
         handler.onFailure( failure );
@@ -269,7 +269,7 @@ void shouldPropagateFailureOnlyOnceFromSummary()
 
         ResultSummary summary = await( handler.consumeAsync() );
         assertNotNull( summary );
-        assertEquals( statement, summary.statement() );
+        assertEquals(query, summary.query() );
     }
 
     @Test
@@ -682,30 +682,30 @@ void shouldReturnNotTransformedListInListAsync()
 
     protected T newHandler()
     {
-        return newHandler( new Statement( "RETURN 1" ) );
+        return newHandler( new Query( "RETURN 1" ) );
     }
 
-    protected T newHandler( Statement statement )
+    protected T newHandler( Query query)
     {
-        return newHandler( statement, emptyList() );
+        return newHandler(query, emptyList() );
     }
 
-    protected T newHandler( List statementKeys )
+    protected T newHandler( List queryKeys )
     {
-        return newHandler( new Statement( "RETURN 1" ), statementKeys, connectionMock() );
+        return newHandler( new Query( "RETURN 1" ), queryKeys, connectionMock() );
     }
 
-    protected T newHandler( Statement statement, List statementKeys )
+    protected T newHandler(Query query, List queryKeys )
     {
-        return newHandler( statement, statementKeys, connectionMock() );
+        return newHandler(query, queryKeys, connectionMock() );
     }
 
-    protected T newHandler( List statementKeys, Connection connection )
+    protected T newHandler( List queryKeys, Connection connection )
     {
-        return newHandler( new Statement( "RETURN 1" ), statementKeys, connection );
+        return newHandler( new Query( "RETURN 1" ), queryKeys, connection );
     }
 
-    protected abstract T newHandler( Statement statement, List statementKeys, Connection connection );
+    protected abstract T newHandler(Query query, List queryKeys, Connection connection );
 
     protected Connection connectionMock()
     {
diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/RunResponseHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/RunResponseHandlerTest.java
index 947d928ce2..15b14fe29f 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/handlers/RunResponseHandlerTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/handlers/RunResponseHandlerTest.java
@@ -83,7 +83,7 @@ void shouldReturnNoKeysWhenFailed()
 
         handler.onFailure( new RuntimeException() );
 
-        assertEquals( emptyList(), handler.statementKeys() );
+        assertEquals( emptyList(), handler.queryKeys() );
     }
 
     @Test
@@ -104,7 +104,7 @@ void shouldReturnKeysWhenSucceeded()
         List keys = asList( "key1", "key2", "key3" );
         handler.onSuccess( singletonMap( "fields", value( keys ) ) );
 
-        assertEquals( keys, handler.statementKeys() );
+        assertEquals( keys, handler.queryKeys() );
     }
 
     @Test
diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/SessionPullResponseCompletionListenerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/SessionPullResponseCompletionListenerTest.java
index eda0779029..5c289e0131 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/handlers/SessionPullResponseCompletionListenerTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/handlers/SessionPullResponseCompletionListenerTest.java
@@ -22,7 +22,7 @@
 
 import java.util.concurrent.CompletableFuture;
 
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.internal.BoltServerAddress;
 import org.neo4j.driver.internal.BookmarkHolder;
 import org.neo4j.driver.internal.InternalBookmark;
@@ -83,7 +83,7 @@ private static ResponseHandler newHandler( Connection connection, PullResponseCo
     {
         RunResponseHandler runHandler = new RunResponseHandler( new CompletableFuture<>(), METADATA_EXTRACTOR );
         BasicPullResponseHandler handler =
-                new BasicPullResponseHandler( new Statement( "RETURN 1" ), runHandler, connection, METADATA_EXTRACTOR, listener );
+                new BasicPullResponseHandler( new Query( "RETURN 1" ), runHandler, connection, METADATA_EXTRACTOR, listener );
         handler.installRecordConsumer( ( record, throwable ) -> {} );
         handler.installSummaryConsumer( ( resultSummary, throwable ) -> {} );
         return handler;
diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListenerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListenerTest.java
index 068fcdf4c5..d0e468777f 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListenerTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListenerTest.java
@@ -23,7 +23,7 @@
 import java.io.IOException;
 import java.util.concurrent.CompletableFuture;
 
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
 import org.neo4j.driver.exceptions.SessionExpiredException;
@@ -66,7 +66,7 @@ private static void testErrorHandling( Throwable error )
         UnmanagedTransaction tx = mock( UnmanagedTransaction.class );
         TransactionPullResponseCompletionListener listener = new TransactionPullResponseCompletionListener( tx );
         RunResponseHandler runHandler = new RunResponseHandler( new CompletableFuture<>(), METADATA_EXTRACTOR );
-        PullResponseHandler handler = new BasicPullResponseHandler( new Statement( "RETURN 1" ), runHandler,
+        PullResponseHandler handler = new BasicPullResponseHandler( new Query( "RETURN 1" ), runHandler,
                 connection, METADATA_EXTRACTOR, listener );
         handler.installRecordConsumer( ( record, throwable ) -> {} );
         handler.installSummaryConsumer( ( resultSummary, throwable ) -> {} );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/AutoPullResponseHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/AutoPullResponseHandlerTest.java
index ae3e3c0c07..1a0b3ce12a 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/AutoPullResponseHandlerTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/AutoPullResponseHandlerTest.java
@@ -21,7 +21,7 @@
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.internal.handlers.PullAllResponseHandlerTestBase;
 import org.neo4j.driver.internal.handlers.PullResponseCompletionListener;
 import org.neo4j.driver.internal.handlers.RunResponseHandler;
@@ -36,12 +36,12 @@
 class AutoPullResponseHandlerTest extends PullAllResponseHandlerTestBase
 {
     @Override
-    protected AutoPullResponseHandler newHandler( Statement statement, List statementKeys, Connection connection )
+    protected AutoPullResponseHandler newHandler(Query query, List queryKeys, Connection connection )
     {
         RunResponseHandler runResponseHandler = new RunResponseHandler( new CompletableFuture<>(), METADATA_EXTRACTOR );
-        runResponseHandler.onSuccess( singletonMap( "fields", value( statementKeys ) ) );
+        runResponseHandler.onSuccess( singletonMap( "fields", value(queryKeys) ) );
         AutoPullResponseHandler handler =
-                new AutoPullResponseHandler( statement, runResponseHandler, connection, METADATA_EXTRACTOR, mock( PullResponseCompletionListener.class ),
+                new AutoPullResponseHandler(query, runResponseHandler, connection, METADATA_EXTRACTOR, mock( PullResponseCompletionListener.class ),
                         DEFAULT_FETCH_SIZE );
         handler.prePopulateRecords();
         return handler;
diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/SessionPullResponseCompletionListenerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/SessionPullResponseCompletionListenerTest.java
index c748cfe6cd..927fef48ca 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/SessionPullResponseCompletionListenerTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/SessionPullResponseCompletionListenerTest.java
@@ -22,7 +22,7 @@
 import java.util.function.BiConsumer;
 
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.internal.BookmarkHolder;
 import org.neo4j.driver.internal.handlers.RunResponseHandler;
 import org.neo4j.driver.internal.handlers.SessionPullResponseCompletionListener;
@@ -96,7 +96,7 @@ private static BasicPullResponseHandler newSessionResponseHandler( Connection co
         RunResponseHandler runHandler = mock( RunResponseHandler.class );
         SessionPullResponseCompletionListener listener = new SessionPullResponseCompletionListener( conn, bookmarkHolder );
         BasicPullResponseHandler handler =
-                new BasicPullResponseHandler( mock( Statement.class ), runHandler, conn, BoltProtocolV4.METADATA_EXTRACTOR, listener );
+                new BasicPullResponseHandler( mock( Query.class ), runHandler, conn, BoltProtocolV4.METADATA_EXTRACTOR, listener );
 
         handler.installRecordConsumer( recordConsumer );
         handler.installSummaryConsumer( summaryConsumer );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/TransactionPullResponseCompletionListenerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/TransactionPullResponseCompletionListenerTest.java
index e472f1a062..341b524b6c 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/TransactionPullResponseCompletionListenerTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/TransactionPullResponseCompletionListenerTest.java
@@ -21,8 +21,8 @@
 import java.util.Collections;
 import java.util.function.BiConsumer;
 
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.internal.async.UnmanagedTransaction;
 import org.neo4j.driver.internal.handlers.RunResponseHandler;
 import org.neo4j.driver.internal.handlers.TransactionPullResponseCompletionListener;
@@ -94,7 +94,7 @@ private static BasicPullResponseHandler newTxResponseHandler(Connection conn, Bi
         RunResponseHandler runHandler = mock( RunResponseHandler.class );
         TransactionPullResponseCompletionListener listener = new TransactionPullResponseCompletionListener( tx );
         BasicPullResponseHandler handler =
-                new BasicPullResponseHandler( mock( Statement.class ), runHandler, conn, BoltProtocolV4.METADATA_EXTRACTOR, listener );
+                new BasicPullResponseHandler( mock( Query.class ), runHandler, conn, BoltProtocolV4.METADATA_EXTRACTOR, listener );
 
         handler.installRecordConsumer( recordConsumer );
         handler.installSummaryConsumer( summaryConsumer );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/DiscardMessageEncoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/DiscardMessageEncoderTest.java
index 3702895e15..4fdd4c8beb 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/DiscardMessageEncoderTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/DiscardMessageEncoderTest.java
@@ -68,7 +68,7 @@ void shouldEncodeDiscardMessage() throws Exception
     }
 
     @Test
-    void shouldAvoidStatementId() throws Throwable
+    void shouldAvoidQueryId() throws Throwable
     {
         encoder.encode( new DiscardMessage( 100, -1 ), packer );
 
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/PullMessageEncoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/PullMessageEncoderTest.java
index 624afb85d2..1e88444d97 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/PullMessageEncoderTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/PullMessageEncoderTest.java
@@ -67,7 +67,7 @@ void shouldEncodePullMessage() throws Exception
     }
 
     @Test
-    void shouldAvoidStatementId() throws Exception
+    void shouldAvoidQueryId() throws Exception
     {
         encoder.encode( new PullMessage( 100, -1 ), packer );
 
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/RunWithMetadataMessageEncoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/RunWithMetadataMessageEncoderTest.java
index 0226030abf..e567c1e2a6 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/RunWithMetadataMessageEncoderTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/RunWithMetadataMessageEncoderTest.java
@@ -29,7 +29,7 @@
 
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Bookmark;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.internal.InternalBookmark;
 import org.neo4j.driver.internal.messaging.ValuePacker;
@@ -65,8 +65,8 @@ void shouldEncodeRunWithMetadataMessage( AccessMode mode ) throws Exception
 
         Duration txTimeout = Duration.ofMillis( 42 );
 
-        Statement statement = new Statement( "RETURN $answer", value( params ) );
-        encoder.encode( autoCommitTxRunMessage( statement, txTimeout, txMetadata, defaultDatabase(), mode, bookmark ), packer );
+        Query query = new Query( "RETURN $answer", value( params ) );
+        encoder.encode( autoCommitTxRunMessage(query, txTimeout, txMetadata, defaultDatabase(), mode, bookmark ), packer );
 
         InOrder order = inOrder( packer );
         order.verify( packer ).packStructHeader( 3, RunWithMetadataMessage.SIGNATURE );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1Test.java
index c83744b5f3..e317daa278 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1Test.java
@@ -33,7 +33,7 @@
 
 import org.neo4j.driver.Bookmark;
 import org.neo4j.driver.Logging;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.exceptions.ClientException;
@@ -88,7 +88,7 @@ public class BoltProtocolV1Test
 {
     private static final String QUERY = "RETURN $x";
     private static final Map PARAMS = singletonMap( "x", value( 42 ) );
-    private static final Statement STATEMENT = new Statement( QUERY, value( PARAMS ) );
+    private static final Query QUERY = new Query( QUERY, value( PARAMS ) );
 
     private final BoltProtocol protocol = createProtocol();
     private final EmbeddedChannel channel = new EmbeddedChannel();
@@ -273,7 +273,7 @@ void shouldNotSupportTransactionConfigForAutoCommitTransactions()
                 .build();
 
         ClientException e = assertThrows( ClientException.class,
-                () -> protocol.runInAutoCommitTransaction( connectionMock( protocol ), new Statement( "RETURN 1" ), BookmarkHolder.NO_OP, config, true,
+                () -> protocol.runInAutoCommitTransaction( connectionMock( protocol ), new Query( "RETURN 1" ), BookmarkHolder.NO_OP, config, true,
                         UNLIMITED_FETCH_SIZE ) );
         assertThat( e.getMessage(), startsWith( "Driver is connected to the database that does not support transaction configuration" ) );
     }
@@ -292,7 +292,7 @@ void shouldNotSupportDatabaseNameForAutoCommitTransactions()
     {
         ClientException e = assertThrows( ClientException.class,
                 () -> protocol.runInAutoCommitTransaction( connectionMock( "foo", protocol ),
-                        new Statement( "RETURN 1" ), BookmarkHolder.NO_OP, TransactionConfig.empty(), true, UNLIMITED_FETCH_SIZE ) );
+                        new Query( "RETURN 1" ), BookmarkHolder.NO_OP, TransactionConfig.empty(), true, UNLIMITED_FETCH_SIZE ) );
         assertThat( e.getMessage(), startsWith( "Database name parameter for selecting database is not supported" ) );
     }
 
@@ -315,13 +315,13 @@ private void testRunWithoutWaitingForRunResponse( boolean autoCommitTx ) throws
         if ( autoCommitTx )
         {
             cursorStage = protocol
-                    .runInAutoCommitTransaction( connection, STATEMENT, BookmarkHolder.NO_OP, TransactionConfig.empty(), false, UNLIMITED_FETCH_SIZE )
+                    .runInAutoCommitTransaction( connection, QUERY, BookmarkHolder.NO_OP, TransactionConfig.empty(), false, UNLIMITED_FETCH_SIZE )
                     .asyncResult();
         }
         else
         {
             cursorStage = protocol
-                    .runInExplicitTransaction( connection, STATEMENT, mock( UnmanagedTransaction.class ), false, UNLIMITED_FETCH_SIZE )
+                    .runInExplicitTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), false, UNLIMITED_FETCH_SIZE )
                     .asyncResult();
         }
         CompletableFuture cursorFuture = cursorStage.toCompletableFuture();
@@ -339,12 +339,12 @@ private void testRunWithWaitingForResponse( boolean success, boolean session ) t
         CompletionStage cursorStage;
         if ( session )
         {
-            cursorStage = protocol.runInAutoCommitTransaction( connection, STATEMENT, BookmarkHolder.NO_OP, TransactionConfig.empty(), true, UNLIMITED_FETCH_SIZE )
+            cursorStage = protocol.runInAutoCommitTransaction( connection, QUERY, BookmarkHolder.NO_OP, TransactionConfig.empty(), true, UNLIMITED_FETCH_SIZE )
                     .asyncResult();
         }
         else
         {
-            cursorStage = protocol.runInExplicitTransaction( connection, STATEMENT, mock( UnmanagedTransaction.class ), true, UNLIMITED_FETCH_SIZE )
+            cursorStage = protocol.runInExplicitTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), true, UNLIMITED_FETCH_SIZE )
                     .asyncResult();
         }
         CompletableFuture cursorFuture = cursorStage.toCompletableFuture();
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java
index cf08cd36a9..69708763cf 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java
@@ -35,7 +35,7 @@
 import org.neo4j.driver.AccessMode;
 import org.neo4j.driver.Bookmark;
 import org.neo4j.driver.Logging;
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.exceptions.ClientException;
@@ -95,7 +95,7 @@ public class BoltProtocolV3Test
 {
     protected static final String QUERY = "RETURN $x";
     protected static final Map PARAMS = singletonMap( "x", value( 42 ) );
-    protected static final Statement STATEMENT = new Statement( QUERY, value( PARAMS ) );
+    protected static final Query QUERY = new Query( QUERY, value( PARAMS ) );
 
     protected final BoltProtocol protocol = createProtocol();
     private final EmbeddedChannel channel = new EmbeddedChannel();
@@ -342,7 +342,7 @@ protected void testDatabaseNameSupport( boolean autoCommitTx )
         if ( autoCommitTx )
         {
             e = assertThrows( ClientException.class,
-                    () -> protocol.runInAutoCommitTransaction( connectionMock( "foo", protocol ), new Statement( "RETURN 1" ), BookmarkHolder.NO_OP,
+                    () -> protocol.runInAutoCommitTransaction( connectionMock( "foo", protocol ), new Query( "RETURN 1" ), BookmarkHolder.NO_OP,
                             TransactionConfig.empty(), true, UNLIMITED_FETCH_SIZE ) );
         }
         else
@@ -360,7 +360,7 @@ protected void testRunInExplicitTransactionAndWaitForRunResponse( boolean succes
         Connection connection = connectionMock( mode, protocol );
 
         CompletableFuture cursorFuture =
-                protocol.runInExplicitTransaction( connection, STATEMENT, mock( UnmanagedTransaction.class ), true, UNLIMITED_FETCH_SIZE ).asyncResult().toCompletableFuture();
+                protocol.runInExplicitTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), true, UNLIMITED_FETCH_SIZE ).asyncResult().toCompletableFuture();
 
         ResponseHandler runResponseHandler = verifyRunInvoked( connection, false, InternalBookmark.empty(), TransactionConfig.empty(), mode ).runHandler;
         assertFalse( cursorFuture.isDone() );
@@ -389,11 +389,11 @@ protected void testRunWithoutWaitingForRunResponse( boolean autoCommitTx, Transa
         if ( autoCommitTx )
         {
             BookmarkHolder bookmarkHolder = new DefaultBookmarkHolder( initialBookmark );
-            cursorStage = protocol.runInAutoCommitTransaction( connection, STATEMENT, bookmarkHolder, config, false, UNLIMITED_FETCH_SIZE ).asyncResult();
+            cursorStage = protocol.runInAutoCommitTransaction( connection, QUERY, bookmarkHolder, config, false, UNLIMITED_FETCH_SIZE ).asyncResult();
         }
         else
         {
-            cursorStage = protocol.runInExplicitTransaction( connection, STATEMENT, mock( UnmanagedTransaction.class ), false, UNLIMITED_FETCH_SIZE ).asyncResult();
+            cursorStage = protocol.runInExplicitTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), false, UNLIMITED_FETCH_SIZE ).asyncResult();
         }
         CompletableFuture cursorFuture = cursorStage.toCompletableFuture();
 
@@ -416,7 +416,7 @@ protected void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( Bookmark b
         BookmarkHolder bookmarkHolder = new DefaultBookmarkHolder( bookmark );
 
         CompletableFuture cursorFuture =
-                protocol.runInAutoCommitTransaction( connection, STATEMENT, bookmarkHolder, config, true, UNLIMITED_FETCH_SIZE )
+                protocol.runInAutoCommitTransaction( connection, QUERY, bookmarkHolder, config, true, UNLIMITED_FETCH_SIZE )
                         .asyncResult()
                         .toCompletableFuture();
         assertFalse( cursorFuture.isDone() );
@@ -438,7 +438,7 @@ protected void testFailedRunInAutoCommitTxWithWaitingForResponse( Bookmark bookm
         BookmarkHolder bookmarkHolder = new DefaultBookmarkHolder( bookmark );
 
         CompletableFuture cursorFuture =
-                protocol.runInAutoCommitTransaction( connection, STATEMENT, bookmarkHolder, config, true, UNLIMITED_FETCH_SIZE )
+                protocol.runInAutoCommitTransaction( connection, QUERY, bookmarkHolder, config, true, UNLIMITED_FETCH_SIZE )
                         .asyncResult()
                         .toCompletableFuture();
         assertFalse( cursorFuture.isDone() );
@@ -467,11 +467,11 @@ private static ResponseHandlers verifyRunInvoked( Connection connection, boolean
         RunWithMetadataMessage expectedMessage;
         if ( session )
         {
-            expectedMessage = RunWithMetadataMessage.autoCommitTxRunMessage( STATEMENT, config, defaultDatabase(), mode, bookmark );
+            expectedMessage = RunWithMetadataMessage.autoCommitTxRunMessage(QUERY, config, defaultDatabase(), mode, bookmark );
         }
         else
         {
-            expectedMessage = RunWithMetadataMessage.explicitTxRunMessage( STATEMENT );
+            expectedMessage = RunWithMetadataMessage.explicitTxRunMessage(QUERY);
         }
 
         verify( connection ).write( eq( expectedMessage ), runHandlerCaptor.capture() );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageWriterV3Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageWriterV3Test.java
index 3f05cf4d6a..75b29d5456 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageWriterV3Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageWriterV3Test.java
@@ -21,7 +21,7 @@
 import java.time.ZonedDateTime;
 import java.util.stream.Stream;
 
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.internal.InternalBookmark;
 import org.neo4j.driver.internal.messaging.Message;
 import org.neo4j.driver.internal.messaging.MessageFormat;
@@ -70,21 +70,21 @@ protected Stream supportedMessages()
                 new BeginMessage( InternalBookmark.parse( "neo4j:bookmark:v1:tx123" ), ofSeconds( 5 ), singletonMap( "key", value( 42 ) ), WRITE, defaultDatabase() ),
                 COMMIT,
                 ROLLBACK,
-                autoCommitTxRunMessage( new Statement( "RETURN 1" ), ofSeconds( 5 ), singletonMap( "key", value( 42 ) ), defaultDatabase(), READ,
+                autoCommitTxRunMessage( new Query( "RETURN 1" ), ofSeconds( 5 ), singletonMap( "key", value( 42 ) ), defaultDatabase(), READ,
                         InternalBookmark.parse( "neo4j:bookmark:v1:tx1" ) ),
-                autoCommitTxRunMessage( new Statement( "RETURN 1" ), ofSeconds( 5 ), singletonMap( "key", value( 42 ) ), defaultDatabase(), WRITE,
+                autoCommitTxRunMessage( new Query( "RETURN 1" ), ofSeconds( 5 ), singletonMap( "key", value( 42 ) ), defaultDatabase(), WRITE,
                         InternalBookmark.parse( "neo4j:bookmark:v1:tx1" ) ),
-                explicitTxRunMessage( new Statement( "RETURN 1" ) ),
+                explicitTxRunMessage( new Query( "RETURN 1" ) ),
                 PULL_ALL,
                 DISCARD_ALL,
                 RESET,
 
                 // Bolt V3 messages with struct values
-                autoCommitTxRunMessage( new Statement( "RETURN $x", singletonMap( "x", value( ZonedDateTime.now() ) ) ), ofSeconds( 1 ), emptyMap(),
+                autoCommitTxRunMessage( new Query( "RETURN $x", singletonMap( "x", value( ZonedDateTime.now() ) ) ), ofSeconds( 1 ), emptyMap(),
                         defaultDatabase(), READ, InternalBookmark.empty() ),
-                autoCommitTxRunMessage( new Statement( "RETURN $x", singletonMap( "x", value( ZonedDateTime.now() ) ) ), ofSeconds( 1 ), emptyMap(),
+                autoCommitTxRunMessage( new Query( "RETURN $x", singletonMap( "x", value( ZonedDateTime.now() ) ) ), ofSeconds( 1 ), emptyMap(),
                         defaultDatabase(), WRITE, InternalBookmark.empty() ),
-                explicitTxRunMessage( new Statement( "RETURN $x", singletonMap( "x", point( 42, 1, 2, 3 ) )  ) )
+                explicitTxRunMessage( new Query( "RETURN $x", singletonMap( "x", point( 42, 1, 2, 3 ) )  ) )
         );
     }
 
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java
index 55160acba9..be452c1d69 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java
@@ -85,7 +85,7 @@ protected void testFailedRunInAutoCommitTxWithWaitingForResponse( Bookmark bookm
         BookmarkHolder bookmarkHolder = new DefaultBookmarkHolder( bookmark );
 
         CompletableFuture cursorFuture =
-                protocol.runInAutoCommitTransaction( connection, STATEMENT, bookmarkHolder, config, true, UNLIMITED_FETCH_SIZE )
+                protocol.runInAutoCommitTransaction( connection, QUERY, bookmarkHolder, config, true, UNLIMITED_FETCH_SIZE )
                         .asyncResult()
                         .toCompletableFuture();
 
@@ -109,7 +109,7 @@ protected void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( Bookmark b
         BookmarkHolder bookmarkHolder = new DefaultBookmarkHolder( bookmark );
 
         CompletableFuture cursorFuture =
-                protocol.runInAutoCommitTransaction( connection, STATEMENT, bookmarkHolder, config, true, UNLIMITED_FETCH_SIZE )
+                protocol.runInAutoCommitTransaction( connection, QUERY, bookmarkHolder, config, true, UNLIMITED_FETCH_SIZE )
                         .asyncResult()
                         .toCompletableFuture();
 
@@ -132,7 +132,7 @@ protected void testRunInExplicitTransactionAndWaitForRunResponse( boolean succes
         Connection connection = connectionMock( mode, protocol );
 
         CompletableFuture cursorFuture =
-                protocol.runInExplicitTransaction( connection, STATEMENT, mock( UnmanagedTransaction.class ), true, UNLIMITED_FETCH_SIZE )
+                protocol.runInExplicitTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), true, UNLIMITED_FETCH_SIZE )
                         .asyncResult()
                         .toCompletableFuture();
 
@@ -165,12 +165,12 @@ protected void testRunWithoutWaitingForRunResponse( boolean autoCommitTx, Transa
         if ( autoCommitTx )
         {
             BookmarkHolder bookmarkHolder = new DefaultBookmarkHolder( initialBookmark );
-            cursorStage = protocol.runInAutoCommitTransaction( connection, STATEMENT, bookmarkHolder, config, false, UNLIMITED_FETCH_SIZE )
+            cursorStage = protocol.runInAutoCommitTransaction( connection, QUERY, bookmarkHolder, config, false, UNLIMITED_FETCH_SIZE )
                     .asyncResult();
         }
         else
         {
-            cursorStage = protocol.runInExplicitTransaction( connection, STATEMENT, mock( UnmanagedTransaction.class ), false, UNLIMITED_FETCH_SIZE )
+            cursorStage = protocol.runInExplicitTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), false, UNLIMITED_FETCH_SIZE )
                     .asyncResult();
         }
 
@@ -197,7 +197,7 @@ protected void testDatabaseNameSupport( boolean autoCommitTx )
         if ( autoCommitTx )
         {
             ResultCursorFactory factory =
-                    protocol.runInAutoCommitTransaction( connection, STATEMENT, BookmarkHolder.NO_OP, TransactionConfig.empty(), false, UNLIMITED_FETCH_SIZE );
+                    protocol.runInAutoCommitTransaction( connection, QUERY, BookmarkHolder.NO_OP, TransactionConfig.empty(), false, UNLIMITED_FETCH_SIZE );
             await( factory.asyncResult() );
             verifySessionRunInvoked( connection, InternalBookmark.empty(), TransactionConfig.empty(), AccessMode.WRITE, database( "foo" ) );
         }
@@ -211,12 +211,12 @@ protected void testDatabaseNameSupport( boolean autoCommitTx )
 
     private ResponseHandler verifyTxRunInvoked( Connection connection )
     {
-        return verifyRunInvoked( connection, RunWithMetadataMessage.explicitTxRunMessage( STATEMENT ) );
+        return verifyRunInvoked( connection, RunWithMetadataMessage.explicitTxRunMessage(QUERY) );
     }
 
     private ResponseHandler verifySessionRunInvoked( Connection connection, Bookmark bookmark, TransactionConfig config, AccessMode mode, DatabaseName databaseName )
     {
-        RunWithMetadataMessage runMessage = RunWithMetadataMessage.autoCommitTxRunMessage( STATEMENT, config, databaseName, mode, bookmark );
+        RunWithMetadataMessage runMessage = RunWithMetadataMessage.autoCommitTxRunMessage(QUERY, config, databaseName, mode, bookmark );
         return verifyRunInvoked( connection, runMessage );
     }
 
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageWriterV4Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageWriterV4Test.java
index 5d1413f8fe..48e71cf7d6 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageWriterV4Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageWriterV4Test.java
@@ -21,7 +21,7 @@
 import java.time.ZonedDateTime;
 import java.util.stream.Stream;
 
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.internal.InternalBookmark;
 import org.neo4j.driver.internal.messaging.Message;
 import org.neo4j.driver.internal.messaging.MessageFormat;
@@ -80,18 +80,18 @@ protected Stream supportedMessages()
                 ROLLBACK,
 
                 RESET,
-                autoCommitTxRunMessage( new Statement( "RETURN 1" ), ofSeconds( 5 ), singletonMap( "key", value( 42 ) ), defaultDatabase(), READ,
+                autoCommitTxRunMessage( new Query( "RETURN 1" ), ofSeconds( 5 ), singletonMap( "key", value( 42 ) ), defaultDatabase(), READ,
                         InternalBookmark.parse( "neo4j:bookmark:v1:tx1" ) ),
-                autoCommitTxRunMessage( new Statement( "RETURN 1" ), ofSeconds( 5 ), singletonMap( "key", value( 42 ) ), database( "foo" ), WRITE,
+                autoCommitTxRunMessage( new Query( "RETURN 1" ), ofSeconds( 5 ), singletonMap( "key", value( 42 ) ), database( "foo" ), WRITE,
                         InternalBookmark.parse( "neo4j:bookmark:v1:tx1" ) ),
-                explicitTxRunMessage( new Statement( "RETURN 1" ) ),
+                explicitTxRunMessage( new Query( "RETURN 1" ) ),
 
                 // Bolt V3 messages with struct values
-                autoCommitTxRunMessage( new Statement( "RETURN $x", singletonMap( "x", value( ZonedDateTime.now() ) ) ), ofSeconds( 1 ), emptyMap(),
+                autoCommitTxRunMessage( new Query( "RETURN $x", singletonMap( "x", value( ZonedDateTime.now() ) ) ), ofSeconds( 1 ), emptyMap(),
                         defaultDatabase(), READ, InternalBookmark.empty() ),
-                autoCommitTxRunMessage( new Statement( "RETURN $x", singletonMap( "x", value( ZonedDateTime.now() ) ) ), ofSeconds( 1 ), emptyMap(), database( "foo" ),
+                autoCommitTxRunMessage( new Query( "RETURN $x", singletonMap( "x", value( ZonedDateTime.now() ) ) ), ofSeconds( 1 ), emptyMap(), database( "foo" ),
                         WRITE, InternalBookmark.empty() ),
-                explicitTxRunMessage( new Statement( "RETURN $x", singletonMap( "x", point( 42, 1, 2, 3 ) )  ) )
+                explicitTxRunMessage( new Query( "RETURN $x", singletonMap( "x", point( 42, 1, 2, 3 ) )  ) )
         );
     }
 
diff --git a/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxSessionTest.java b/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxSessionTest.java
index 6bf3563e6c..aa78b277a4 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxSessionTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxSessionTest.java
@@ -21,6 +21,7 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
+import org.neo4j.driver.Query;
 import org.reactivestreams.Publisher;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -34,7 +35,6 @@
 import java.util.stream.Stream;
 
 import org.neo4j.driver.AccessMode;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.TransactionConfig;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.internal.InternalRecord;
@@ -75,8 +75,8 @@ private static Stream> allSessionRunMethods()
                 rxSession -> rxSession.run( "RETURN $x", singletonMap( "x", 1 ) ),
                 rxSession -> rxSession.run( "RETURN $x",
                         new InternalRecord( singletonList( "x" ), new Value[]{new IntegerValue( 1 )} ) ),
-                rxSession -> rxSession.run( new Statement( "RETURN $x", parameters( "x", 1 ) ) ),
-                rxSession -> rxSession.run( new Statement( "RETURN $x", parameters( "x", 1 ) ), empty() ),
+                rxSession -> rxSession.run( new Query( "RETURN $x", parameters( "x", 1 ) ) ),
+                rxSession -> rxSession.run( new Query( "RETURN $x", parameters( "x", 1 ) ), empty() ),
                 rxSession -> rxSession.run( "RETURN $x", singletonMap( "x", 1 ), empty() ),
                 rxSession -> rxSession.run( "RETURN 1", empty() )
         );
@@ -109,7 +109,7 @@ void shouldDelegateRun( Function runReturnOne ) throws Thro
         RxResultCursor cursor = mock( RxResultCursorImpl.class );
 
         // Run succeeded with a cursor
-        when( session.runRx( any( Statement.class ), any( TransactionConfig.class ) ) ).thenReturn( completedFuture( cursor ) );
+        when( session.runRx( any( Query.class ), any( TransactionConfig.class ) ) ).thenReturn( completedFuture( cursor ) );
         InternalRxSession rxSession = new InternalRxSession( session );
 
         // When
@@ -118,7 +118,7 @@ void shouldDelegateRun( Function runReturnOne ) throws Thro
         CompletionStage cursorFuture = ((InternalRxResult) result).cursorFutureSupplier().get();
 
         // Then
-        verify( session ).runRx( any( Statement.class ), any( TransactionConfig.class ) );
+        verify( session ).runRx( any( Query.class ), any( TransactionConfig.class ) );
         assertThat( Futures.getNow( cursorFuture ), equalTo( cursor ) );
     }
 
@@ -131,7 +131,7 @@ void shouldReleaseConnectionIfFailedToRun( Function runRetu
         NetworkSession session = mock( NetworkSession.class );
 
         // Run failed with error
-        when( session.runRx( any( Statement.class ), any( TransactionConfig.class ) ) ).thenReturn( Futures.failedFuture( error ) );
+        when( session.runRx( any( Query.class ), any( TransactionConfig.class ) ) ).thenReturn( Futures.failedFuture( error ) );
         when( session.releaseConnectionAsync() ).thenReturn( Futures.completedWithNull() );
 
         InternalRxSession rxSession = new InternalRxSession( session );
@@ -142,7 +142,7 @@ void shouldReleaseConnectionIfFailedToRun( Function runRetu
         CompletionStage cursorFuture = ((InternalRxResult) result).cursorFutureSupplier().get();
 
         // Then
-        verify( session ).runRx( any( Statement.class ), any( TransactionConfig.class ) );
+        verify( session ).runRx( any( Query.class ), any( TransactionConfig.class ) );
         RuntimeException t = assertThrows( CompletionException.class, () -> Futures.getNow( cursorFuture ) );
         assertThat( t.getCause(), equalTo( error ) );
         verify( session ).releaseConnectionAsync();
diff --git a/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxTransactionTest.java b/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxTransactionTest.java
index 7a967e9229..f9f97a0d11 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxTransactionTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxTransactionTest.java
@@ -21,6 +21,7 @@
 import org.junit.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
+import org.neo4j.driver.Query;
 import org.reactivestreams.Publisher;
 import reactor.test.StepVerifier;
 
@@ -29,7 +30,6 @@
 import java.util.function.Function;
 import java.util.stream.Stream;
 
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.internal.InternalRecord;
 import org.neo4j.driver.internal.async.UnmanagedTransaction;
@@ -88,7 +88,7 @@ private static Stream> allTxRunMethods()
                 rxSession -> rxSession.run( "RETURN $x", singletonMap( "x", 1 ) ),
                 rxSession -> rxSession.run( "RETURN $x",
                         new InternalRecord( singletonList( "x" ), new Value[]{new IntegerValue( 1 )} ) ),
-                rxSession -> rxSession.run( new Statement( "RETURN $x", parameters( "x", 1 ) ) )
+                rxSession -> rxSession.run( new Query( "RETURN $x", parameters( "x", 1 ) ) )
         );
     }
 
@@ -101,7 +101,7 @@ void shouldDelegateRun( Function runReturnOne ) throws
         RxResultCursor cursor = mock( RxResultCursorImpl.class );
 
         // Run succeeded with a cursor
-        when( tx.runRx( any( Statement.class ) ) ).thenReturn( completedFuture( cursor ) );
+        when( tx.runRx( any( Query.class ) ) ).thenReturn( completedFuture( cursor ) );
         InternalRxTransaction rxTx = new InternalRxTransaction( tx );
 
         // When
@@ -110,7 +110,7 @@ void shouldDelegateRun( Function runReturnOne ) throws
         CompletionStage cursorFuture = ((InternalRxResult) result).cursorFutureSupplier().get();
 
         // Then
-        verify( tx ).runRx( any( Statement.class ) );
+        verify( tx ).runRx( any( Query.class ) );
         assertThat( Futures.getNow( cursorFuture ), equalTo( cursor ) );
     }
 
@@ -123,7 +123,7 @@ void shouldMarkTxIfFailedToRun( Function runReturnOne )
         UnmanagedTransaction tx = mock( UnmanagedTransaction.class );
 
         // Run failed with error
-        when( tx.runRx( any( Statement.class ) ) ).thenReturn( Futures.failedFuture( error ) );
+        when( tx.runRx( any( Query.class ) ) ).thenReturn( Futures.failedFuture( error ) );
         InternalRxTransaction rxTx = new InternalRxTransaction( tx );
 
         // When
@@ -132,7 +132,7 @@ void shouldMarkTxIfFailedToRun( Function runReturnOne )
         CompletionStage cursorFuture = ((InternalRxResult) result).cursorFutureSupplier().get();
 
         // Then
-        verify( tx ).runRx( any( Statement.class ) );
+        verify( tx ).runRx( any( Query.class ) );
         RuntimeException t = assertThrows( CompletionException.class, () -> Futures.getNow( cursorFuture ) );
         assertThat( t.getCause(), equalTo( error ) );
         verify( tx ).markTerminated();
diff --git a/driver/src/test/java/org/neo4j/driver/internal/reactive/util/ListBasedPullHandler.java b/driver/src/test/java/org/neo4j/driver/internal/reactive/util/ListBasedPullHandler.java
index 4cfb2f0737..ce146cd74d 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/reactive/util/ListBasedPullHandler.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/reactive/util/ListBasedPullHandler.java
@@ -21,6 +21,7 @@
 import java.util.List;
 import java.util.Map;
 
+import org.neo4j.driver.Query;
 import org.neo4j.driver.internal.handlers.PullResponseCompletionListener;
 import org.neo4j.driver.internal.handlers.RunResponseHandler;
 import org.neo4j.driver.internal.handlers.pulln.BasicPullResponseHandler;
@@ -28,7 +29,6 @@
 import org.neo4j.driver.internal.util.MetadataExtractor;
 import org.neo4j.driver.internal.value.BooleanValue;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.summary.ResultSummary;
 
@@ -63,16 +63,16 @@ public ListBasedPullHandler( Throwable error )
 
     private ListBasedPullHandler( List list, Throwable error )
     {
-        super( mock( Statement.class ), mock( RunResponseHandler.class ), mock( Connection.class ), mock( MetadataExtractor.class ), mock(
+        super( mock( Query.class ), mock( RunResponseHandler.class ), mock( Connection.class ), mock( MetadataExtractor.class ), mock(
                 PullResponseCompletionListener.class ) );
         this.list = list;
         this.error = error;
-        when( super.metadataExtractor.extractSummary( any( Statement.class ), any( Connection.class ), anyLong(), any( Map.class ) ) ).thenReturn(
+        when( super.metadataExtractor.extractSummary( any( Query.class ), any( Connection.class ), anyLong(), any( Map.class ) ) ).thenReturn(
                 mock( ResultSummary.class ) );
         if ( list.size() > 1 )
         {
             Record record = list.get( 0 );
-            when( super.runResponseHandler.statementKeys() ).thenReturn( record.keys() );
+            when( super.runResponseHandler.queryKeys() ).thenReturn( record.keys() );
         }
     }
 
diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/MetadataExtractorTest.java b/driver/src/test/java/org/neo4j/driver/internal/util/MetadataExtractorTest.java
index ba1efdfaba..9c12caffb7 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/util/MetadataExtractorTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/util/MetadataExtractorTest.java
@@ -24,7 +24,7 @@
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
-import org.neo4j.driver.Statement;
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Value;
 import org.neo4j.driver.Values;
 import org.neo4j.driver.exceptions.UntrustedServerException;
@@ -60,10 +60,10 @@
 import static org.neo4j.driver.internal.util.MetadataExtractor.extractDatabaseInfo;
 import static org.neo4j.driver.internal.util.MetadataExtractor.extractNeo4jServerVersion;
 import static org.neo4j.driver.internal.util.ServerVersion.v4_0_0;
-import static org.neo4j.driver.summary.StatementType.READ_ONLY;
-import static org.neo4j.driver.summary.StatementType.READ_WRITE;
-import static org.neo4j.driver.summary.StatementType.SCHEMA_WRITE;
-import static org.neo4j.driver.summary.StatementType.WRITE_ONLY;
+import static org.neo4j.driver.summary.QueryType.READ_ONLY;
+import static org.neo4j.driver.summary.QueryType.READ_WRITE;
+import static org.neo4j.driver.summary.QueryType.SCHEMA_WRITE;
+import static org.neo4j.driver.summary.QueryType.WRITE_ONLY;
 import static org.neo4j.driver.util.TestUtil.anyServerVersion;
 
 class MetadataExtractorTest
@@ -74,17 +74,17 @@ class MetadataExtractorTest
     private final MetadataExtractor extractor = new MetadataExtractor( RESULT_AVAILABLE_AFTER_KEY, RESULT_CONSUMED_AFTER_KEY );
 
     @Test
-    void shouldExtractStatementKeys()
+    void shouldExtractQueryKeys()
     {
         List keys = asList( "hello", " ", "world", "!" );
-        List extractedKeys = extractor.extractStatementKeys( singletonMap( "fields", value( keys ) ) );
+        List extractedKeys = extractor.extractQueryKeys( singletonMap( "fields", value( keys ) ) );
         assertEquals( keys, extractedKeys );
     }
 
     @Test
-    void shouldExtractEmptyStatementKeysWhenNoneInMetadata()
+    void shouldExtractEmptyQueryKeysWhenNoneInMetadata()
     {
-        List extractedKeys = extractor.extractStatementKeys( emptyMap() );
+        List extractedKeys = extractor.extractQueryKeys( emptyMap() );
         assertEquals( emptyList(), extractedKeys );
     }
 
@@ -104,14 +104,14 @@ void shouldExtractNoResultAvailableAfterWhenNoneInMetadata()
     }
 
     @Test
-    void shouldBuildResultSummaryWithStatement()
+    void shouldBuildResultSummaryWithQuery()
     {
-        Statement statement = new Statement( "UNWIND range(10, 100) AS x CREATE (:Node {name: $name, x: x})",
+        Query query = new Query( "UNWIND range(10, 100) AS x CREATE (:Node {name: $name, x: x})",
                 singletonMap( "name", "Apa" ) );
 
-        ResultSummary summary = extractor.extractSummary( statement, connectionMock(), 42, emptyMap() );
+        ResultSummary summary = extractor.extractSummary(query, connectionMock(), 42, emptyMap() );
 
-        assertEquals( statement, summary.statement() );
+        assertEquals(query, summary.query() );
     }
 
     @Test
@@ -119,21 +119,21 @@ void shouldBuildResultSummaryWithServerInfo()
     {
         Connection connection = connectionMock( new BoltServerAddress( "server:42" ), v4_0_0 );
 
-        ResultSummary summary = extractor.extractSummary( statement(), connection, 42, emptyMap() );
+        ResultSummary summary = extractor.extractSummary( query(), connection, 42, emptyMap() );
 
         assertEquals( "server:42", summary.server().address() );
         assertEquals( "Neo4j/4.0.0", summary.server().version() );
     }
 
     @Test
-    void shouldBuildResultSummaryWithStatementType()
+    void shouldBuildResultSummaryWithQueryType()
     {
-        assertEquals( READ_ONLY, createWithStatementType( value( "r" ) ).statementType() );
-        assertEquals( READ_WRITE, createWithStatementType( value( "rw" ) ).statementType() );
-        assertEquals( WRITE_ONLY, createWithStatementType( value( "w" ) ).statementType() );
-        assertEquals( SCHEMA_WRITE, createWithStatementType( value( "s" ) ).statementType() );
+        assertEquals( READ_ONLY, createWithQueryType( value( "r" ) ).queryType() );
+        assertEquals( READ_WRITE, createWithQueryType( value( "rw" ) ).queryType() );
+        assertEquals( WRITE_ONLY, createWithQueryType( value( "w" ) ).queryType() );
+        assertEquals( SCHEMA_WRITE, createWithQueryType( value( "s" ) ).queryType() );
 
-        assertNull( createWithStatementType( null ).statementType() );
+        assertNull( createWithQueryType( null ).queryType() );
     }
 
     @Test
@@ -155,7 +155,7 @@ void shouldBuildResultSummaryWithCounters()
 
         Map metadata = singletonMap( "stats", stats );
 
-        ResultSummary summary = extractor.extractSummary( statement(), connectionMock(), 42, metadata );
+        ResultSummary summary = extractor.extractSummary( query(), connectionMock(), 42, metadata );
 
         assertEquals( 42, summary.counters().nodesCreated() );
         assertEquals( 4242, summary.counters().nodesDeleted() );
@@ -173,7 +173,7 @@ void shouldBuildResultSummaryWithCounters()
     @Test
     void shouldBuildResultSummaryWithoutCounters()
     {
-        ResultSummary summary = extractor.extractSummary( statement(), connectionMock(), 42, emptyMap() );
+        ResultSummary summary = extractor.extractSummary( query(), connectionMock(), 42, emptyMap() );
         assertEquals( EMPTY_STATS, summary.counters() );
     }
 
@@ -194,7 +194,7 @@ void shouldBuildResultSummaryWithPlan()
         ) );
         Map metadata = singletonMap( "plan", plan );
 
-        ResultSummary summary = extractor.extractSummary( statement(), connectionMock(), 42, metadata );
+        ResultSummary summary = extractor.extractSummary( query(), connectionMock(), 42, metadata );
 
         assertTrue( summary.hasPlan() );
         assertEquals( "Projection", summary.plan().operatorType() );
@@ -214,7 +214,7 @@ void shouldBuildResultSummaryWithPlan()
     @Test
     void shouldBuildResultSummaryWithoutPlan()
     {
-        ResultSummary summary = extractor.extractSummary( statement(), connectionMock(), 42, emptyMap() );
+        ResultSummary summary = extractor.extractSummary( query(), connectionMock(), 42, emptyMap() );
         assertFalse( summary.hasPlan() );
         assertNull( summary.plan() );
     }
@@ -241,7 +241,7 @@ void shouldBuildResultSummaryWithProfiledPlan()
         ) );
         Map metadata = singletonMap( "profile", profile );
 
-        ResultSummary summary = extractor.extractSummary( statement(), connectionMock(), 42, metadata );
+        ResultSummary summary = extractor.extractSummary( query(), connectionMock(), 42, metadata );
 
         assertTrue( summary.hasPlan() );
         assertTrue( summary.hasProfile() );
@@ -270,7 +270,7 @@ void shouldBuildResultSummaryWithProfiledPlan()
     @Test
     void shouldBuildResultSummaryWithoutProfiledPlan()
     {
-        ResultSummary summary = extractor.extractSummary( statement(), connectionMock(), 42, emptyMap() );
+        ResultSummary summary = extractor.extractSummary( query(), connectionMock(), 42, emptyMap() );
         assertFalse( summary.hasProfile() );
         assertNull( summary.profile() );
     }
@@ -303,7 +303,7 @@ void shouldBuildResultSummaryWithNotifications()
         Value notifications = value( notification1, notification2 );
         Map metadata = singletonMap( "notifications", notifications );
 
-        ResultSummary summary = extractor.extractSummary( statement(), connectionMock(), 42, metadata );
+        ResultSummary summary = extractor.extractSummary( query(), connectionMock(), 42, metadata );
 
         assertEquals( 2, summary.notifications().size() );
         Notification firstNotification = summary.notifications().get( 0 );
@@ -325,7 +325,7 @@ void shouldBuildResultSummaryWithNotifications()
     @Test
     void shouldBuildResultSummaryWithoutNotifications()
     {
-        ResultSummary summary = extractor.extractSummary( statement(), connectionMock(), 42, emptyMap() );
+        ResultSummary summary = extractor.extractSummary( query(), connectionMock(), 42, emptyMap() );
         assertEquals( 0, summary.notifications().size() );
     }
 
@@ -334,7 +334,7 @@ void shouldBuildResultSummaryWithResultAvailableAfter()
     {
         int value = 42_000;
 
-        ResultSummary summary = extractor.extractSummary( statement(), connectionMock(), value, emptyMap() );
+        ResultSummary summary = extractor.extractSummary( query(), connectionMock(), value, emptyMap() );
 
         assertEquals( 42, summary.resultAvailableAfter( TimeUnit.SECONDS ) );
         assertEquals( value, summary.resultAvailableAfter( TimeUnit.MILLISECONDS ) );
@@ -346,7 +346,7 @@ void shouldBuildResultSummaryWithResultConsumedAfter()
         int value = 42_000;
         Map metadata = singletonMap( RESULT_CONSUMED_AFTER_KEY, value( value ) );
 
-        ResultSummary summary = extractor.extractSummary( statement(), connectionMock(), 42, metadata );
+        ResultSummary summary = extractor.extractSummary( query(), connectionMock(), 42, metadata );
 
         assertEquals( 42, summary.resultConsumedAfter( TimeUnit.SECONDS ) );
         assertEquals( value, summary.resultConsumedAfter( TimeUnit.MILLISECONDS ) );
@@ -355,7 +355,7 @@ void shouldBuildResultSummaryWithResultConsumedAfter()
     @Test
     void shouldBuildResultSummaryWithoutResultConsumedAfter()
     {
-        ResultSummary summary = extractor.extractSummary( statement(), connectionMock(), 42, emptyMap() );
+        ResultSummary summary = extractor.extractSummary( query(), connectionMock(), 42, emptyMap() );
         assertEquals( -1, summary.resultConsumedAfter( TimeUnit.SECONDS ) );
         assertEquals( -1, summary.resultConsumedAfter( TimeUnit.MILLISECONDS ) );
     }
@@ -457,15 +457,15 @@ void shouldFailToExtractServerVersionFromNonNeo4jProduct()
         assertThrows( UntrustedServerException.class, () -> extractNeo4jServerVersion( singletonMap( "server", value( "NotNeo4j/1.2.3" ) ) ) );
     }
 
-    private ResultSummary createWithStatementType( Value typeValue )
+    private ResultSummary createWithQueryType(Value typeValue )
     {
         Map metadata = singletonMap( "type", typeValue );
-        return extractor.extractSummary( statement(), connectionMock(), 42, metadata );
+        return extractor.extractSummary( query(), connectionMock(), 42, metadata );
     }
 
-    private static Statement statement()
+    private static Query query()
     {
-        return new Statement( "RETURN 1" );
+        return new Query( "RETURN 1" );
     }
 
     private static Connection connectionMock()
diff --git a/driver/src/test/java/org/neo4j/driver/stress/AbstractStressTestBase.java b/driver/src/test/java/org/neo4j/driver/stress/AbstractStressTestBase.java
index 491ba4d7ad..f66b1b62c9 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/AbstractStressTestBase.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/AbstractStressTestBase.java
@@ -22,6 +22,7 @@
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.neo4j.driver.Query;
 import org.reactivestreams.Publisher;
 import reactor.core.publisher.Flux;
 
@@ -57,7 +58,6 @@
 import org.neo4j.driver.Logging;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.async.AsyncSession;
@@ -637,8 +637,8 @@ private Bookmark createNodesRx( int batchCount, int batchSize, InternalDriver dr
     private Publisher createNodesInTxRx( RxTransaction tx, int batchIndex, int batchSize )
     {
         return Flux.concat( Flux.range( 0, batchSize ).map( index -> batchIndex * batchSize + index ).map( nodeIndex -> {
-            Statement statement = createNodeInTxStatement( nodeIndex );
-            return Flux.from( tx.run( statement ).consume() ).then(); // As long as there is no error
+            Query query = createNodeInTxQuery( nodeIndex );
+            return Flux.from( tx.run(query).consume() ).then(); // As long as there is no error
         } ) );
     }
 
@@ -681,37 +681,37 @@ private static Void createNodesInTx( Transaction tx, int batchIndex, int batchSi
 
     private static void createNodeInTx( Transaction tx, int nodeIndex )
     {
-        Statement statement = createNodeInTxStatement( nodeIndex );
-        tx.run( statement ).consume();
+        Query query = createNodeInTxQuery( nodeIndex );
+        tx.run(query).consume();
     }
 
     private static CompletionStage createNodesInTxAsync( AsyncTransaction tx, int batchIndex, int batchSize )
     {
         @SuppressWarnings( "unchecked" )
-        CompletableFuture[] statementFutures = IntStream.range( 0, batchSize )
+        CompletableFuture[] queryFutures = IntStream.range( 0, batchSize )
                 .map( index -> batchIndex * batchSize + index )
                 .mapToObj( nodeIndex -> createNodeInTxAsync( tx, nodeIndex ) )
                 .toArray( CompletableFuture[]::new );
 
-        return CompletableFuture.allOf( statementFutures )
+        return CompletableFuture.allOf( queryFutures )
                 .thenApply( ignored -> (Throwable) null )
                 .exceptionally( error -> error );
     }
 
     private static CompletableFuture createNodeInTxAsync( AsyncTransaction tx, int nodeIndex )
     {
-        Statement statement = createNodeInTxStatement( nodeIndex );
-        return tx.runAsync( statement )
+        Query query = createNodeInTxQuery( nodeIndex );
+        return tx.runAsync(query)
                 .thenCompose( ResultCursor::consumeAsync )
                 .thenApply( ignore -> (Void) null )
                 .toCompletableFuture();
     }
 
-    private static Statement createNodeInTxStatement( int nodeIndex )
+    private static Query createNodeInTxQuery(int nodeIndex )
     {
         String query = "CREATE (n:Test:Node) SET n = $props";
         Map params = singletonMap( "props", createNodeProperties( nodeIndex ) );
-        return new Statement( query, params );
+        return new Query( query, params );
     }
 
     private static Map createNodeProperties( int nodeIndex )
diff --git a/driver/src/test/java/org/neo4j/driver/stress/CausalClusteringIT.java b/driver/src/test/java/org/neo4j/driver/stress/CausalClusteringIT.java
index d6a9068a5b..063dc78282 100644
--- a/driver/src/test/java/org/neo4j/driver/stress/CausalClusteringIT.java
+++ b/driver/src/test/java/org/neo4j/driver/stress/CausalClusteringIT.java
@@ -49,7 +49,7 @@
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
 import org.neo4j.driver.Result;
-import org.neo4j.driver.StatementRunner;
+import org.neo4j.driver.QueryRunner;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.Values;
 import org.neo4j.driver.async.AsyncSession;
@@ -577,7 +577,7 @@ RoutingSettings.DEFAULT, RetrySettings.DEFAULT, configWithoutLogging() ) )
 
             ServiceUnavailableException error = new ServiceUnavailableException( "Connection broke!" );
             driverFactory.setNextRunFailure( error );
-            assertUnableToRunMoreStatementsInTx( tx2, error );
+            assertUnableToRunMoreQueriesInTx( tx2, error );
 
             tx2.close();
             tx1.commit();
@@ -706,7 +706,7 @@ void shouldKeepOperatingWhenConnectionsBreak() throws Exception
         }
     }
 
-    private static void assertUnableToRunMoreStatementsInTx( Transaction tx, ServiceUnavailableException cause )
+    private static void assertUnableToRunMoreQueriesInTx(Transaction tx, ServiceUnavailableException cause )
     {
         SessionExpiredException e = assertThrows( SessionExpiredException.class, () -> tx.run( "CREATE (n:Node3 {name: 'Node3'})" ).consume() );
         assertEquals( cause, e.getCause() );
@@ -1006,14 +1006,14 @@ private static Bookmark createNodeAndGetBookmark( Session session, String label,
         }
     }
 
-    private static Result runCreateNode(StatementRunner statementRunner, String label, String property, String value )
+    private static Result runCreateNode(QueryRunner queryRunner, String label, String property, String value )
     {
-        return statementRunner.run( "CREATE (n:" + label + ") SET n." + property + " = $value", parameters( "value", value ) );
+        return queryRunner.run( "CREATE (n:" + label + ") SET n." + property + " = $value", parameters( "value", value ) );
     }
 
-    private static int runCountNodes( StatementRunner statementRunner, String label, String property, String value )
+    private static int runCountNodes(QueryRunner queryRunner, String label, String property, String value )
     {
-        Result result = statementRunner.run( "MATCH (n:" + label + " {" + property + ": $value}) RETURN count(n)", parameters( "value", value ) );
+        Result result = queryRunner.run( "MATCH (n:" + label + " {" + property + ": $value}) RETURN count(n)", parameters( "value", value ) );
         return result.single().get( 0 ).asInt();
     }
 
diff --git a/driver/src/test/java/org/neo4j/driver/util/SessionExtension.java b/driver/src/test/java/org/neo4j/driver/util/SessionExtension.java
index 0978234558..9f9f7fa9ad 100644
--- a/driver/src/test/java/org/neo4j/driver/util/SessionExtension.java
+++ b/driver/src/test/java/org/neo4j/driver/util/SessionExtension.java
@@ -24,9 +24,9 @@
 
 import java.util.Map;
 
+import org.neo4j.driver.Query;
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Session;
-import org.neo4j.driver.Statement;
 import org.neo4j.driver.Result;
 import org.neo4j.driver.Transaction;
 import org.neo4j.driver.TransactionConfig;
@@ -120,50 +120,50 @@ public void reset()
     }
 
     @Override
-    public Result run(String statementText, Map statementParameters )
+    public Result run(String query, Map parameters)
     {
-        return realSession.run( statementText, statementParameters );
+        return realSession.run(query, parameters);
     }
 
     @Override
-    public Result run(String statementText, Value parameters )
+    public Result run(String query, Value parameters )
     {
-        return realSession.run( statementText, parameters );
+        return realSession.run(query, parameters );
     }
 
     @Override
-    public Result run(String statementText, Record parameters )
+    public Result run(String query, Record parameters )
     {
-        return realSession.run( statementText, parameters );
+        return realSession.run(query, parameters );
     }
 
     @Override
-    public Result run(String statementTemplate )
+    public Result run(String query)
     {
-        return realSession.run( statementTemplate );
+        return realSession.run(query);
     }
 
     @Override
-    public Result run(Statement statement )
+    public Result run(Query query)
     {
-        return realSession.run( statement.text(), statement.parameters() );
+        return realSession.run( query.text(), query.parameters() );
     }
 
     @Override
-    public Result run(String statement, TransactionConfig config )
+    public Result run(String query, TransactionConfig config )
     {
-        return realSession.run( statement, config );
+        return realSession.run(query, config );
     }
 
     @Override
-    public Result run(String statement, Map parameters, TransactionConfig config )
+    public Result run(String query, Map parameters, TransactionConfig config )
     {
-        return realSession.run( statement, parameters, config );
+        return realSession.run(query, parameters, config );
     }
 
     @Override
-    public Result run(Statement statement, TransactionConfig config )
+    public Result run(Query query, TransactionConfig config )
     {
-        return realSession.run( statement, config );
+        return realSession.run(query, config );
     }
 }
diff --git a/driver/src/test/java/org/neo4j/driver/util/TestUtil.java b/driver/src/test/java/org/neo4j/driver/util/TestUtil.java
index 513b1fd5b1..4072af889c 100644
--- a/driver/src/test/java/org/neo4j/driver/util/TestUtil.java
+++ b/driver/src/test/java/org/neo4j/driver/util/TestUtil.java
@@ -280,12 +280,12 @@ public static NetworkSession newSession( ConnectionProvider connectionProvider,
 
     public static void verifyRunRx( Connection connection, String query )
     {
-        verify( connection ).writeAndFlush( argThat( runWithMetaMessageWithStatementMatcher( query ) ), any() );
+        verify( connection ).writeAndFlush( argThat( runWithMetaMessageWithQueryMatcher( query ) ), any() );
     }
 
     public static void verifyRunAndPull( Connection connection, String query )
     {
-        verify( connection ).write( argThat( runWithMetaMessageWithStatementMatcher( query ) ), any() );
+        verify( connection ).write( argThat( runWithMetaMessageWithQueryMatcher( query ) ), any() );
         verify( connection ).writeAndFlush( any( PullMessage.class ), any() );
     }
 
@@ -445,7 +445,7 @@ public static void setupSuccessfulRunAndPull( Connection connection, String quer
             ResponseHandler runHandler = invocation.getArgument( 1 );
             runHandler.onSuccess( emptyMap() );
             return null;
-        } ).when( connection ).write( argThat( runWithMetaMessageWithStatementMatcher( query ) ), any() );
+        } ).when( connection ).write( argThat( runWithMetaMessageWithQueryMatcher( query ) ), any() );
 
         doAnswer( invocation ->
         {
@@ -588,14 +588,14 @@ public static String randomString( int size )
         return sb.toString();
     }
 
-    public static ArgumentMatcher runMessageWithStatementMatcher( String statement )
+    public static ArgumentMatcher runMessageWithQueryMatcher(String query )
     {
-        return message -> message instanceof RunMessage && Objects.equals( statement, ((RunMessage) message).statement() );
+        return message -> message instanceof RunMessage && Objects.equals( query, ((RunMessage) message).query() );
     }
 
-    public static ArgumentMatcher runWithMetaMessageWithStatementMatcher( String statement )
+    public static ArgumentMatcher runWithMetaMessageWithQueryMatcher(String query )
     {
-        return message -> message instanceof RunWithMetadataMessage && Objects.equals( statement, ((RunWithMetadataMessage) message).statement() );
+        return message -> message instanceof RunWithMetadataMessage && Objects.equals( query, ((RunWithMetadataMessage) message).query() );
     }
 
     /**
@@ -606,14 +606,14 @@ public static ServerVersion anyServerVersion()
         return ServerVersion.v4_0_0;
     }
 
-    private static void setupSuccessfulPullAll( Connection connection, String statement )
+    private static void setupSuccessfulPullAll( Connection connection, String query )
     {
         doAnswer( invocation ->
         {
             ResponseHandler handler = invocation.getArgument( 3 );
             handler.onSuccess( emptyMap() );
             return null;
-        } ).when( connection ).writeAndFlush( argThat( runMessageWithStatementMatcher( statement ) ), any(), any(), any() );
+        } ).when( connection ).writeAndFlush( argThat( runMessageWithQueryMatcher( query ) ), any(), any(), any() );
     }
 
     private static void setupSuccessResponse( Connection connection, Class messageType )
diff --git a/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java b/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java
index d475d894d1..a4c00757a1 100644
--- a/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java
+++ b/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java
@@ -36,7 +36,7 @@
 import org.neo4j.driver.Value;
 import org.neo4j.driver.internal.util.EnabledOnNeo4jWith;
 import org.neo4j.driver.summary.ResultSummary;
-import org.neo4j.driver.summary.StatementType;
+import org.neo4j.driver.summary.QueryType;
 import org.neo4j.driver.util.DatabaseExtension;
 import org.neo4j.driver.util.ParallelizableIT;
 import org.neo4j.driver.util.StdIOCapture;
@@ -69,34 +69,34 @@ class ExamplesIT
 
     private String uri;
 
-    private int readInt( final String statement, final Value parameters )
+    private int readInt( final String query, final Value parameters )
     {
         try ( Session session = neo4j.driver().session() )
         {
-            return session.readTransaction( tx -> tx.run( statement, parameters ).single().get( 0 ).asInt() );
+            return session.readTransaction( tx -> tx.run( query, parameters ).single().get( 0 ).asInt() );
         }
     }
 
-    private int readInt( final String statement )
+    private int readInt( final String query )
     {
-        return readInt( statement, parameters() );
+        return readInt( query, parameters() );
     }
 
-    private void write( final String statement, final Value parameters )
+    private void write( final String query, final Value parameters )
     {
         try ( Session session = neo4j.driver().session() )
         {
             session.writeTransaction( tx ->
             {
-                tx.run( statement, parameters );
+                tx.run( query, parameters );
                 return null;
             } );
         }
     }
 
-    private void write( String statement )
+    private void write( String query )
     {
-        write( statement, parameters() );
+        write( query, parameters() );
     }
 
     private int personCount( String name )
@@ -384,7 +384,7 @@ void testShouldRunAsyncTransactionFunctionExample() throws Exception
             try ( AutoCloseable ignore = stdIOCapture.capture() )
             {
                 ResultSummary summary = await( example.printAllProducts() );
-                assertEquals( StatementType.READ_ONLY, summary.statementType() );
+                assertEquals( QueryType.READ_ONLY, summary.queryType() );
             }
 
             Set capturedOutput = new HashSet<>( stdIOCapture.stdout() );
@@ -551,7 +551,7 @@ void testShouldRunRxTransactionFunctionExampleReactor() throws Exception
                 final List summaryList = await( example.printAllProductsReactor() );
                 assertThat( summaryList.size(), equalTo( 1 ) );
                 ResultSummary summary = summaryList.get( 0 );
-                assertEquals( StatementType.READ_ONLY, summary.statementType() );
+                assertEquals( QueryType.READ_ONLY, summary.queryType() );
             }
 
             Set capturedOutput = new HashSet<>( stdIOCapture.stdout() );
@@ -581,7 +581,7 @@ void testShouldRunRxTransactionFunctionExampleRxJava() throws Exception
                 final List summaryList = await( example.printAllProductsRxJava() );
                 assertThat( summaryList.size(), equalTo( 1 ) );
                 ResultSummary summary = summaryList.get( 0 );
-                assertEquals( StatementType.READ_ONLY, summary.statementType() );
+                assertEquals( QueryType.READ_ONLY, summary.queryType() );
             }
 
             Set capturedOutput = new HashSet<>( stdIOCapture.stdout() );

From 4c6ca4a388bbfe726ffe5cd48c101042d2d8c96a Mon Sep 17 00:00:00 2001
From: Nigel Small 
Date: Mon, 18 Nov 2019 12:05:30 +0000
Subject: [PATCH 3/7] ExplicitTransaction->UnmanagedTransaction

---
 driver/src/main/java/org/neo4j/driver/Bookmark.java  |  2 +-
 driver/src/main/java/org/neo4j/driver/Session.java   |  6 +++---
 .../java/org/neo4j/driver/TransactionConfig.java     |  4 ++--
 .../java/org/neo4j/driver/async/AsyncSession.java    |  6 +++---
 .../exceptions/TransactionNestingException.java      |  2 +-
 .../driver/internal/async/UnmanagedTransaction.java  |  4 ++--
 .../driver/internal/messaging/BoltProtocol.java      | 10 +++++-----
 .../messaging/request/RunWithMetadataMessage.java    |  2 +-
 .../driver/internal/messaging/v1/BoltProtocolV1.java |  5 +++--
 .../driver/internal/messaging/v3/BoltProtocolV3.java |  9 +++++----
 .../java/org/neo4j/driver/reactive/RxSession.java    |  4 ++--
 driver/src/main/javadoc/overview.html                |  2 +-
 .../internal/messaging/v1/BoltProtocolV1Test.java    |  4 ++--
 .../internal/messaging/v3/BoltProtocolV3Test.java    |  6 +++---
 .../internal/messaging/v3/MessageWriterV3Test.java   |  6 +++---
 .../internal/messaging/v4/BoltProtocolV4Test.java    |  6 +++---
 .../internal/messaging/v4/MessageWriterV4Test.java   |  6 +++---
 ...le.java => AsyncUnmanagedTransactionExample.java} |  8 ++++----
 ...ample.java => RxUnmanagedTransactionExample.java} | 12 ++++++------
 .../test/java/org/neo4j/docs/driver/ExamplesIT.java  |  4 ++--
 20 files changed, 55 insertions(+), 53 deletions(-)
 rename examples/src/main/java/org/neo4j/docs/driver/{AsyncExplicitTransactionExample.java => AsyncUnmanagedTransactionExample.java} (92%)
 rename examples/src/main/java/org/neo4j/docs/driver/{RxExplicitTransactionExample.java => RxUnmanagedTransactionExample.java} (88%)

diff --git a/driver/src/main/java/org/neo4j/driver/Bookmark.java b/driver/src/main/java/org/neo4j/driver/Bookmark.java
index 134c759eb7..6dc7d5a06c 100644
--- a/driver/src/main/java/org/neo4j/driver/Bookmark.java
+++ b/driver/src/main/java/org/neo4j/driver/Bookmark.java
@@ -29,7 +29,7 @@
  * the database is as up-to-date as the latest transaction referenced by the supplied bookmarks.
  *
  * Within a session, bookmark propagation is carried out automatically.
- * Thus all transactions in a session including explicit and implicit transactions are ensured to be carried out one after another.
+ * Thus all transactions in a session (both managed and unmanaged) are guaranteed to be carried out one after another.
  *
  * To opt out of this mechanism for unrelated units of work, applications can use multiple sessions.
  */
diff --git a/driver/src/main/java/org/neo4j/driver/Session.java b/driver/src/main/java/org/neo4j/driver/Session.java
index f20661a139..ff7ec618fc 100644
--- a/driver/src/main/java/org/neo4j/driver/Session.java
+++ b/driver/src/main/java/org/neo4j/driver/Session.java
@@ -35,7 +35,7 @@
  * COMMIT that query within its own transaction. This type
  * of transaction is known as an autocommit transaction.
  * 
    
- * Explicit transactions allow multiple queries to be committed as part of
+ * Unmanaged transactions allow multiple queries to be committed as part of
  * a single atomic operation and can be rolled back if necessary. They can also
  * be used to ensure causal consistency, meaning that an application
  * can run a series of queries on different members of a cluster, while
@@ -64,7 +64,7 @@
 public interface Session extends Resource, QueryRunner
 {
     /**
-     * Begin a new explicit {@linkplain Transaction transaction}. At
+     * Begin a new unmanaged {@linkplain Transaction transaction}. At
      * most one transaction may exist in a session at any point in time. To
      * maintain multiple concurrent transactions, use multiple concurrent
      * sessions.
@@ -74,7 +74,7 @@ public interface Session extends Resource, QueryRunner
     Transaction beginTransaction();
 
     /**
-     * Begin a new explicit {@linkplain Transaction transaction} with the specified {@link TransactionConfig configuration}.
+     * Begin a new unmanaged {@linkplain Transaction transaction} with the specified {@link TransactionConfig configuration}.
      * At most one transaction may exist in a session at any point in time. To
      * maintain multiple concurrent transactions, use multiple concurrent
      * sessions.
diff --git a/driver/src/main/java/org/neo4j/driver/TransactionConfig.java b/driver/src/main/java/org/neo4j/driver/TransactionConfig.java
index 1b857633f2..b82acfc272 100644
--- a/driver/src/main/java/org/neo4j/driver/TransactionConfig.java
+++ b/driver/src/main/java/org/neo4j/driver/TransactionConfig.java
@@ -32,7 +32,7 @@
 import static org.neo4j.driver.internal.util.Preconditions.checkArgument;
 
 /**
- * Configuration object containing settings for explicit and auto-commit transactions.
+ * Configuration object containing settings for transactions.
  * Instances are immutable and can be reused for multiple transactions.
  * 
    
  * Configuration is supported for:
@@ -42,7 +42,7 @@
  * 
  • transactions started by transaction functions - using {@link Session#readTransaction(TransactionWork, TransactionConfig)},
  * {@link Session#writeTransaction(TransactionWork, TransactionConfig)}, {@link AsyncSession#readTransactionAsync(AsyncTransactionWork, TransactionConfig)} and
  * {@link AsyncSession#writeTransactionAsync(AsyncTransactionWork, TransactionConfig)}
    • 
- * 
  • explicit transactions - using {@link Session#beginTransaction(TransactionConfig)} and {@link AsyncSession#beginTransactionAsync(TransactionConfig)}
    • 
+ * 
  • unmanaged transactions - using {@link Session#beginTransaction(TransactionConfig)} and {@link AsyncSession#beginTransactionAsync(TransactionConfig)}
    • 
  * 

  * 

  * Creation of configuration objects can be done using the builder API:
diff --git a/driver/src/main/java/org/neo4j/driver/async/AsyncSession.java b/driver/src/main/java/org/neo4j/driver/async/AsyncSession.java
index a3ece70519..41bb3e18a0 100644
--- a/driver/src/main/java/org/neo4j/driver/async/AsyncSession.java
+++ b/driver/src/main/java/org/neo4j/driver/async/AsyncSession.java
@@ -43,7 +43,7 @@
  * COMMIT that query within its own transaction. This type
  * of transaction is known as an autocommit transaction.
  * 

- * Explicit transactions allow multiple queries to be committed as part of
+ * Unmanaged transactions allow multiple queries to be committed as part of
  * a single atomic operation and can be rolled back if necessary. They can also
  * be used to ensure causal consistency, meaning that an application
  * can run a series of queries on different members of a cluster, while
@@ -72,7 +72,7 @@
 public interface AsyncSession extends AsyncQueryRunner
 {
     /**
-     * Begin a new explicit {@linkplain Transaction transaction}. At
+     * Begin a new unmanaged {@linkplain Transaction transaction}. At
      * most one transaction may exist in a session at any point in time. To
      * maintain multiple concurrent transactions, use multiple concurrent
      * sessions.
@@ -93,7 +93,7 @@ public interface AsyncSession extends AsyncQueryRunner
     CompletionStage beginTransactionAsync();
 
     /**
-     * Begin a new explicit {@linkplain AsyncTransaction transaction} with the specified {@link TransactionConfig configuration}.
+     * Begin a new unmanaged {@linkplain AsyncTransaction transaction} with the specified {@link TransactionConfig configuration}.
      * At most one transaction may exist in a session at any point in time.
      * To maintain multiple concurrent transactions, use multiple concurrent sessions.
      * 

diff --git a/driver/src/main/java/org/neo4j/driver/exceptions/TransactionNestingException.java b/driver/src/main/java/org/neo4j/driver/exceptions/TransactionNestingException.java
index 2c6bb7020d..fe7b653a49 100644
--- a/driver/src/main/java/org/neo4j/driver/exceptions/TransactionNestingException.java
+++ b/driver/src/main/java/org/neo4j/driver/exceptions/TransactionNestingException.java
@@ -19,7 +19,7 @@
 package org.neo4j.driver.exceptions;
 
 /**
- * This exception indicates a user is nesting new transaction with an on-going transaction (explicit and/or auto-commit).
+ * This exception indicates a user is nesting new transaction with an on-going transaction (unmanaged and/or auto-commit).
  */
 public class TransactionNestingException extends ClientException
 {
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/UnmanagedTransaction.java b/driver/src/main/java/org/neo4j/driver/internal/async/UnmanagedTransaction.java
index fedf786864..2bec5a9bd6 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/UnmanagedTransaction.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/UnmanagedTransaction.java
@@ -142,7 +142,7 @@ public CompletionStage runAsync(Query query, boolean waitForRunRes
     {
         ensureCanRunQueries();
         CompletionStage cursorStage =
-                protocol.runInExplicitTransaction( connection, query, this, waitForRunResponse, fetchSize ).asyncResult();
+                protocol.runInUnmanagedTransaction( connection, query, this, waitForRunResponse, fetchSize ).asyncResult();
         resultCursors.add( cursorStage );
         return cursorStage.thenApply( cursor -> cursor );
     }
@@ -151,7 +151,7 @@ public CompletionStage runRx(Query query)
     {
         ensureCanRunQueries();
         CompletionStage cursorStage =
-                protocol.runInExplicitTransaction( connection, query, this, false, fetchSize ).rxResult();
+                protocol.runInUnmanagedTransaction( connection, query, this, false, fetchSize ).rxResult();
         resultCursors.add( cursorStage );
         return cursorStage;
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java
index 24ea5a2785..97350c6f80 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java
@@ -68,7 +68,7 @@ public interface BoltProtocol
     void prepareToCloseChannel( Channel channel );
 
     /**
-     * Begin an explicit transaction.
+     * Begin an unmanaged transaction.
      *
      * @param connection the connection to use.
      * @param bookmark the bookmarks. Never null, should be {@link InternalBookmark#empty()} when absent.
@@ -78,7 +78,7 @@ public interface BoltProtocol
     CompletionStage beginTransaction( Connection connection, Bookmark bookmark, TransactionConfig config );
 
     /**
-     * Commit the explicit transaction.
+     * Commit the unmanaged transaction.
      *
      * @param connection the connection to use.
      * @return a completion stage completed with a bookmark when transaction is committed or completed exceptionally when there was a failure.
@@ -86,7 +86,7 @@ public interface BoltProtocol
     CompletionStage commitTransaction( Connection connection );
 
     /**
-     * Rollback the explicit transaction.
+     * Rollback the unmanaged transaction.
      *
      * @param connection the connection to use.
      * @return a completion stage completed when transaction is rolled back or completed exceptionally when there was a failure.
@@ -110,7 +110,7 @@ ResultCursorFactory runInAutoCommitTransaction(Connection connection, Query quer
                                                    TransactionConfig config, boolean waitForRunResponse, long fetchSize );
 
     /**
-     * Execute the given query in a running explicit transaction, i.e. {@link Transaction#run(Query)}.
+     * Execute the given query in a running unmanaged transaction, i.e. {@link Transaction#run(Query)}.
      *
      * @param connection the network connection to use.
      * @param query the cypher to execute.
@@ -121,7 +121,7 @@ ResultCursorFactory runInAutoCommitTransaction(Connection connection, Query quer
      * @param fetchSize the record fetch size for PULL message.
      * @return stage with cursor.
      */
-    ResultCursorFactory runInExplicitTransaction(Connection connection, Query query, UnmanagedTransaction tx, boolean waitForRunResponse,
+    ResultCursorFactory runInUnmanagedTransaction(Connection connection, Query query, UnmanagedTransaction tx, boolean waitForRunResponse,
                                                  long fetchSize );
 
     /**
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RunWithMetadataMessage.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RunWithMetadataMessage.java
index f616d69447..ac4ea9635e 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RunWithMetadataMessage.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RunWithMetadataMessage.java
@@ -53,7 +53,7 @@ public static RunWithMetadataMessage autoCommitTxRunMessage(Query query, Duratio
         return new RunWithMetadataMessage( query.text(), query.parameters().asMap( ofValue() ), metadata );
     }
 
-    public static RunWithMetadataMessage explicitTxRunMessage( Query query)
+    public static RunWithMetadataMessage unmanagedTxRunMessage(Query query)
     {
         return new RunWithMetadataMessage( query.text(), query.parameters().asMap( ofValue() ), emptyMap() );
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1.java
index cb748c8168..262f6bc4cf 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1.java
@@ -33,6 +33,7 @@
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.internal.BookmarkHolder;
 import org.neo4j.driver.internal.DatabaseName;
+import org.neo4j.driver.internal.InternalBookmark;
 import org.neo4j.driver.internal.async.UnmanagedTransaction;
 import org.neo4j.driver.internal.cursor.AsyncResultCursorOnlyFactory;
 import org.neo4j.driver.internal.cursor.ResultCursorFactory;
@@ -168,8 +169,8 @@ public ResultCursorFactory runInAutoCommitTransaction(Connection connection, Que
     }
 
     @Override
-    public ResultCursorFactory runInExplicitTransaction(Connection connection, Query query, UnmanagedTransaction tx,
-                                                        boolean waitForRunResponse, long ignored )
+    public ResultCursorFactory runInUnmanagedTransaction(Connection connection, Query query, UnmanagedTransaction tx,
+                                                         boolean waitForRunResponse, long ignored )
     {
         return buildResultCursorFactory( connection, query, tx, waitForRunResponse );
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java
index 89b85db82d..e49ec36ae4 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java
@@ -31,6 +31,7 @@
 import org.neo4j.driver.Value;
 import org.neo4j.driver.internal.BookmarkHolder;
 import org.neo4j.driver.internal.DatabaseName;
+import org.neo4j.driver.internal.InternalBookmark;
 import org.neo4j.driver.internal.async.UnmanagedTransaction;
 import org.neo4j.driver.internal.cursor.AsyncResultCursorOnlyFactory;
 import org.neo4j.driver.internal.cursor.ResultCursorFactory;
@@ -57,7 +58,7 @@
 import static org.neo4j.driver.internal.messaging.request.MultiDatabaseUtil.assertEmptyDatabaseName;
 import static org.neo4j.driver.internal.messaging.request.RollbackMessage.ROLLBACK;
 import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage;
-import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.explicitTxRunMessage;
+import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage;
 
 public class BoltProtocolV3 implements BoltProtocol
 {
@@ -147,10 +148,10 @@ public ResultCursorFactory runInAutoCommitTransaction(Connection connection, Que
     }
 
     @Override
-    public ResultCursorFactory runInExplicitTransaction(Connection connection, Query query, UnmanagedTransaction tx,
-                                                        boolean waitForRunResponse, long fetchSize )
+    public ResultCursorFactory runInUnmanagedTransaction(Connection connection, Query query, UnmanagedTransaction tx,
+                                                         boolean waitForRunResponse, long fetchSize )
     {
-        RunWithMetadataMessage runMessage = explicitTxRunMessage(query);
+        RunWithMetadataMessage runMessage = unmanagedTxRunMessage(query);
         return buildResultCursorFactory( connection, query, BookmarkHolder.NO_OP, tx, runMessage, waitForRunResponse, fetchSize );
     }
 
diff --git a/driver/src/main/java/org/neo4j/driver/reactive/RxSession.java b/driver/src/main/java/org/neo4j/driver/reactive/RxSession.java
index a7812c09de..de93306336 100644
--- a/driver/src/main/java/org/neo4j/driver/reactive/RxSession.java
+++ b/driver/src/main/java/org/neo4j/driver/reactive/RxSession.java
@@ -41,7 +41,7 @@
 public interface RxSession extends RxQueryRunner
 {
     /**
-     * Begin a new explicit {@linkplain RxTransaction transaction}. At
+     * Begin a new unmanaged {@linkplain RxTransaction transaction}. At
      * most one transaction may exist in a session at any point in time. To
      * maintain multiple concurrent transactions, use multiple concurrent
      * sessions.
@@ -53,7 +53,7 @@ public interface RxSession extends RxQueryRunner
     Publisher beginTransaction();
 
     /**
-     * Begin a new explicit {@linkplain RxTransaction transaction} with the specified {@link TransactionConfig configuration}.
+     * Begin a new unmanaged {@linkplain RxTransaction transaction} with the specified {@link TransactionConfig configuration}.
      * At most one transaction may exist in a session at any point in time. To
      * maintain multiple concurrent transactions, use multiple concurrent sessions.
      * 

diff --git a/driver/src/main/javadoc/overview.html b/driver/src/main/javadoc/overview.html
index 20ddf1390a..d067847d91 100644
--- a/driver/src/main/javadoc/overview.html
+++ b/driver/src/main/javadoc/overview.html
@@ -28,7 +28,7 @@ 
Example

         // Sessions are lightweight and disposable connection wrappers.
         try (Session session = driver.session())
         {
-            // Wrapping Cypher in an explicit transaction provides atomicity
+            // Wrapping Cypher in an unmanaged transaction provides atomicity
             // and makes handling errors much easier.
             try (Transaction tx = session.beginTransaction())
             {
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1Test.java
index e317daa278..c6f33f1caa 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1Test.java
@@ -321,7 +321,7 @@ private void testRunWithoutWaitingForRunResponse( boolean autoCommitTx ) throws
         else
         {
             cursorStage = protocol
-                    .runInExplicitTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), false, UNLIMITED_FETCH_SIZE )
+                    .runInUnmanagedTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), false, UNLIMITED_FETCH_SIZE )
                     .asyncResult();
         }
         CompletableFuture cursorFuture = cursorStage.toCompletableFuture();
@@ -344,7 +344,7 @@ private void testRunWithWaitingForResponse( boolean success, boolean session ) t
         }
         else
         {
-            cursorStage = protocol.runInExplicitTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), true, UNLIMITED_FETCH_SIZE )
+            cursorStage = protocol.runInUnmanagedTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), true, UNLIMITED_FETCH_SIZE )
                     .asyncResult();
         }
         CompletableFuture cursorFuture = cursorStage.toCompletableFuture();
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java
index 69708763cf..dbbb80de5d 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java
@@ -360,7 +360,7 @@ protected void testRunInExplicitTransactionAndWaitForRunResponse( boolean succes
         Connection connection = connectionMock( mode, protocol );
 
         CompletableFuture cursorFuture =
-                protocol.runInExplicitTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), true, UNLIMITED_FETCH_SIZE ).asyncResult().toCompletableFuture();
+                protocol.runInUnmanagedTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), true, UNLIMITED_FETCH_SIZE ).asyncResult().toCompletableFuture();
 
         ResponseHandler runResponseHandler = verifyRunInvoked( connection, false, InternalBookmark.empty(), TransactionConfig.empty(), mode ).runHandler;
         assertFalse( cursorFuture.isDone() );
@@ -393,7 +393,7 @@ protected void testRunWithoutWaitingForRunResponse( boolean autoCommitTx, Transa
         }
         else
         {
-            cursorStage = protocol.runInExplicitTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), false, UNLIMITED_FETCH_SIZE ).asyncResult();
+            cursorStage = protocol.runInUnmanagedTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), false, UNLIMITED_FETCH_SIZE ).asyncResult();
         }
         CompletableFuture cursorFuture = cursorStage.toCompletableFuture();
 
@@ -471,7 +471,7 @@ private static ResponseHandlers verifyRunInvoked( Connection connection, boolean
         }
         else
         {
-            expectedMessage = RunWithMetadataMessage.explicitTxRunMessage(QUERY);
+            expectedMessage = RunWithMetadataMessage.unmanagedTxRunMessage(QUERY);
         }
 
         verify( connection ).write( eq( expectedMessage ), runHandlerCaptor.capture() );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageWriterV3Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageWriterV3Test.java
index 75b29d5456..7e39349b82 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageWriterV3Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageWriterV3Test.java
@@ -49,7 +49,7 @@
 import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET;
 import static org.neo4j.driver.internal.messaging.request.RollbackMessage.ROLLBACK;
 import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage;
-import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.explicitTxRunMessage;
+import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage;
 
 class MessageWriterV3Test extends AbstractMessageWriterTestBase
 {
@@ -74,7 +74,7 @@ protected Stream supportedMessages()
                         InternalBookmark.parse( "neo4j:bookmark:v1:tx1" ) ),
                 autoCommitTxRunMessage( new Query( "RETURN 1" ), ofSeconds( 5 ), singletonMap( "key", value( 42 ) ), defaultDatabase(), WRITE,
                         InternalBookmark.parse( "neo4j:bookmark:v1:tx1" ) ),
-                explicitTxRunMessage( new Query( "RETURN 1" ) ),
+                unmanagedTxRunMessage( new Query( "RETURN 1" ) ),
                 PULL_ALL,
                 DISCARD_ALL,
                 RESET,
@@ -84,7 +84,7 @@ protected Stream supportedMessages()
                         defaultDatabase(), READ, InternalBookmark.empty() ),
                 autoCommitTxRunMessage( new Query( "RETURN $x", singletonMap( "x", value( ZonedDateTime.now() ) ) ), ofSeconds( 1 ), emptyMap(),
                         defaultDatabase(), WRITE, InternalBookmark.empty() ),
-                explicitTxRunMessage( new Query( "RETURN $x", singletonMap( "x", point( 42, 1, 2, 3 ) )  ) )
+                unmanagedTxRunMessage( new Query( "RETURN $x", singletonMap( "x", point( 42, 1, 2, 3 ) )  ) )
         );
     }
 
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java
index be452c1d69..10085e9455 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java
@@ -132,7 +132,7 @@ protected void testRunInExplicitTransactionAndWaitForRunResponse( boolean succes
         Connection connection = connectionMock( mode, protocol );
 
         CompletableFuture cursorFuture =
-                protocol.runInExplicitTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), true, UNLIMITED_FETCH_SIZE )
+                protocol.runInUnmanagedTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), true, UNLIMITED_FETCH_SIZE )
                         .asyncResult()
                         .toCompletableFuture();
 
@@ -170,7 +170,7 @@ protected void testRunWithoutWaitingForRunResponse( boolean autoCommitTx, Transa
         }
         else
         {
-            cursorStage = protocol.runInExplicitTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), false, UNLIMITED_FETCH_SIZE )
+            cursorStage = protocol.runInUnmanagedTransaction( connection, QUERY, mock( UnmanagedTransaction.class ), false, UNLIMITED_FETCH_SIZE )
                     .asyncResult();
         }
 
@@ -211,7 +211,7 @@ protected void testDatabaseNameSupport( boolean autoCommitTx )
 
     private ResponseHandler verifyTxRunInvoked( Connection connection )
     {
-        return verifyRunInvoked( connection, RunWithMetadataMessage.explicitTxRunMessage(QUERY) );
+        return verifyRunInvoked( connection, RunWithMetadataMessage.unmanagedTxRunMessage(QUERY) );
     }
 
     private ResponseHandler verifySessionRunInvoked( Connection connection, Bookmark bookmark, TransactionConfig config, AccessMode mode, DatabaseName databaseName )
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageWriterV4Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageWriterV4Test.java
index 48e71cf7d6..09b2726dfd 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageWriterV4Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageWriterV4Test.java
@@ -52,7 +52,7 @@
 import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET;
 import static org.neo4j.driver.internal.messaging.request.RollbackMessage.ROLLBACK;
 import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage;
-import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.explicitTxRunMessage;
+import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage;
 
 class MessageWriterV4Test extends AbstractMessageWriterTestBase
 {
@@ -84,14 +84,14 @@ protected Stream supportedMessages()
                         InternalBookmark.parse( "neo4j:bookmark:v1:tx1" ) ),
                 autoCommitTxRunMessage( new Query( "RETURN 1" ), ofSeconds( 5 ), singletonMap( "key", value( 42 ) ), database( "foo" ), WRITE,
                         InternalBookmark.parse( "neo4j:bookmark:v1:tx1" ) ),
-                explicitTxRunMessage( new Query( "RETURN 1" ) ),
+                unmanagedTxRunMessage( new Query( "RETURN 1" ) ),
 
                 // Bolt V3 messages with struct values
                 autoCommitTxRunMessage( new Query( "RETURN $x", singletonMap( "x", value( ZonedDateTime.now() ) ) ), ofSeconds( 1 ), emptyMap(),
                         defaultDatabase(), READ, InternalBookmark.empty() ),
                 autoCommitTxRunMessage( new Query( "RETURN $x", singletonMap( "x", value( ZonedDateTime.now() ) ) ), ofSeconds( 1 ), emptyMap(), database( "foo" ),
                         WRITE, InternalBookmark.empty() ),
-                explicitTxRunMessage( new Query( "RETURN $x", singletonMap( "x", point( 42, 1, 2, 3 ) )  ) )
+                unmanagedTxRunMessage( new Query( "RETURN $x", singletonMap( "x", point( 42, 1, 2, 3 ) )  ) )
         );
     }
 
diff --git a/examples/src/main/java/org/neo4j/docs/driver/AsyncExplicitTransactionExample.java b/examples/src/main/java/org/neo4j/docs/driver/AsyncUnmanagedTransactionExample.java
similarity index 92%
rename from examples/src/main/java/org/neo4j/docs/driver/AsyncExplicitTransactionExample.java
rename to examples/src/main/java/org/neo4j/docs/driver/AsyncUnmanagedTransactionExample.java
index 2655eb2c0c..6a923d5a33 100644
--- a/examples/src/main/java/org/neo4j/docs/driver/AsyncExplicitTransactionExample.java
+++ b/examples/src/main/java/org/neo4j/docs/driver/AsyncUnmanagedTransactionExample.java
@@ -27,16 +27,16 @@
 import org.neo4j.driver.async.AsyncTransaction;
 import org.neo4j.driver.async.ResultCursor;
 
-public class AsyncExplicitTransactionExample extends BaseApplication
+public class AsyncUnmanagedTransactionExample extends BaseApplication
 {
-    public AsyncExplicitTransactionExample( String uri, String user, String password )
+    public AsyncUnmanagedTransactionExample(String uri, String user, String password )
     {
         super( uri, user, password );
     }
 
     public CompletionStage printSingleProduct()
     {
-        // tag::async-explicit-transaction[]
+        // tag::async-unmanaged-transaction[]
         String query = "MATCH (p:Product) WHERE p.id = $id RETURN p.title";
         Map parameters = Collections.singletonMap( "id", 0 );
 
@@ -69,6 +69,6 @@ public CompletionStage printSingleProduct()
                     return null;
                 } )
                 .thenCompose( ignore -> session.closeAsync() );
-        // end::async-explicit-transaction[]
+        // end::async-unmanaged-transaction[]
     }
 }
diff --git a/examples/src/main/java/org/neo4j/docs/driver/RxExplicitTransactionExample.java b/examples/src/main/java/org/neo4j/docs/driver/RxUnmanagedTransactionExample.java
similarity index 88%
rename from examples/src/main/java/org/neo4j/docs/driver/RxExplicitTransactionExample.java
rename to examples/src/main/java/org/neo4j/docs/driver/RxUnmanagedTransactionExample.java
index 49d0facaae..1325f350f7 100644
--- a/examples/src/main/java/org/neo4j/docs/driver/RxExplicitTransactionExample.java
+++ b/examples/src/main/java/org/neo4j/docs/driver/RxUnmanagedTransactionExample.java
@@ -27,16 +27,16 @@
 import org.neo4j.driver.reactive.RxSession;
 import org.neo4j.driver.reactive.RxTransaction;
 
-public class RxExplicitTransactionExample extends BaseApplication
+public class RxUnmanagedTransactionExample extends BaseApplication
 {
-    public RxExplicitTransactionExample( String uri, String user, String password )
+    public RxUnmanagedTransactionExample(String uri, String user, String password )
     {
         super( uri, user, password );
     }
 
     public Flux readSingleProductReactor()
     {
-        // tag::reactor-explicit-transaction[]
+        // tag::reactor-unmanaged-transaction[]
         String query = "MATCH (p:Product) WHERE p.id = $id RETURN p.title";
         Map parameters = Collections.singletonMap( "id", 0 );
 
@@ -44,12 +44,12 @@ public Flux readSingleProductReactor()
         return Flux.usingWhen( session.beginTransaction(),
                 tx -> Flux.from( tx.run( query, parameters ).records() ).map( record -> record.get( 0 ).asString() ),
                 RxTransaction::commit, ( tx, error ) -> tx.rollback(), null );
-        // end::reactor-explicit-transaction[]
+        // end::reactor-unmanaged-transaction[]
     }
 
     public Flowable readSingleProductRxJava()
     {
-        // tag::RxJava-explicit-transaction[]
+        // tag::RxJava-unmanaged-transaction[]
         String query = "MATCH (p:Product) WHERE p.id = $id RETURN p.title";
         Map parameters = Collections.singletonMap( "id", 0 );
 
@@ -63,6 +63,6 @@ public Flowable readSingleProductRxJava()
                                     // We rollback and rethrow the error. For a real application, you may want to handle the error directly here
                                     return Flowable.fromPublisher( tx.rollback() ).concatWith( Flowable.error( error ) );
                                 } ) );
-        // end::RxJava-explicit-transaction[]
+        // end::RxJava-unmanaged-transaction[]
     }
 }
diff --git a/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java b/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java
index a4c00757a1..83b3a2fe18 100644
--- a/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java
+++ b/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java
@@ -423,7 +423,7 @@ void testPassBookmarksExample() throws Exception
     @Test
     void testAsyncExplicitTransactionExample() throws Exception
     {
-        try ( AsyncExplicitTransactionExample example = new AsyncExplicitTransactionExample( uri, USER, PASSWORD ) )
+        try ( AsyncUnmanagedTransactionExample example = new AsyncUnmanagedTransactionExample( uri, USER, PASSWORD ) )
         {
             // create a 'Product' node
             try ( Session session = neo4j.driver().session() )
@@ -510,7 +510,7 @@ void testShouldRunRxAutocommitTransactionExample() throws Exception
     @EnabledOnNeo4jWith( BOLT_V4 )
     void testRxExplicitTransactionExample() throws Exception
     {
-        try ( RxExplicitTransactionExample example = new RxExplicitTransactionExample( uri, USER, PASSWORD ) )
+        try ( RxUnmanagedTransactionExample example = new RxUnmanagedTransactionExample( uri, USER, PASSWORD ) )
         {
             // create a 'Product' node
             try ( Session session = neo4j.driver().session() )

From 83aa0839e5567f14e843190a2450f05027e56365 Mon Sep 17 00:00:00 2001
From: Nigel Small 
Date: Mon, 18 Nov 2019 13:36:48 +0000
Subject: [PATCH 4/7] Highlight managed/unmanaged in Session commentary

---
 .../main/java/org/neo4j/driver/Session.java   | 104 ++++++++++--------
 1 file changed, 56 insertions(+), 48 deletions(-)

diff --git a/driver/src/main/java/org/neo4j/driver/Session.java b/driver/src/main/java/org/neo4j/driver/Session.java
index ff7ec618fc..76d1d82928 100644
--- a/driver/src/main/java/org/neo4j/driver/Session.java
+++ b/driver/src/main/java/org/neo4j/driver/Session.java
@@ -26,38 +26,29 @@
 /**
  * Provides a context of work for database interactions.
  * 

- * A Session hosts a series of {@linkplain Transaction transactions}
- * carried out against a database. Within the database, all queries are
- * carried out within a transaction. Within application code, however, it is
- * not always necessary to explicitly {@link #beginTransaction() begin a
- * transaction}. If a query is {@link #run} directly against a {@link
- * Session}, the server will automatically BEGIN and
- * COMMIT that query within its own transaction. This type
- * of transaction is known as an autocommit transaction.
+ * A Session is a logical container for a causally chained series of
+ * {@linkplain Transaction transactions}. Client applications typically work
+ * with managed transactions, which come in two flavours: transaction
+ * functions and auto-commit transactions. Managed transactions automatically
+ * handle the transaction boundaries (BEGIN and
+ * COMMIT/ROLLBACK) and can also provide other
+ * supporting features; transaction functions offer retry capabilities, for
+ * example.
  * 

- * Unmanaged transactions allow multiple queries to be committed as part of
- * a single atomic operation and can be rolled back if necessary. They can also
- * be used to ensure causal consistency, meaning that an application
- * can run a series of queries on different members of a cluster, while
- * ensuring that each query sees the state of graph at least as up-to-date as
- * the graph seen by the previous query. For more on causal consistency, see
- * the Neo4j clustering manual.
+ * Unmanaged transactions are also available but tend to be used by libraries
+ * or tooling that require more fine-grained control.
  * 

- * Typically, a session will acquire a TCP connection to execute query or
- * transaction. Such a connection will be acquired from a connection pool
- * and released back there when query result is consumed or transaction is
- * committed or rolled back. One connection can therefore be adopted by many
- * sessions, although by only one at a time. Application code should never need
- * to deal directly with connection management.
+ * Typically, a session will acquire a TCP connection from a connection pool
+ * in order to carry out a transaction. Once the transaction has completed,
+ * and the entire result has been consumed, this connection will be released
+ * back into the pool. One connection can therefore be adopted by several
+ * sessions over its lifetime, although it will only be owned by one at a
+ * time. Client applications should never need to deal directly with
+ * connection management.
  * 

- * A session inherits its destination address and permissions from its
- * underlying connection. This means that for a single query/transaction one
- * session may only ever target one machine within a cluster and does not
- * support re-authentication. To achieve otherwise requires creation of a
- * separate session.
- * 

- * Similarly, multiple sessions should be used when working with concurrency;
- * session implementations are not thread safe.
+ * Session implementations are not generally thread-safe. Therefore, multiple
+ * sessions should be used when an application requires multiple concurrent
+ * threads of database work to be carried out.
  *
  * @since 1.0 (Removed async API to {@link AsyncSession} in 2.0)
  */
@@ -74,10 +65,10 @@ public interface Session extends Resource, QueryRunner
     Transaction beginTransaction();
 
     /**
-     * Begin a new unmanaged {@linkplain Transaction transaction} with the specified {@link TransactionConfig configuration}.
-     * At most one transaction may exist in a session at any point in time. To
-     * maintain multiple concurrent transactions, use multiple concurrent
-     * sessions.
+     * Begin a new unmanaged {@linkplain Transaction transaction} with
+     * the specified {@link TransactionConfig configuration}. At most one
+     * transaction may exist in a session at any point in time. To maintain
+     * multiple concurrent transactions, use multiple concurrent sessions.
      *
      * @param config configuration for the new transaction.
      * @return a new {@link Transaction}
@@ -85,10 +76,13 @@ public interface Session extends Resource, QueryRunner
     Transaction beginTransaction( TransactionConfig config );
 
     /**
-     * Execute given unit of work in a  {@link AccessMode#READ read} transaction.
+     * Execute a unit of work in a managed {@link AccessMode#READ read} transaction.
+     * 

+     * This transaction will automatically be committed unless an exception is
+     * thrown during query execution or by the user code.
      * 

-     * Transaction will automatically be committed unless exception is thrown from the unit of work itself or during committing,
-     * or transaction is explicitly committed via {@link Transaction#commit()} or rolled back via {@link Transaction#rollback()}.
+     * Managed transactions should not generally be explicitly committed (via
+     * {@link Transaction#commit()}).
      *
      * @param work the {@link TransactionWork} to be applied to a new read transaction.
      * @param  the return type of the given unit of work.
@@ -97,10 +91,14 @@ public interface Session extends Resource, QueryRunner
      T readTransaction( TransactionWork work );
 
     /**
-     * Execute given unit of work in a  {@link AccessMode#READ read} transaction with the specified {@link TransactionConfig configuration}.
+     * Execute a unit of work in a managed {@link AccessMode#READ read} transaction
+     * with the specified {@link TransactionConfig configuration}.
      * 

-     * Transaction will automatically be committed unless exception is thrown from the unit of work itself or during committing,
-     * or transaction is explicitly committed via {@link Transaction#commit()} or rolled back via {@link Transaction#rollback()}.
+     * This transaction will automatically be committed unless an exception is
+     * thrown during query execution or by the user code.
+     * 

+     * Managed transactions should not generally be explicitly committed (via
+     * {@link Transaction#commit()}).
      *
      * @param work the {@link TransactionWork} to be applied to a new read transaction.
      * @param config configuration for all transactions started to execute the unit of work.
@@ -110,10 +108,13 @@ public interface Session extends Resource, QueryRunner
      T readTransaction( TransactionWork work, TransactionConfig config );
 
     /**
-     * Execute given unit of work in a  {@link AccessMode#WRITE write} transaction.
+     * Execute a unit of work in a managed {@link AccessMode#WRITE write} transaction.
+     * 

+     * This transaction will automatically be committed unless an exception is
+     * thrown during query execution or by the user code.
      * 

-     * Transaction will automatically be committed unless exception is thrown from the unit of work itself or during committing,
-     * or transaction is explicitly committed via {@link Transaction#commit()} or rolled back via {@link Transaction#rollback()}.
+     * Managed transactions should not generally be explicitly committed (via
+     * {@link Transaction#commit()}).
      *
      * @param work the {@link TransactionWork} to be applied to a new write transaction.
      * @param  the return type of the given unit of work.
@@ -122,10 +123,14 @@ public interface Session extends Resource, QueryRunner
      T writeTransaction( TransactionWork work );
 
     /**
-     * Execute given unit of work in a  {@link AccessMode#WRITE write} transaction with the specified {@link TransactionConfig configuration}.
+     * Execute a unit of work in a managed {@link AccessMode#WRITE write} transaction
+     * with the specified {@link TransactionConfig configuration}.
+     * 

+     * This transaction will automatically be committed unless an exception is
+     * thrown during query execution or by the user code.
      * 

-     * Transaction will automatically be committed unless exception is thrown from the unit of work itself or during committing,
-     * or transaction is explicitly committed via {@link Transaction#commit()} or rolled back via {@link Transaction#rollback()}.
+     * Managed transactions should not generally be explicitly committed (via
+     * {@link Transaction#commit()}).
      *
      * @param work the {@link TransactionWork} to be applied to a new write transaction.
      * @param config configuration for all transactions started to execute the unit of work.
@@ -135,7 +140,8 @@ public interface Session extends Resource, QueryRunner
      T writeTransaction( TransactionWork work, TransactionConfig config );
 
     /**
-     * Run a query in an auto-commit transaction with the specified {@link TransactionConfig configuration} and return a result stream.
+     * Run a query in a managed auto-commit transaction with the specified
+     * {@link TransactionConfig configuration}, and return a result stream.
      *
      * @param query text of a Neo4j query.
      * @param config configuration for the new transaction.
@@ -144,7 +150,8 @@ public interface Session extends Resource, QueryRunner
     Result run(String query, TransactionConfig config );
 
     /**
-     * Run a query with parameters in an auto-commit transaction with specified {@link TransactionConfig configuration} and return a result stream.
+     * Run a query with parameters in a managed auto-commit transaction with the
+     * specified {@link TransactionConfig configuration}, and return a result stream.
      * 

      * This method takes a set of parameters that will be injected into the
      * query by Neo4j. Using parameters is highly encouraged, it helps avoid
@@ -181,7 +188,8 @@ public interface Session extends Resource, QueryRunner
     Result run(String query, Map parameters, TransactionConfig config );
 
     /**
-     * Run a query in an auto-commit transaction with specified {@link TransactionConfig configuration} and return a result stream.
+     * Run a query in a managed auto-commit transaction with the specified
+     * {@link TransactionConfig configuration}, and return a result stream.
      * 
Example

      * 
      * {@code

From 45c50951293c833eceee5b18af2bd4cac2cd6e75 Mon Sep 17 00:00:00 2001
From: Nigel Small 
Date: Mon, 18 Nov 2019 15:16:59 +0000
Subject: [PATCH 5/7] Bug fixes

---
 .../driver/internal/messaging/v1/BoltProtocolV1Test.java    | 6 +++---
 .../driver/internal/messaging/v3/BoltProtocolV3Test.java    | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1Test.java
index c6f33f1caa..14c01f7fd8 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v1/BoltProtocolV1Test.java
@@ -86,9 +86,9 @@
 
 public class BoltProtocolV1Test
 {
-    private static final String QUERY = "RETURN $x";
+    private static final String QUERY_TEXT = "RETURN $x";
     private static final Map PARAMS = singletonMap( "x", value( 42 ) );
-    private static final Query QUERY = new Query( QUERY, value( PARAMS ) );
+    private static final Query QUERY = new Query( QUERY_TEXT, value( PARAMS ) );
 
     private final BoltProtocol protocol = createProtocol();
     private final EmbeddedChannel channel = new EmbeddedChannel();
@@ -370,7 +370,7 @@ private static ResponseHandler verifyRunInvoked( Connection connection )
         ArgumentCaptor runHandlerCaptor = ArgumentCaptor.forClass( ResponseHandler.class );
         ArgumentCaptor pullAllHandlerCaptor = ArgumentCaptor.forClass( ResponseHandler.class );
 
-        verify( connection ).write( eq( new RunMessage( QUERY, PARAMS ) ), runHandlerCaptor.capture() );
+        verify( connection ).write( eq( new RunMessage( QUERY_TEXT, PARAMS ) ), runHandlerCaptor.capture() );
         verify( connection ).writeAndFlush( eq( PullAllMessage.PULL_ALL ), pullAllHandlerCaptor.capture() );
 
         assertThat( runHandlerCaptor.getValue(), instanceOf( RunResponseHandler.class ) );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java
index dbbb80de5d..ef3b26378d 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java
@@ -93,9 +93,9 @@
 
 public class BoltProtocolV3Test
 {
-    protected static final String QUERY = "RETURN $x";
+    protected static final String QUERY_TEXT = "RETURN $x";
     protected static final Map PARAMS = singletonMap( "x", value( 42 ) );
-    protected static final Query QUERY = new Query( QUERY, value( PARAMS ) );
+    protected static final Query QUERY = new Query( QUERY_TEXT, value( PARAMS ) );
 
     protected final BoltProtocol protocol = createProtocol();
     private final EmbeddedChannel channel = new EmbeddedChannel();

From bffd000aa209648f917beea38a8c01f09b4b79b7 Mon Sep 17 00:00:00 2001
From: Nigel Small 
Date: Mon, 18 Nov 2019 16:05:32 +0000
Subject: [PATCH 6/7] More test renames

---
 .../neo4j/driver/integration/SessionBoltV3IT.java    |  2 +-
 .../org/neo4j/driver/integration/SessionResetIT.java |  4 ++--
 .../driver/integration/UnsupportedBoltV3IT.java      |  4 ++--
 .../internal/messaging/v3/BoltProtocolV3Test.java    | 12 ++++++------
 .../internal/messaging/v4/BoltProtocolV4Test.java    |  2 +-
 .../test/java/org/neo4j/docs/driver/ExamplesIT.java  |  4 ++--
 6 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/driver/src/test/java/org/neo4j/driver/integration/SessionBoltV3IT.java b/driver/src/test/java/org/neo4j/driver/integration/SessionBoltV3IT.java
index 8d18312d5c..f7f4cb699f 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/SessionBoltV3IT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/SessionBoltV3IT.java
@@ -220,7 +220,7 @@ void shouldUseBookmarksForAutoCommitTransactions()
     }
 
     @Test
-    void shouldUseBookmarksForAutoCommitAndExplicitTransactions()
+    void shouldUseBookmarksForAutoCommitAndUnmanagedTransactions()
     {
         Session session = driver.session();
         Bookmark initialBookmark = session.lastBookmark();
diff --git a/driver/src/test/java/org/neo4j/driver/integration/SessionResetIT.java b/driver/src/test/java/org/neo4j/driver/integration/SessionResetIT.java
index 02ae6761e0..7509608554 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/SessionResetIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/SessionResetIT.java
@@ -135,7 +135,7 @@ void shouldTerminateAutoCommitQuery()
     }
 
     @Test
-    void shouldTerminateQueryInExplicitTransaction()
+    void shouldTerminateQueryInUnmanagedTransaction()
     {
         testQueryTermination( LONG_QUERY, false );
     }
@@ -165,7 +165,7 @@ void shouldTerminateAutoCommitQueriesRandomly() throws Exception
     }
 
     @Test
-    void shouldTerminateQueriesInExplicitTransactionsRandomly() throws Exception
+    void shouldTerminateQueriesInUnmanagedTransactionsRandomly() throws Exception
     {
         testRandomQueryTermination( false );
     }
diff --git a/driver/src/test/java/org/neo4j/driver/integration/UnsupportedBoltV3IT.java b/driver/src/test/java/org/neo4j/driver/integration/UnsupportedBoltV3IT.java
index f601b093dc..56001dbf9e 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/UnsupportedBoltV3IT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/UnsupportedBoltV3IT.java
@@ -75,13 +75,13 @@ void shouldNotSupportAsyncTransactionFunctionsWithTransactionConfig()
     }
 
     @Test
-    void shouldNotSupportExplicitTransactionsWithTransactionConfig()
+    void shouldNotSupportUnmanagedTransactionsWithTransactionConfig()
     {
         assertTxConfigNotSupported( () -> driver.session().beginTransaction( txConfig ) );
     }
 
     @Test
-    void shouldNotSupportAsyncExplicitTransactionsWithTransactionConfig()
+    void shouldNotSupportAsyncUnmanagedTransactionsWithTransactionConfig()
     {
         assertTxConfigNotSupported( driver.asyncSession().beginTransactionAsync( txConfig ) );
     }
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java
index ef3b26378d..1d42d152d4 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java
@@ -305,23 +305,23 @@ void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunRe
 
     @ParameterizedTest
     @EnumSource( AccessMode.class )
-    void shouldRunInExplicitTransactionWithoutWaitingForRunResponse( AccessMode mode ) throws Exception
+    void shouldRunInUnmanagedTransactionWithoutWaitingForRunResponse(AccessMode mode ) throws Exception
     {
         testRunWithoutWaitingForRunResponse( false, TransactionConfig.empty(), mode );
     }
 
     @ParameterizedTest
     @EnumSource( AccessMode.class )
-    void shouldRunInExplicitTransactionAndWaitForSuccessRunResponse( AccessMode mode ) throws Exception
+    void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse(AccessMode mode ) throws Exception
     {
-        testRunInExplicitTransactionAndWaitForRunResponse( true, mode );
+        testRunInUnmanagedTransactionAndWaitForRunResponse( true, mode );
     }
 
     @ParameterizedTest
     @EnumSource( AccessMode.class )
-    void shouldRunInExplicitTransactionAndWaitForFailureRunResponse( AccessMode mode ) throws Exception
+    void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse(AccessMode mode ) throws Exception
     {
-        testRunInExplicitTransactionAndWaitForRunResponse( false, mode );
+        testRunInUnmanagedTransactionAndWaitForRunResponse( false, mode );
     }
 
     @Test
@@ -354,7 +354,7 @@ protected void testDatabaseNameSupport( boolean autoCommitTx )
         assertThat( e.getMessage(), startsWith( "Database name parameter for selecting database is not supported" ) );
     }
 
-    protected void testRunInExplicitTransactionAndWaitForRunResponse( boolean success, AccessMode mode ) throws Exception
+    protected void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success, AccessMode mode ) throws Exception
     {
         // Given
         Connection connection = connectionMock( mode, protocol );
diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java
index 10085e9455..9ccf277e43 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java
@@ -126,7 +126,7 @@ protected void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( Bookmark b
     }
 
     @Override
-    protected void testRunInExplicitTransactionAndWaitForRunResponse( boolean success, AccessMode mode ) throws Exception
+    protected void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success, AccessMode mode ) throws Exception
     {
         // Given
         Connection connection = connectionMock( mode, protocol );
diff --git a/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java b/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java
index 83b3a2fe18..fe4e32c25d 100644
--- a/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java
+++ b/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java
@@ -421,7 +421,7 @@ void testPassBookmarksExample() throws Exception
     }
 
     @Test
-    void testAsyncExplicitTransactionExample() throws Exception
+    void testAsyncUnmanagedTransactionExample() throws Exception
     {
         try ( AsyncUnmanagedTransactionExample example = new AsyncUnmanagedTransactionExample( uri, USER, PASSWORD ) )
         {
@@ -508,7 +508,7 @@ void testShouldRunRxAutocommitTransactionExample() throws Exception
 
     @Test
     @EnabledOnNeo4jWith( BOLT_V4 )
-    void testRxExplicitTransactionExample() throws Exception
+    void testRxUnmanagedTransactionExample() throws Exception
     {
         try ( RxUnmanagedTransactionExample example = new RxUnmanagedTransactionExample( uri, USER, PASSWORD ) )
         {

From 5ebe0f9cf46ea1fcee8081a5f597410571085f15 Mon Sep 17 00:00:00 2001
From: Nigel Small 
Date: Mon, 18 Nov 2019 16:07:39 +0000
Subject: [PATCH 7/7] Undid license change

---
 LICENSE.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/LICENSE.txt b/LICENSE.txt
index a1fac6c0ad..d645695673 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -121,7 +121,7 @@
           that such additional attribution notices cannot be construed
           as modifying the License.
 
-      You may add Your own copyright query to Your modifications and
+      You may add Your own copyright statement to Your modifications and
       may provide additional or different license terms and conditions
       for use, reproduction, or distribution of Your modifications, or
       for any such Derivative Works as a whole, provided Your use,