#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);
+  }
+
+}

src/test/java/com/avaje/tests/transaction/TestExplicitTransactionMode.java

@@ -0,0 +1,98 @@
+package com.avaje.tests.transaction;
+
+import com.avaje.ebean.BaseTestCase;
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.EbeanServerFactory;
+import com.avaje.ebean.Query;
+import com.avaje.ebean.Transaction;
+import com.avaje.ebean.config.DataSourceConfig;
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebeaninternal.server.lib.sql.DataSourcePool;
+import com.avaje.tests.model.basic.UTDetail;
+import com.avaje.tests.model.basic.UTMaster;
+import org.junit.Test;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class TestExplicitTransactionMode extends BaseTestCase {
+
+  @Test
+  public void test() throws SQLException {
+
+    DataSourceConfig dsConfig = new DataSourceConfig();
+    dsConfig.loadSettings("h2autocommit");//"h2autocommit","pg"
+    dsConfig.setAutoCommit(true);
+
+    DataSourcePool pool = new DataSourcePool(null, "h2autocommit", dsConfig);
+
+    Connection connection = pool.getConnection();
+    assertTrue(connection.getAutoCommit());
+    connection.close();
+
+    ServerConfig config = new ServerConfig();
+    config.setName("h2autocommit");
+    config.loadFromProperties();
+    config.setDataSource(pool);
+    config.setDefaultServer(false);
+    config.setRegister(false);
+    config.setExplicitTransactionBeginMode(true);
+
+    config.addClass(UTMaster.class);
+    config.addClass(UTDetail.class);
+    config.setDdlGenerate(true);
+    config.setDdlRun(true);
+
+    EbeanServer ebeanServer = EbeanServerFactory.create(config);
+
+    Query<UTMaster> query = ebeanServer.find(UTMaster.class);
+    List<UTMaster> details = ebeanServer.findList(query, null);
+    assertEquals(0, details.size());
+
+    UTMaster bean0 = new UTMaster("one0");
+    Transaction txn0 = ebeanServer.beginTransaction();
+    try {
+      ebeanServer.save(bean0);
+      txn0.rollback();
+    } finally {
+      txn0.end();
+    }
+
+    // rollback as expected
+    assertEquals(0, ebeanServer.find(UTMaster.class).findRowCount());
+
+    UTMaster bean1 = new UTMaster("one1");
+    UTMaster bean2 = new UTMaster("two2");
+    UTMaster bean3 = new UTMaster("three3");
+
+    // use a different transaction to do final query check
+    Transaction otherTxn = ebeanServer.createTransaction();
+    Transaction txn = ebeanServer.beginTransaction();
+
+    try {
+      ebeanServer.save(bean1);
+      ebeanServer.save(bean2);
+
+      // not visible in other transaction
+      Query<UTMaster> query2 = ebeanServer.find(UTMaster.class);
+      details = ebeanServer.findList(query2, otherTxn);
+      assertEquals(0, details.size());
+
+      ebeanServer.save(bean3);
+
+      txn.commit();
+
+    } finally {
+      txn.end();
+    }
+
+    // commit as expected
+    Query<UTMaster> query3 = ebeanServer.find(UTMaster.class);
+    details = ebeanServer.findList(query3, otherTxn);
+    assertEquals(3, details.size());
+  }
+}