Remove support for trailing add()s

Author: Michael-A-McMahon

src/main/java/oracle/r2dbc/impl/OracleStatementImpl.java

@@ -1092,10 +1092,9 @@ private Publisher<OracleResultImpl> executeGeneratingValues() {
   /**
    * <p>
    * Executes this {@code Statement} as a batch DML command. The returned
-   * {@code Publisher} emits 1 {@code Result} for each set of bind values in
-   * this {@code Statement}'s {@link #batch}. Each {@code Result} has an
-   * update count and no row data. Update counts are floored to a maximum of
-   * {@link Integer#MAX_VALUE}.
+   * {@code Publisher} emits 1 {@code Result} having a
+   * {@link io.r2dbc.spi.Result.UpdateCount} segment for each set of bind
+   * values in the {@link #batch}.
    * </p><p>
    * This method copies any mutable state of this {@code Statement} needed to
    * execute the batch; Any mutations that occur after this method returns will
@@ -1108,14 +1107,14 @@ private Publisher<OracleResultImpl> executeGeneratingValues() {
    * subscriber subscribes, before the subscriber emits a {@code request}
    * signal.
    * </p>
-   * @return {@code Publisher} that the {@code Result}s of executing this
+   * @return {@code Publisher} that emits the {@code Result}s of executing this
    * {@code Statement} as a batch DML command.
    * @throws IllegalStateException If this {@code Statement} has been
    * configured to return generated values with
    * {@link #returnGeneratedValues(String...)}. Oracle JDBC does not support
    * batch execution that returns generated keys.
-   * @throws IllegalStateException If at least one parameter has been set
-   * since the last call to {@link #add()}, but not all parameters have been set
+   * @throws IllegalStateException If not all parameters have been set since the
+   * last call to {@link #add()}
    * @throws IllegalStateException If all parameters have been set since the
    * last call to {@link #add()}, and an out parameter is present. JDBC does
    * not support batch execution with out parameters.
@@ -1127,7 +1126,8 @@ Publisher<OracleResultImpl> executeBatch() {
         "Batch execution with generated values is not supported");
     }
 
-    addImplicit();
+
+    add(); // TODO: Catch and emit IllegalStateException as R2dbcException?
     Queue<Object[]> currentBatch = batch;
     int batchSize = batch.size();
     batch = new LinkedList<>();

src/test/java/oracle/r2dbc/impl/OracleConnectionImplTest.java

@@ -843,7 +843,9 @@ public void testRollbackTransaction() {
           "Hola, Oracle",
           "Namaste, Oracle",
           "Ni hao, Oracle");
-        values.forEach(value -> insert.bind("value", value).add());
+        values.subList(0, values.size() - 1)
+          .forEach(value -> insert.bind("value", value).add());
+        insert.bind("value", values.get(values.size() - 1));
         awaitUpdate(
           values.stream().map(value -> 1).collect(Collectors.toList()),
           insert);
@@ -982,7 +984,7 @@ public void testSetAutoCommit() {
             List.of(1, 1),
             insertInSessionA
               .bind(0, "D").add()
-              .bind(0, "D").add());
+              .bind(0, "D"));
           awaitNone(enableAutoCommitPublisher);
           assertFalse(sessionA.isAutoCommit(),
             "Unexpected value returned by isAutoCommit() after subscribing to"

src/test/java/oracle/r2dbc/impl/OracleResultImplTest.java

@@ -407,7 +407,7 @@ public void testBatchUpdateError() {
       awaitNone(Mono.from(connection.createStatement(
         "INSERT INTO testBatchUpdateError VALUES (?)")
         .bind(0, 0).add()
-        .bind(0, 0).add()
+        .bind(0, 0)
         .execute())
         .flatMapMany(result ->
           result.flatMap(segment -> {

src/test/java/oracle/r2dbc/impl/OracleStatementImplTest.java

@@ -95,7 +95,7 @@ public void testBindByIndex() {
           .bind(0, 0).bind(1, 0).add()
           .bind(0, 1).bind(1, 0).add()
           .bind(0, 1).bind(1, 1).add()
-          .bind(0, 1).bind(1, 2).add());
+          .bind(0, 1).bind(1, 2));
 
       // Expect bind values to be applied in WHERE clause as:
       // SELECT x, y FROM testBindByIndex WHERE x = 1 AND y > 0
@@ -217,7 +217,7 @@ public void testBindByName() {
           .bind("X", 0).bind("Y", 0).add()
           .bind("X", 1).bind("Y", 0).add()
           .bind("X", 1).bind("Y", 1).add()
-          .bind("X", 1).bind("Y", 2).add());
+          .bind("X", 1).bind("Y", 2));
 
       // Expect bind values to be applied in WHERE clause as:
       // SELECT x, y FROM testBindByName WHERE x = 1 AND y > 0
@@ -430,7 +430,7 @@ public void testBindNullByIndex() {
           .bindNull(0, Integer.class).bind(1, 1).add()
           .bindNull(0, Integer.class).bind(1, 2).add()
           .bind(0, 0).bind(1, 3).add()
-          .bind(0, 0).bindNull(1, Integer.class).add());
+          .bind(0, 0).bindNull(1, Integer.class));
       awaitQuery(
         asList(
           asList(null, 0),
@@ -574,7 +574,7 @@ public void testBindNullByName() {
           .bindNull("x", Integer.class).bind("y", 1).add()
           .bindNull("x", Integer.class).bind("y", 2).add()
           .bind("x", 0).bind("y", 3).add()
-          .bind("x", 0).bindNull("y", Integer.class).add());
+          .bind("x", 0).bindNull("y", Integer.class));
       awaitQuery(
         asList(
           asList(null, 0),
@@ -725,7 +725,7 @@ public void testAdd() {
       awaitUpdate(
         asList(1, 1, 1),
         connection.createStatement("INSERT INTO testAdd VALUES(0, 0)")
-          .add().add().add());
+          .add().add());
       awaitQuery(
         asList(asList(0, 0), asList(0, 0), asList(0, 0)),
         row -> asList(row.get(0, Integer.class), row.get(1, Integer.class)),
@@ -737,7 +737,7 @@ public void testAdd() {
         connection.createStatement("INSERT INTO testAdd VALUES(:x, :y)")
           .bind("x", 1).bind("y", 1).add()
           .bind("x", 1).bind("y", 2).add()
-          .bind("x", 1).bind("y", 3).add());
+          .bind("x", 1).bind("y", 3));
       awaitQuery(
         asList(asList(1, 1), asList(1, 2), asList(1, 3)),
         row -> asList(row.get(0, Integer.class), row.get(1, Integer.class)),
@@ -768,7 +768,7 @@ public void testAdd() {
         Mono.from(connection.createStatement("SELECT ? FROM dual")
           .bind(0, 1).add()
           .bind(0, 2).add()
-          .bind(0, 3).add()
+          .bind(0, 3)
           .execute())
           .flatMapMany(Result::getRowsUpdated));
 
@@ -860,7 +860,7 @@ public void testExecute() {
         asList(1, 1),
         updateStatement
           .bind("oldValue", 1).bind("newValue", 2).add()
-          .bind("oldValue", 0).bind("newValue", 1).add());
+          .bind("oldValue", 0).bind("newValue", 1));
 
       // Expect bind values to be cleared after execute with explicit add()
       assertThrows(IllegalStateException.class, updateStatement::execute);
@@ -1757,8 +1757,9 @@ public void testNoOutImplicitResult() {
       // Load [0,100] into the table
       Statement insert = connection.createStatement(
         "INSERT INTO testNoOutImplicitResult VALUES (?)");
-      IntStream.rangeClosed(0, 100)
+      IntStream.range(0, 100)
         .forEach(i -> insert.bind(0, i).add());
+      insert.bind(0, 100);
       awaitOne(101, Flux.from(insert.execute())
         .flatMap(Result::getRowsUpdated)
         .reduce(0, (total, updateCount) -> total + updateCount));
@@ -1867,8 +1868,9 @@ public void testOutAndImplicitResult() {
       // Load [0,100] into the table
       Statement insert = connection.createStatement(
         "INSERT INTO testOutAndImplicitResult VALUES (?)");
-      IntStream.rangeClosed(0, 100)
+      IntStream.range(0, 100)
         .forEach(i -> insert.bind(0, i).add());
+      insert.bind(0, 100);
       awaitOne(101, Flux.from(insert.execute())
         .flatMap(Result::getRowsUpdated)
         .reduce(0, (total, updateCount) -> total + updateCount));

src/test/java/oracle/r2dbc/impl/TypeMappingTest.java

@@ -543,7 +543,7 @@ private static <T, U> void verifyTypeMapping(
       awaitUpdate(asList(1,1), connection.createStatement(
         "INSERT INTO "+table+"(javaValue) VALUES(:javaValue)")
         .bind("javaValue", javaValue).add()
-        .bindNull("javaValue", javaValue.getClass()).add());
+        .bindNull("javaValue", javaValue.getClass()));
 
       verifyEquals.accept(javaValue,
         awaitOne(Flux.from(connection.createStatement(

src/test/java/oracle/r2dbc/test/OracleTestKit.java

@@ -28,6 +28,7 @@
 import io.r2dbc.spi.ConnectionFactories;
 import io.r2dbc.spi.ConnectionFactory;
 import io.r2dbc.spi.ConnectionFactoryOptions;
+import io.r2dbc.spi.R2dbcNonTransientException;
 import io.r2dbc.spi.Result;
 import io.r2dbc.spi.Row;
 import io.r2dbc.spi.Statement;
@@ -269,7 +270,7 @@ public void duplicateColumnNames() {
    * segments from a single {@code Result}. The default implementation expects
    * 10 {@code Result}s each with a single {@code UpdateCount}. Batch DML
    * execution is a single call to Oracle Database, and so Oracle R2DBC
-   * returns a signle {@code Result}
+   * returns a single {@code Result}
    * </p>
    */
   @Override
@@ -280,8 +281,17 @@ public void prepareStatement() {
         Statement statement = connection.createStatement(expand(TestStatement.INSERT_VALUE_PLACEHOLDER, getPlaceholder(0)));
 
         IntStream.range(0, 10)
-          .forEach(i -> TestKit.bind(statement, getIdentifier(0), i).add());
+          .forEach(i -> {
+            TestKit.bind(statement, getIdentifier(0), i);
 
+            if (i != 9) {
+              statement.add();
+            }
+          });
+
+        // The original TestKit implementation is modified below to call
+        // Result.getRowsUpdated(), which returns a Publisher of 10
+        // UpdateCount segments.
         return Flux.from(statement
           .execute())
           .flatMap(Result::getRowsUpdated);