Dedicated functional interface for readTx and writeTx

lutovich · lutovich · commit 0035520d81d3 · 2017-03-08T00:44:18.000+01:00
Added dedicated functional interface `TransactionWork` to be used in
`Session#readTransaction()` and `Session#writeTransaction()` methods.
It does not change how code looks for Java 8 lambdas but looks better with
Java 7 where users do not need to implement `Function&lt;T,U&gt;` where first
generic type parameter is always `Transaction`.
diff --git a/driver/src/main/java/org/neo4j/driver/internal/NetworkSession.java b/driver/src/main/java/org/neo4j/driver/internal/NetworkSession.java
@@ -37,11 +37,11 @@
 import org.neo4j.driver.v1.Statement;
 import org.neo4j.driver.v1.StatementResult;
 import org.neo4j.driver.v1.Transaction;
+import org.neo4j.driver.v1.TransactionWork;
 import org.neo4j.driver.v1.Value;
 import org.neo4j.driver.v1.Values;
 import org.neo4j.driver.v1.exceptions.ClientException;
 import org.neo4j.driver.v1.types.TypeSystem;
-import org.neo4j.driver.v1.util.Function;
 
 import static org.neo4j.driver.v1.Values.value;
 
@@ -182,13 +182,13 @@ public synchronized Transaction beginTransaction( String bookmark )
     }
 
     @Override
-    public <T> T readTransaction( Function<Transaction,T> work )
+    public <T> T readTransaction( TransactionWork<T> work )
     {
         return transaction( AccessMode.READ, work );
     }
 
     @Override
-    public <T> T writeTransaction( Function<Transaction,T> work )
+    public <T> T writeTransaction( TransactionWork<T> work )
     {
         return transaction( AccessMode.WRITE, work );
     }
@@ -244,7 +244,7 @@ public synchronized void onConnectionError( boolean recoverable )
         }
     }
 
