#864

Author: babyfish-ct

project/jimmer-sql/src/main/java/org/babyfish/jimmer/sql/ast/impl/mutation/AbstractAssociationOperator.java

@@ -9,10 +9,7 @@
 import org.babyfish.jimmer.sql.runtime.*;
 import org.jetbrains.annotations.Nullable;
 
-import java.sql.BatchUpdateException;
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.SQLException;
+import java.sql.*;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -106,9 +103,24 @@ int[] executeImpl(
                                 variables,
                                 sqlTuple.get_3(),
                                 ExecutionPurpose.MUTATE,
-                                null,
+                                (ex, args) -> {
+                                    if (ex instanceof SQLException) {
+                                        return exceptionTranslator.apply((SQLException) ex, null);
+                                    }
+                                    return ex;
+                                },
                                 Connection::prepareStatement,
-                                (stmt, args) -> stmt.executeUpdate()
+                                (stmt, args) -> {
+                                    Savepoint savepoint = SavepointManager.setIfNeeded(args.con, sqlClient);
+                                    try {
+                                        return stmt.executeUpdate();
+                                    } catch (SQLException ex) {
+                                        SavepointManager.rollback(stmt::getConnection, savepoint);
+                                        throw ex;
+                                    } finally {
+                                        SavepointManager.release(stmt::getConnection, savepoint);
+                                    }
+                                }
                         )
                 );
             }

project/jimmer-sql/src/main/java/org/babyfish/jimmer/sql/ast/impl/mutation/MiddleTableOperator.java

@@ -29,6 +29,8 @@ class MiddleTableOperator extends AbstractAssociationOperator {
 
     private static final int[] EMPTY_ROW_COUNTS = new int[0];
 
+    private static final int[] SINGLE_ERROR_ROW_COUNTS = new int[] {-1};
+
     private final MutationPath path;
 
     private final ExceptionTranslator<Exception> exceptionTranslator;
@@ -996,21 +998,26 @@ private Exception translateConnectException(
             Collection<Tuple2<Object, Object>> idTuples
     ) {
         String state = ex.getSQLState();
-        if (state == null || !state.startsWith("23") || !(ex instanceof BatchUpdateException)) {
+        if (state == null || !state.startsWith("23")) {
             return convertFinalException(ex, ctx);
         }
-        BatchUpdateException bue = (BatchUpdateException) ex;
+        int[] affectedRowCounts;
+        if (ex instanceof BatchUpdateException) {
+            affectedRowCounts = ((BatchUpdateException)ex).getUpdateCounts();
+        } else {
+            affectedRowCounts = SINGLE_ERROR_ROW_COUNTS;
+        }
         MiddleTableInvestigator investigator = new MiddleTableInvestigator(
-                bue,
-                bue.getUpdateCounts(),
+                ex,
+                affectedRowCounts,
                 Investigators.toInvestigatorSqlClient(sqlClient, ctx),
                 con,
                 path,
                 idTuples
         );
         Exception investigatedException = investigator.investigate();
         if (investigatedException == null) {
-            investigatedException = bue;
+            investigatedException = ex;
         }
         return convertFinalException(investigatedException, ctx);
     }

project/jimmer-sql/src/main/java/org/babyfish/jimmer/sql/runtime/DefaultExecutor.java

@@ -46,6 +46,7 @@ private static void setParameters(
         }
     }
 
+    @SuppressWarnings("unchecked")
     @Override
     public <R> R execute(@NotNull Args<R> args) {
         String sql = args.sql;
@@ -59,19 +60,22 @@ public <R> R execute(@NotNull Args<R> args) {
             return args.block.apply(stmt, args);
         } catch (Exception ex) {
             ExceptionTranslator<Exception> exceptionTranslator =
-                    args.sqlClient().getExceptionTranslator();
-            if (exceptionTranslator != null) {
-                ex = exceptionTranslator.translate(ex, args);
+                    (ExceptionTranslator<Exception>) args.getExceptionTranslator();
+            Exception translatedException;
+            if (exceptionTranslator == null) {
+                translatedException = ex;
+            } else {
+                translatedException = exceptionTranslator.translate(ex, args);
             }
-            if (ex instanceof RuntimeException) {
-                throw (RuntimeException) ex;
+            if (translatedException instanceof RuntimeException) {
+                throw (RuntimeException) translatedException;
             }
             throw new ExecutionException(
                     "Cannot execute SQL statement: " +
                     sql +
                     ", variables: " +
                     variables,
-                    ex
+                    translatedException
             );
         }
     }