#415 - ENH: Add ExplicitJdbcTransaction ... so like AutoCommitJdbcTransaction but using explicit statements to commit and rollback

src/main/java/com/avaje/ebean/config/ServerConfig.java

@@ -234,7 +234,12 @@ public class ServerConfig {
    * Indicates that Ebean should use autoCommit friendly Transactions and TransactionManager.
    */
   private boolean autoCommitMode;
-  
+
+  /**
+   * Set to true if transaction begin should be started with explicit statement.
+   */
+  private boolean explicitTransactionBeginMode;
+
   /** 
    * The data source JNDI name if using a JNDI DataSource. 
    */
@@ -1220,6 +1225,28 @@ public class ServerConfig {
     this.autoCommitMode = autoCommitMode;
   }
 
+  /**
+   * Return true if transaction begin should be started with explicit statement.
+   */
+  public boolean isExplicitTransactionBeginMode() {
+    return explicitTransactionBeginMode;
+  }
+
+  /**
+   * Set to true if transaction begin should be started with explicit statement.
+   * <p>
+   * This works for H2 and Postgres but not for Oracle - only use this if you first name
+   * is Daryl or you have explicitly talked to Rob about this feature.
+   * </p>
+   * <p>
+   * This is generally not expected to be turned on but instead allow transactions to start
+   * implicitly which is generally the standard approach.
+   * </p>
+   */
+  public void setExplicitTransactionBeginMode(boolean explicitTransactionBeginMode) {
+    this.explicitTransactionBeginMode = explicitTransactionBeginMode;
+  }
+
   /**
    * Return a value used to represent TRUE in the database.
    * <p>
@@ -2067,6 +2094,7 @@ public class ServerConfig {
     }
     loadDataSourceSettings(p);
 
+    explicitTransactionBeginMode = p.getBoolean("explicitTransactionBeginMode", explicitTransactionBeginMode);
     autoCommitMode = p.getBoolean("autoCommitMode", autoCommitMode);
     useJtaTransactionManager = p.getBoolean("useJtaTransactionManager", useJtaTransactionManager);
 

src/main/java/com/avaje/ebeaninternal/server/core/InternalConfiguration.java

@@ -39,6 +39,7 @@ import com.avaje.ebeaninternal.server.readaudit.DefaultReadAuditPrepare;
 import com.avaje.ebeaninternal.server.text.json.DJsonContext;
 import com.avaje.ebeaninternal.server.transaction.AutoCommitTransactionManager;
 import com.avaje.ebeaninternal.server.transaction.DefaultTransactionScopeManager;
+import com.avaje.ebeaninternal.server.transaction.ExplicitTransactionManager;
 import com.avaje.ebeaninternal.server.transaction.ExternalTransactionScopeManager;
 import com.avaje.ebeaninternal.server.transaction.JtaTransactionManager;
 import com.avaje.ebeaninternal.server.transaction.TransactionManager;
@@ -220,6 +221,10 @@ public class InternalConfiguration {
    */
   private TransactionManager createTransactionManager() {
 
+    if (serverConfig.isExplicitTransactionBeginMode()) {
+      return new ExplicitTransactionManager(clusterManager, backgroundExecutor, serverConfig, beanDescriptorManager, this.getBootupClasses());
+    }
+
     if (isAutoCommitMode()) {
       return new AutoCommitTransactionManager(clusterManager, backgroundExecutor, serverConfig, beanDescriptorManager, this.getBootupClasses());
     }

src/main/java/com/avaje/ebeaninternal/server/transaction/ExplicitJdbcTransaction.java

@@ -0,0 +1,45 @@
+package com.avaje.ebeaninternal.server.transaction;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+/**
+ * This only works for Postgres and H2 (and doesn't work for Oracle).
+ *
+ * Uses explicit begin statement to start the transactions.
+ */
+public class ExplicitJdbcTransaction extends JdbcTransaction {
+
+  public ExplicitJdbcTransaction(String id, boolean explicit, Connection connection, TransactionManager manager) {
+    super(id, explicit, connection, manager);
+  }
+
+  @Override
+  protected void checkAutoCommit(Connection connection) throws SQLException {
+    // begin the transaction explicitly
+    executeStatement("begin");
+  }
+
+  @Override
+  protected void performRollback() throws SQLException {
+    // Postgres needs this explicit rollback statement when used with AutoCommit=true
+    executeStatement("rollback");
+  }
+
+  @Override
+  protected void performCommit() throws SQLException {
+    // Postgres needs this explicit commit statement when used with AutoCommit=true
+    executeStatement("commit");
+  }
+
+  private void executeStatement(String statement) throws SQLException {
+    PreparedStatement stmt = connection.prepareStatement(statement);
+    try {
+      stmt.execute();
+    } finally {
+      stmt.close();
+    }
+  }
+
+}

src/main/java/com/avaje/ebeaninternal/server/transaction/ExplicitTransactionManager.java

@@ -0,0 +1,32 @@
+package com.avaje.ebeaninternal.server.transaction;
+
+import com.avaje.ebean.BackgroundExecutor;
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebeaninternal.api.SpiTransaction;
+import com.avaje.ebeaninternal.server.cluster.ClusterManager;
+import com.avaje.ebeaninternal.server.core.BootupClasses;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptorManager;
+
+import java.sql.Connection;
+
+/**
+ * TransactionManager where the transactions start with explicit "begin" statement.
+ */
+public class ExplicitTransactionManager extends TransactionManager {
+
+  public ExplicitTransactionManager(ClusterManager clusterManager, BackgroundExecutor backgroundExecutor,
+                                    ServerConfig config, BeanDescriptorManager descMgr, BootupClasses bootupClasses) {
+
+    super(clusterManager, backgroundExecutor, config, descMgr, bootupClasses);
+  }
+
+  /**
+   * Create a ExplicitJdbcTransaction.
+   */
+  @Override
+  protected SpiTransaction createTransaction(boolean explicit, Connection c, long id) {
+
+    return new ExplicitJdbcTransaction(prefix + id, explicit, c, this);
+  }
+
+}