-    private synchronized <T> T transaction( AccessMode mode, Function<Transaction,T> work )
+    private synchronized <T> T transaction( AccessMode mode, TransactionWork<T> work )
     {
         RetryDecision decision = null;
         List<Throwable> errors = null;
@@ -253,7 +253,7 @@ private synchronized <T> T transaction( AccessMode mode, Function<Transaction,T>
         {
             try ( Transaction tx = beginTransaction( mode ) )
             {
-                return work.apply( tx );
+                return work.execute( tx );
             }
             catch ( Throwable newError )
             {
diff --git a/driver/src/main/java/org/neo4j/driver/v1/Session.java b/driver/src/main/java/org/neo4j/driver/v1/Session.java
@@ -18,7 +18,6 @@
  */
 package org.neo4j.driver.v1;
 
-import org.neo4j.driver.v1.util.Function;
 import org.neo4j.driver.v1.util.Resource;
 
 /**
@@ -86,20 +85,20 @@ public interface Session extends Resource, StatementRunner
     /**
      * Execute given unit of work in a  {@link AccessMode#READ read} transaction.
      *
-     * @param work the {@link Function} to be applied to a new read transaction.
+     * @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.
      */
-    <T> T readTransaction( Function<Transaction,T> work );
+    <T> T readTransaction( TransactionWork<T> work );
 
     /**
      * Execute given unit of work in a {@link AccessMode#WRITE write} transaction.
      *
-     * @param work the {@link Function} to be applied to a new write transaction.
+     * @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.
      */
-    <T> T writeTransaction( Function<Transaction,T> work );
+    <T> T writeTransaction( TransactionWork<T> work );
 
     /**
      * Return the bookmark received following the last completed
diff --git a/driver/src/main/java/org/neo4j/driver/v1/TransactionWork.java b/driver/src/main/java/org/neo4j/driver/v1/TransactionWork.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2002-2017 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.v1;
+
+/**
+ * Callback that executes operations against a given {@link Transaction}.
+ * To be used with {@link Session#readTransaction(TransactionWork)} and
+ * {@link Session#writeTransaction(TransactionWork)} methods.
+ *
+ * @param <T> the return type of this work.
+ */
+public interface TransactionWork<T>
+{
+    /**
+     * Executes all given operations against the same transaction.
+     *
+     * @param tx the transaction to use.
+     * @return some result object or {@code null} if none.
+     */
+    T execute( Transaction tx );
+}
diff --git a/driver/src/test/java/org/neo4j/driver/internal/NetworkSessionTest.java b/driver/src/test/java/org/neo4j/driver/internal/NetworkSessionTest.java
@@ -38,11 +38,11 @@
 import org.neo4j.driver.v1.AccessMode;
 import org.neo4j.driver.v1.Session;
 import org.neo4j.driver.v1.Transaction;
+import org.neo4j.driver.v1.TransactionWork;
 import org.neo4j.driver.v1.Value;
 import org.neo4j.driver.v1.exceptions.ClientException;
 import org.neo4j.driver.v1.exceptions.ServiceUnavailableException;
 import org.neo4j.driver.v1.exceptions.SessionExpiredException;
-import org.neo4j.driver.v1.util.Function;
 
 import static java.util.Collections.singletonMap;
 import static org.hamcrest.CoreMatchers.containsString;
@@ -764,10 +764,10 @@ private static void testConnectionAcquisition( AccessMode sessionMode, AccessMod
         when( connectionProvider.acquireConnection( transactionMode ) ).thenReturn( connection );
         NetworkSession session = newSession( connectionProvider, sessionMode );
 
-        Function<Transaction,Integer> work = new Function<Transaction,Integer>()
+        TransactionWork<Integer> work = new TransactionWork<Integer>()
         {
             @Override
-            public Integer apply( Transaction tx )
+            public Integer execute( Transaction tx )
             {
                 tx.success();
                 return 42;
@@ -789,10 +789,10 @@ private static void testTxCommitOrRollback( AccessMode transactionMode, final bo
         when( connectionProvider.acquireConnection( transactionMode ) ).thenReturn( connection );
         NetworkSession session = newSession( connectionProvider, WRITE );
 
-        Function<Transaction,Integer> work = new Function<Transaction,Integer>()
+        TransactionWork<Integer> work = new TransactionWork<Integer>()
         {
             @Override
-            public Integer apply( Transaction tx )
+            public Integer execute( Transaction tx )
             {
                 if ( commit )
                 {
@@ -831,10 +831,10 @@ private static void testTxRollbackWhenThrows( AccessMode transactionMode )
         NetworkSession session = newSession( connectionProvider, WRITE );
 
         final RuntimeException error = new IllegalStateException( "Oh!" );
-        Function<Transaction,Void> work = new Function<Transaction,Void>()
+        TransactionWork<Void> work = new TransactionWork<Void>()
         {
             @Override
-            public Void apply( Transaction tx )
+            public Void execute( Transaction tx )
             {
                 throw error;
             }
@@ -864,12 +864,12 @@ private static void testTxIsRetriedUntilSuccessWhenFunctionThrows( AccessMode mo
         when( connectionProvider.acquireConnection( mode ) ).thenReturn( connection );
         NetworkSession session = newSession( connectionProvider, retryLogic );
 
-        int answer = executeTransaction( session, mode, new Function<Transaction,Integer>()
+        int answer = executeTransaction( session, mode, new TransactionWork<Integer>()
         {
             int invoked;
 
             @Override
-            public Integer apply( Transaction tx )
+            public Integer execute( Transaction tx )
             {
                 if ( invoked++ < failures )
                 {
@@ -896,10 +896,10 @@ private static void testTxIsRetriedUntilSuccessWhenTxCloseThrows( AccessMode mod
         when( connectionProvider.acquireConnection( mode ) ).thenReturn( connection );
         NetworkSession session = newSession( connectionProvider, retryLogic );
 
-        int answer = executeTransaction( session, mode, new Function<Transaction,Integer>()
+        int answer = executeTransaction( session, mode, new TransactionWork<Integer>()
         {
             @Override
-            public Integer apply( Transaction tx )
+            public Integer execute( Transaction tx )
             {
                 tx.success();
                 return 43;
@@ -925,12 +925,12 @@ private static void testTxIsRetriedUntilFailureWhenFunctionThrows( AccessMode mo
 
         try
         {
-            executeTransaction( session, mode, new Function<Transaction,Integer>()
+            executeTransaction( session, mode, new TransactionWork<Integer>()
             {
                 int invoked;
 
                 @Override
-                public Integer apply( Transaction tx )
+                public Integer execute( Transaction tx )
                 {
                     if ( invoked++ < failures )
                     {
@@ -963,10 +963,10 @@ private static void testTxIsRetriedUntilFailureWhenTxCloseThrows( AccessMode mod
 
         try
         {
-            executeTransaction( session, mode, new Function<Transaction,Integer>()
+            executeTransaction( session, mode, new TransactionWork<Integer>()
             {
                 @Override
-                public Integer apply( Transaction tx )
+                public Integer execute( Transaction tx )
                 {
                     tx.success();
                     return 42;
@@ -992,12 +992,12 @@ private static void testRetryErrorsAreCombined( AccessMode mode )
 
         try
         {
-            executeTransaction( session, mode, new Function<Transaction,Integer>()
+            executeTransaction( session, mode, new TransactionWork<Integer>()
             {
                 int invoked;
 
                 @Override
-                public Integer apply( Transaction tx )
+                public Integer execute( Transaction tx )
                 {
                     if ( invoked++ < failures )
                     {
@@ -1035,12 +1035,12 @@ private static void testRetryErrorsAreNotCombinedWhenSameErrorIsThrown( AccessMo
         final ServiceUnavailableException error = new ServiceUnavailableException( "Oh!" );
         try
         {
-            executeTransaction( session, mode, new Function<Transaction,Integer>()
+            executeTransaction( session, mode, new TransactionWork<Integer>()
             {
                 int invoked;
 
                 @Override
-                public Integer apply( Transaction tx )
+                public Integer execute( Transaction tx )
                 {
                     if ( invoked++ < failures )
                     {
@@ -1060,7 +1060,7 @@ public Integer apply( Transaction tx )
         }
     }
 
-    private static <T> T executeTransaction( Session session, AccessMode mode, Function<Transaction,T> work )
+    private static <T> T executeTransaction( Session session, AccessMode mode, TransactionWork<T> work )
     {
         if ( mode == READ )
         {
diff --git a/driver/src/test/java/org/neo4j/driver/internal/RoutingDriverBoltKitTest.java b/driver/src/test/java/org/neo4j/driver/internal/RoutingDriverBoltKitTest.java
@@ -44,6 +44,7 @@
 import org.neo4j.driver.v1.Record;
 import org.neo4j.driver.v1.Session;
 import org.neo4j.driver.v1.Transaction;
+import org.neo4j.driver.v1.TransactionWork;
 import org.neo4j.driver.v1.exceptions.ServiceUnavailableException;
 import org.neo4j.driver.v1.exceptions.SessionExpiredException;
 import org.neo4j.driver.v1.util.Function;
@@ -877,12 +878,12 @@ private static Driver newDriver( String uriString, DriverFactory driverFactory )
         return driverFactory.newInstance( uri, auth, routingConf, RetrySettings.DEFAULT, config );
     }
 
-    private static Function<Transaction,List<Record>> queryWork( final String query, final AtomicInteger invocations )
+    private static TransactionWork<List<Record>> queryWork( final String query, final AtomicInteger invocations )
     {
-        return new Function<Transaction,List<Record>>()
+        return new TransactionWork<List<Record>>()
         {
             @Override
-            public List<Record> apply( Transaction tx )
+            public List<Record> execute( Transaction tx )
             {
                 invocations.incrementAndGet();
                 return tx.run( query ).list();
diff --git a/driver/src/test/java/org/neo4j/driver/v1/integration/SessionIT.java b/driver/src/test/java/org/neo4j/driver/v1/integration/SessionIT.java
diff --git a/driver/src/test/java/org/neo4j/driver/v1/util/TestNeo4jSession.java b/driver/src/test/java/org/neo4j/driver/v1/util/TestNeo4jSession.java

Original file line number	Diff line number	Diff line change
`@@ -37,11 +37,11 @@`
`37`	`37`	`import org.neo4j.driver.v1.Statement;`
`38`	`38`	`import org.neo4j.driver.v1.StatementResult;`
`39`	`39`	`import org.neo4j.driver.v1.Transaction;`
	`40`	`+import org.neo4j.driver.v1.TransactionWork;`
`40`	`41`	`import org.neo4j.driver.v1.Value;`
`41`	`42`	`import org.neo4j.driver.v1.Values;`
`42`	`43`	`import org.neo4j.driver.v1.exceptions.ClientException;`
`43`	`44`	`import org.neo4j.driver.v1.types.TypeSystem;`
`44`		`-import org.neo4j.driver.v1.util.Function;`
`45`	`45`
`46`	`46`	`import static org.neo4j.driver.v1.Values.value;`
`47`	`47`
`@@ -182,13 +182,13 @@ public synchronized Transaction beginTransaction( String bookmark )`
`182`	`182`	`}`
`183`	`183`
`184`	`184`	`@Override`
`185`		`- public <T> T readTransaction( Function<Transaction,T> work )`
	`185`	`+ public <T> T readTransaction( TransactionWork<T> work )`
`186`	`186`	`{`
`187`	`187`	`return transaction( AccessMode.READ, work );`
`188`	`188`	`}`
`189`	`189`
`190`	`190`	`@Override`
`191`		`- public <T> T writeTransaction( Function<Transaction,T> work )`
	`191`	`+ public <T> T writeTransaction( TransactionWork<T> work )`
`192`	`192`	`{`
`193`	`193`	`return transaction( AccessMode.WRITE, work );`
`194`	`194`	`}`
`@@ -244,7 +244,7 @@ public synchronized void onConnectionError( boolean recoverable )`
`244`	`244`	`}`
`245`	`245`	`}`
`246`	`246`
`247`		`- private synchronized <T> T transaction( AccessMode mode, Function<Transaction,T> work )`
	`247`	`+ private synchronized <T> T transaction( AccessMode mode, TransactionWork<T> work )`
`248`	`248`	`{`
`249`	`249`	`RetryDecision decision = null;`
`250`	`250`	`List<Throwable> errors = null;`
`@@ -253,7 +253,7 @@ private synchronized <T> T transaction( AccessMode mode, Function<Transaction,T>`
`253`	`253`	`{`
`254`	`254`	`try ( Transaction tx = beginTransaction( mode ) )`
`255`	`255`	`{`
`256`		`- return work.apply( tx );`
	`256`	`+ return work.execute( tx );`
`257`	`257`	`}`
`258`	`258`	`catch ( Throwable newError )`
`259`	`259`	`{`
Original file line number	Diff line number	Diff line change
`@@ -38,11 +38,11 @@`
`38`	`38`	`import org.neo4j.driver.v1.AccessMode;`
`39`	`39`	`import org.neo4j.driver.v1.Session;`
`40`	`40`	`import org.neo4j.driver.v1.Transaction;`
	`41`	`+import org.neo4j.driver.v1.TransactionWork;`
`41`	`42`	`import org.neo4j.driver.v1.Value;`
`42`	`43`	`import org.neo4j.driver.v1.exceptions.ClientException;`
`43`	`44`	`import org.neo4j.driver.v1.exceptions.ServiceUnavailableException;`
`44`	`45`	`import org.neo4j.driver.v1.exceptions.SessionExpiredException;`
`45`		`-import org.neo4j.driver.v1.util.Function;`
`46`	`46`
`47`	`47`	`import static java.util.Collections.singletonMap;`
`48`	`48`	`import static org.hamcrest.CoreMatchers.containsString;`
`@@ -764,10 +764,10 @@ private static void testConnectionAcquisition( AccessMode sessionMode, AccessMod`
`764`	`764`	`when( connectionProvider.acquireConnection( transactionMode ) ).thenReturn( connection );`
`765`	`765`	`NetworkSession session = newSession( connectionProvider, sessionMode );`
`766`	`766`
`767`		`- Function<Transaction,Integer> work = new Function<Transaction,Integer>()`
	`767`	`+ TransactionWork<Integer> work = new TransactionWork<Integer>()`
`768`	`768`	`{`
`769`	`769`	`@Override`
`770`		`- public Integer apply( Transaction tx )`
	`770`	`+ public Integer execute( Transaction tx )`
`771`	`771`	`{`
`772`	`772`	`tx.success();`
`773`	`773`	`return 42;`
`@@ -789,10 +789,10 @@ private static void testTxCommitOrRollback( AccessMode transactionMode, final bo`
`789`	`789`	`when( connectionProvider.acquireConnection( transactionMode ) ).thenReturn( connection );`
`790`	`790`	`NetworkSession session = newSession( connectionProvider, WRITE );`
`791`	`791`
`792`		`- Function<Transaction,Integer> work = new Function<Transaction,Integer>()`
	`792`	`+ TransactionWork<Integer> work = new TransactionWork<Integer>()`
`793`	`793`	`{`
`794`	`794`	`@Override`
`795`		`- public Integer apply( Transaction tx )`
	`795`	`+ public Integer execute( Transaction tx )`
`796`	`796`	`{`
`797`	`797`	`if ( commit )`
`798`	`798`	`{`
`@@ -831,10 +831,10 @@ private static void testTxRollbackWhenThrows( AccessMode transactionMode )`
`831`	`831`	`NetworkSession session = newSession( connectionProvider, WRITE );`
`832`	`832`
`833`	`833`	`final RuntimeException error = new IllegalStateException( "Oh!" );`
`834`		`- Function<Transaction,Void> work = new Function<Transaction,Void>()`
	`834`	`+ TransactionWork<Void> work = new TransactionWork<Void>()`
`835`	`835`	`{`
`836`	`836`	`@Override`
`837`		`- public Void apply( Transaction tx )`
	`837`	`+ public Void execute( Transaction tx )`
`838`	`838`	`{`
`839`	`839`	`throw error;`
`840`	`840`	`}`
`@@ -864,12 +864,12 @@ private static void testTxIsRetriedUntilSuccessWhenFunctionThrows( AccessMode mo`
`864`	`864`	`when( connectionProvider.acquireConnection( mode ) ).thenReturn( connection );`
`865`	`865`	`NetworkSession session = newSession( connectionProvider, retryLogic );`
`866`	`866`
`867`		`- int answer = executeTransaction( session, mode, new Function<Transaction,Integer>()`
	`867`	`+ int answer = executeTransaction( session, mode, new TransactionWork<Integer>()`
`868`	`868`	`{`
`869`	`869`	`int invoked;`
`870`	`870`
`871`	`871`	`@Override`
`872`		`- public Integer apply( Transaction tx )`
	`872`	`+ public Integer execute( Transaction tx )`
`873`	`873`	`{`
`874`	`874`	`if ( invoked++ < failures )`
`875`	`875`	`{`
`@@ -896,10 +896,10 @@ private static void testTxIsRetriedUntilSuccessWhenTxCloseThrows( AccessMode mod`
`896`	`896`	`when( connectionProvider.acquireConnection( mode ) ).thenReturn( connection );`
`897`	`897`	`NetworkSession session = newSession( connectionProvider, retryLogic );`
`898`	`898`
`899`		`- int answer = executeTransaction( session, mode, new Function<Transaction,Integer>()`
	`899`	`+ int answer = executeTransaction( session, mode, new TransactionWork<Integer>()`
`900`	`900`	`{`
`901`	`901`	`@Override`
`902`		`- public Integer apply( Transaction tx )`
	`902`	`+ public Integer execute( Transaction tx )`
`903`	`903`	`{`
`904`	`904`	`tx.success();`
`905`	`905`	`return 43;`
`@@ -925,12 +925,12 @@ private static void testTxIsRetriedUntilFailureWhenFunctionThrows( AccessMode mo`
`925`	`925`
`926`	`926`	`try`
`927`	`927`	`{`
`928`		`- executeTransaction( session, mode, new Function<Transaction,Integer>()`
	`928`	`+ executeTransaction( session, mode, new TransactionWork<Integer>()`
`929`	`929`	`{`
`930`	`930`	`int invoked;`
`931`	`931`
`932`	`932`	`@Override`
`933`		`- public Integer apply( Transaction tx )`
	`933`	`+ public Integer execute( Transaction tx )`
`934`	`934`	`{`
`935`	`935`	`if ( invoked++ < failures )`
`936`	`936`	`{`
`@@ -963,10 +963,10 @@ private static void testTxIsRetriedUntilFailureWhenTxCloseThrows( AccessMode mod`
`963`	`963`
`964`	`964`	`try`
`965`	`965`	`{`
`966`		`- executeTransaction( session, mode, new Function<Transaction,Integer>()`
	`966`	`+ executeTransaction( session, mode, new TransactionWork<Integer>()`
`967`	`967`	`{`
`968`	`968`	`@Override`
`969`		`- public Integer apply( Transaction tx )`
	`969`	`+ public Integer execute( Transaction tx )`
`970`	`970`	`{`
`971`	`971`	`tx.success();`
`972`	`972`	`return 42;`
`@@ -992,12 +992,12 @@ private static void testRetryErrorsAreCombined( AccessMode mode )`
`992`	`992`
`993`	`993`	`try`
`994`	`994`	`{`
`995`		`- executeTransaction( session, mode, new Function<Transaction,Integer>()`
	`995`	`+ executeTransaction( session, mode, new TransactionWork<Integer>()`
`996`	`996`	`{`
`997`	`997`	`int invoked;`
`998`	`998`
`999`	`999`	`@Override`
`1000`		`- public Integer apply( Transaction tx )`
	`1000`	`+ public Integer execute( Transaction tx )`
`1001`	`1001`	`{`
`1002`	`1002`	`if ( invoked++ < failures )`
`1003`	`1003`	`{`
`@@ -1035,12 +1035,12 @@ private static void testRetryErrorsAreNotCombinedWhenSameErrorIsThrown( AccessMo`
`1035`	`1035`	`final ServiceUnavailableException error = new ServiceUnavailableException( "Oh!" );`
`1036`	`1036`	`try`
`1037`	`1037`	`{`
`1038`		`- executeTransaction( session, mode, new Function<Transaction,Integer>()`
	`1038`	`+ executeTransaction( session, mode, new TransactionWork<Integer>()`
`1039`	`1039`	`{`
`1040`	`1040`	`int invoked;`
`1041`	`1041`
`1042`	`1042`	`@Override`
`1043`		`- public Integer apply( Transaction tx )`
	`1043`	`+ public Integer execute( Transaction tx )`
`1044`	`1044`	`{`
`1045`	`1045`	`if ( invoked++ < failures )`
`1046`	`1046`	`{`
`@@ -1060,7 +1060,7 @@ public Integer apply( Transaction tx )`
`1060`	`1060`	`}`
`1061`	`1061`	`}`
`1062`	`1062`
`1063`		`- private static <T> T executeTransaction( Session session, AccessMode mode, Function<Transaction,T> work )`
	`1063`	`+ private static <T> T executeTransaction( Session session, AccessMode mode, TransactionWork<T> work )`
`1064`	`1064`	`{`
`1065`	`1065`	`if ( mode == READ )`
`1066`	`1066`	`{`
Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,7 @@`
`44`	`44`	`import org.neo4j.driver.v1.Record;`
`45`	`45`	`import org.neo4j.driver.v1.Session;`
`46`	`46`	`import org.neo4j.driver.v1.Transaction;`
	`47`	`+import org.neo4j.driver.v1.TransactionWork;`
`47`	`48`	`import org.neo4j.driver.v1.exceptions.ServiceUnavailableException;`
`48`	`49`	`import org.neo4j.driver.v1.exceptions.SessionExpiredException;`
`49`	`50`	`import org.neo4j.driver.v1.util.Function;`
`@@ -877,12 +878,12 @@ private static Driver newDriver( String uriString, DriverFactory driverFactory )`
`877`	`878`	`return driverFactory.newInstance( uri, auth, routingConf, RetrySettings.DEFAULT, config );`
`878`	`879`	`}`
`879`	`880`
`880`		`- private static Function<Transaction,List<Record>> queryWork( final String query, final AtomicInteger invocations )`
	`881`	`+ private static TransactionWork<List<Record>> queryWork( final String query, final AtomicInteger invocations )`
`881`	`882`	`{`
`882`		`- return new Function<Transaction,List<Record>>()`
	`883`	`+ return new TransactionWork<List<Record>>()`
`883`	`884`	`{`
`884`	`885`	`@Override`
`885`		`- public List<Record> apply( Transaction tx )`
	`886`	`+ public List<Record> execute( Transaction tx )`
`886`	`887`	`{`
`887`	`888`	`invocations.incrementAndGet();`
`888`	`889`	`return tx.run( query ).list();`