feat: delete deprecated transaction functions (#1647)

BREAKING CHANGE: the deprecated `writeTransaction` and `readTransaction` have been deleted, please use `executeWrite` and `executeRead`

Author: injectives

driver/clirr-ignored-differences.xml

@@ -712,4 +712,62 @@
         <method>org.neo4j.driver.Bookmark lastBookmark()</method>
     </difference>
 
+    <difference>
+        <className>org/neo4j/driver/Session</className>
+        <differenceType>7002</differenceType>
+        <method>java.lang.Object readTransaction(org.neo4j.driver.TransactionWork)</method>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/Session</className>
+        <differenceType>7002</differenceType>
+        <method>java.lang.Object readTransaction(org.neo4j.driver.TransactionWork, org.neo4j.driver.TransactionConfig)</method>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/Session</className>
+        <differenceType>7002</differenceType>
+        <method>java.lang.Object writeTransaction(org.neo4j.driver.TransactionWork)</method>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/Session</className>
+        <differenceType>7002</differenceType>
+        <method>java.lang.Object writeTransaction(org.neo4j.driver.TransactionWork, org.neo4j.driver.TransactionConfig)</method>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/async/AsyncSession</className>
+        <differenceType>7002</differenceType>
+        <method>java.util.concurrent.CompletionStage readTransactionAsync(org.neo4j.driver.async.AsyncTransactionWork)</method>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/async/AsyncSession</className>
+        <differenceType>7002</differenceType>
+        <method>java.util.concurrent.CompletionStage readTransactionAsync(org.neo4j.driver.async.AsyncTransactionWork, org.neo4j.driver.TransactionConfig)</method>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/async/AsyncSession</className>
+        <differenceType>7002</differenceType>
+        <method>java.util.concurrent.CompletionStage writeTransactionAsync(org.neo4j.driver.async.AsyncTransactionWork)</method>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/async/AsyncSession</className>
+        <differenceType>7002</differenceType>
+        <method>java.util.concurrent.CompletionStage writeTransactionAsync(org.neo4j.driver.async.AsyncTransactionWork, org.neo4j.driver.TransactionConfig)</method>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/TransactionWork</className>
+        <differenceType>8001</differenceType>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/async/AsyncTransactionWork</className>
+        <differenceType>8001</differenceType>
+    </difference>
+
 </differences>

driver/src/main/java/org/neo4j/driver/Session.java

@@ -73,21 +73,6 @@ public interface Session extends BaseSession, Resource, QueryRunner {
      */
     Transaction beginTransaction(TransactionConfig config);
 
-    /**
-     * Execute a unit of work in a managed {@link AccessMode#READ read} transaction.
-     * <p>
-     * This transaction will automatically be committed unless an exception is thrown during query execution or by the user code.
-     * <p>
-     * Managed transactions should not be explicitly committed (via {@link Transaction#commit()}).
-     *
-     * @param work the {@link TransactionWork} to be applied to a new read transaction.
-     * @param <T>  the return type of the given unit of work.
-     * @return a result as returned by the given unit of work.
-     * @deprecated superseded by {@link #executeRead(TransactionCallback)}.
-     */
-    @Deprecated
-    <T> T readTransaction(TransactionWork<T> work);
-
     /**
      * Execute a unit of work as a single, managed transaction with {@link AccessMode#READ read} access mode and retry behaviour. The transaction allows for one
      * or more statements to be run.
@@ -105,22 +90,6 @@ default <T> T executeRead(TransactionCallback<T> callback) {
         return executeRead(callback, TransactionConfig.empty());
     }
 
-    /**
-     * Execute a unit of work in a managed {@link AccessMode#READ read} transaction with the specified {@link TransactionConfig configuration}.
-     * <p>
-     * This transaction will automatically be committed unless an exception is thrown during query execution or by the user code.
-     * <p>
-     * Managed transactions should not 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.
-     * @param <T>    the return type of the given unit of work.
-     * @return a result as returned by the given unit of work.
-     * @deprecated superseded by {@link #executeRead(TransactionCallback, TransactionConfig)}.
-     */
-    @Deprecated
-    <T> T readTransaction(TransactionWork<T> work, TransactionConfig config);
-
     /**
      * Execute a unit of work as a single, managed transaction with {@link AccessMode#READ read} access mode and retry behaviour. The transaction allows for one
      * or more statements to be run.
@@ -137,21 +106,6 @@ default <T> T executeRead(TransactionCallback<T> callback) {
      */
     <T> T executeRead(TransactionCallback<T> callback, TransactionConfig config);
 
-    /**
-     * Execute a unit of work in a managed {@link AccessMode#WRITE write} transaction.
-     * <p>
-     * This transaction will automatically be committed unless an exception is thrown during query execution or by the user code.
-     * <p>
-     * Managed transactions should not be explicitly committed (via {@link Transaction#commit()}).
-     *
-     * @param work the {@link TransactionWork} to be applied to a new write transaction.
-     * @param <T>  the return type of the given unit of work.
-     * @return a result as returned by the given unit of work.
-     * @deprecated superseded by {@link #executeWrite(TransactionCallback)}.
-     */
-    @Deprecated
-    <T> T writeTransaction(TransactionWork<T> work);
-
     /**
      * Execute a unit of work as a single, managed transaction with {@link AccessMode#WRITE write} access mode and retry behaviour. The transaction allows for
      * one or more statements to be run.
@@ -186,22 +140,6 @@ default void executeWriteWithoutResult(Consumer<TransactionContext> contextConsu
         });
     }
 
-    /**
-     * Execute a unit of work in a managed {@link AccessMode#WRITE write} transaction with the specified {@link TransactionConfig configuration}.
-     * <p>
-     * This transaction will automatically be committed unless an exception is thrown during query execution or by the user code.
-     * <p>
-     * Managed transactions should not 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.
-     * @param <T>    the return type of the given unit of work.
-     * @return a result as returned by the given unit of work.
-     * @deprecated superseded by {@link #executeWrite(TransactionCallback, TransactionConfig)}.
-     */
-    @Deprecated
-    <T> T writeTransaction(TransactionWork<T> work, TransactionConfig config);
-
     /**
      * Execute a unit of work as a single, managed transaction with {@link AccessMode#WRITE write} access mode and retry behaviour. The transaction allows for one or more statements to be run.
      * <p>

driver/src/main/java/org/neo4j/driver/TransactionWork.java

@@ -112,31 +112,6 @@ public interface AsyncSession extends BaseSession, AsyncQueryRunner {
      */
     CompletionStage<AsyncTransaction> beginTransactionAsync(TransactionConfig config);
 
-    /**
-     * Execute given unit of asynchronous work in a  {@link AccessMode#READ read} asynchronous transaction.
-     * <p>
-     * Transaction will automatically be committed unless given unit of work fails or
-     * {@link AsyncTransaction#commitAsync() async transaction commit} fails.
-     * It will also not be committed if explicitly rolled back via {@link AsyncTransaction#rollbackAsync()}.
-     * <p>
-     * Returned stage and given {@link AsyncTransactionWork} can be completed/executed by an IO thread which should never block.
-     * Otherwise IO operations on this and potentially other network connections might deadlock.
-     * Please do not chain blocking operations like {@link CompletableFuture#get()} on the returned stage and do not use them inside the
-     * {@link AsyncTransactionWork}.
-     * Consider using asynchronous calls throughout the chain or offloading blocking operation to a different {@link Executor}.
-     * This can be done using methods with "Async" suffix like
-     * {@link CompletionStage#thenApplyAsync(Function)} or {@link CompletionStage#thenApplyAsync(Function, Executor)}.
-     *
-     * @param work the {@link AsyncTransactionWork} to be applied to a new read transaction. Operation executed by the
-     * given work must be asynchronous.
-     * @param <T> the return type of the given unit of work.
-     * @return a {@link CompletionStage completion stage} completed with the same result as returned by the given
-     * unit of work. Stage can be completed exceptionally if given work or commit fails.
-     * @deprecated superseded by {@link #executeReadAsync(AsyncTransactionCallback)}.
-     */
-    @Deprecated
-    <T> CompletionStage<T> readTransactionAsync(AsyncTransactionWork<CompletionStage<T>> work);
-
     /**
      * Execute a unit of work as a single, managed transaction with {@link AccessMode#READ read} access mode and retry behaviour. The transaction allows for one
      * or more statements to be run.
@@ -157,34 +132,6 @@ default <T> CompletionStage<T> executeReadAsync(AsyncTransactionCallback<Complet
         return executeReadAsync(callback, TransactionConfig.empty());
     }
 
-    /**
-     * Execute given unit of asynchronous work in a  {@link AccessMode#READ read} asynchronous transaction with
-     * the specified {@link TransactionConfig configuration}.
-     * <p>
-     * Transaction will automatically be committed unless given unit of work fails or
-     * {@link AsyncTransaction#commitAsync() async transaction commit} fails.
-     * It will also not be committed if explicitly rolled back via {@link AsyncTransaction#rollbackAsync()}.
-     * <p>
-     * Returned stage and given {@link AsyncTransactionWork} can be completed/executed by an IO thread which should never block.
-     * Otherwise IO operations on this and potentially other network connections might deadlock.
-     * Please do not chain blocking operations like {@link CompletableFuture#get()} on the returned stage and do not use them inside the
-     * {@link AsyncTransactionWork}.
-     * Consider using asynchronous calls throughout the chain or offloading blocking operation to a different {@link Executor}.
-     * This can be done using methods with "Async" suffix like
-     * {@link CompletionStage#thenApplyAsync(Function)} or {@link CompletionStage#thenApplyAsync(Function, Executor)}.
-     *
-     * @param work the {@link  AsyncTransactionWork} to be applied to a new read transaction. Operation executed by the
-     * given work must be asynchronous.
-     * @param config configuration for all transactions started to execute the unit of work.
-     * @param <T> the return type of the given unit of work.
-     * @return a {@link CompletionStage completion stage} completed with the same result as returned by the given
-     * unit of work. Stage can be completed exceptionally if given work or commit fails.
-     * @deprecated superseded by {@link #executeReadAsync(AsyncTransactionCallback, TransactionConfig)}.
-     */
-    @Deprecated
-    <T> CompletionStage<T> readTransactionAsync(
-            AsyncTransactionWork<CompletionStage<T>> work, TransactionConfig config);
-
     /**
      * Execute a unit of work as a single, managed transaction with {@link AccessMode#READ read} access mode and retry behaviour. The transaction allows for one or more statements to be run.
      * <p>
@@ -204,31 +151,6 @@ <T> CompletionStage<T> readTransactionAsync(
     <T> CompletionStage<T> executeReadAsync(
             AsyncTransactionCallback<CompletionStage<T>> callback, TransactionConfig config);
 
-    /**
-     * Execute given unit of asynchronous work in a  {@link AccessMode#WRITE write} asynchronous transaction.
-     * <p>
-     * Transaction will automatically be committed unless given unit of work fails or
-     * {@link AsyncTransaction#commitAsync() async transaction commit} fails. It will also not be committed if explicitly
-     * rolled back via {@link AsyncTransaction#rollbackAsync()}.
-     * <p>
-     * Returned stage and given {@link  AsyncTransactionWork} can be completed/executed by an IO thread which should never block.
-     * Otherwise IO operations on this and potentially other network connections might deadlock.
-     * Please do not chain blocking operations like {@link CompletableFuture#get()} on the returned stage and do not use them inside the
-     * {@link AsyncTransactionWork}.
-     * Consider using asynchronous calls throughout the chain or offloading blocking operation to a different {@link Executor}.
-     * This can be done using methods with "Async" suffix like
-     * {@link CompletionStage#thenApplyAsync(Function)} or {@link CompletionStage#thenApplyAsync(Function, Executor)}.
-     *
-     * @param work the {@link AsyncTransactionWork} to be applied to a new write transaction. Operation executed by the
-     * given work must be asynchronous.
-     * @param <T> the return type of the given unit of work.
-     * @return a {@link CompletionStage completion stage} completed with the same result as returned by the given
-     * unit of work. Stage can be completed exceptionally if given work or commit fails.
-     * @deprecated superseded by {@link #executeWriteAsync(AsyncTransactionCallback)}.
-     */
-    @Deprecated
-    <T> CompletionStage<T> writeTransactionAsync(AsyncTransactionWork<CompletionStage<T>> work);
-
     /**
      * Execute a unit of work as a single, managed transaction with {@link AccessMode#WRITE write} access mode and retry behaviour. The transaction allows for
      * one or more statements to be run.
@@ -249,34 +171,6 @@ default <T> CompletionStage<T> executeWriteAsync(AsyncTransactionCallback<Comple
         return executeWriteAsync(callback, TransactionConfig.empty());
     }
 
-    /**
-     * Execute given unit of asynchronous work in a  {@link AccessMode#WRITE write} asynchronous transaction with
-     * the specified {@link TransactionConfig configuration}.
-     * <p>
-     * Transaction will automatically be committed unless given unit of work fails or
-     * {@link AsyncTransaction#commitAsync() async transaction commit} fails. It will also not be committed if explicitly
-     * rolled back via {@link AsyncTransaction#rollbackAsync()}.
-     * <p>
-     * Returned stage and given {@link AsyncTransactionWork} can be completed/executed by an IO thread which should never block.
-     * Otherwise IO operations on this and potentially other network connections might deadlock.
-     * Please do not chain blocking operations like {@link CompletableFuture#get()} on the returned stage and do not use them inside the
-     * {@link AsyncTransactionWork}.
-     * Consider using asynchronous calls throughout the chain or offloading blocking operation to a different {@link Executor}.
-     * This can be done using methods with "Async" suffix like
-     * {@link CompletionStage#thenApplyAsync(Function)} or {@link CompletionStage#thenApplyAsync(Function, Executor)}.
-     *
-     * @param work the {@link AsyncTransactionWork} to be applied to a new write transaction. Operation executed by the
-     * given work must be asynchronous.
-     * @param config configuration for all transactions started to execute the unit of work.
-     * @param <T> the return type of the given unit of work.
-     * @return a {@link CompletionStage completion stage} completed with the same result as returned by the given
-     * unit of work. Stage can be completed exceptionally if given work or commit fails.
-     * @deprecated superseded by {@link #executeWriteAsync(AsyncTransactionCallback, TransactionConfig)}.
-     */
-    @Deprecated
-    <T> CompletionStage<T> writeTransactionAsync(
-            AsyncTransactionWork<CompletionStage<T>> work, TransactionConfig config);
-
     /**
      * Execute a unit of work as a single, managed transaction with {@link AccessMode#WRITE write} access mode and retry behaviour. The transaction allows for one or more statements to be run.
      * <p>