diff options
Diffstat (limited to 'src')
9 files changed, 297 insertions, 95 deletions
diff --git a/src/main/java/com/amazon/carbonado/gen/MasterStorableGenerator.java b/src/main/java/com/amazon/carbonado/gen/MasterStorableGenerator.java index b9da366..d8d2901 100644 --- a/src/main/java/com/amazon/carbonado/gen/MasterStorableGenerator.java +++ b/src/main/java/com/amazon/carbonado/gen/MasterStorableGenerator.java @@ -36,6 +36,7 @@ import org.cojen.util.KeyFactory; import org.cojen.util.SoftValuedHashMap;
import com.amazon.carbonado.ConstraintException;
+import com.amazon.carbonado.IsolationLevel;
import com.amazon.carbonado.OptimisticLockException;
import com.amazon.carbonado.PersistException;
import com.amazon.carbonado.Repository;
@@ -795,7 +796,7 @@ public final class MasterStorableGenerator<S extends Storable> { }
/**
- * Generates code to enter a transaction, if required.
+ * Generates code to enter a transaction, if required and if none in progress.
*
* @param opType type of operation, Insert, Update, or Delete
* @param txnVar required variable of type Transaction for storing transaction
@@ -806,26 +807,59 @@ public final class MasterStorableGenerator<S extends Storable> { return null;
}
- // txn = masterSupport.getRootRepository().enterTransaction();
+ // Repository repo = masterSupport.getRootRepository();
TypeDesc repositoryType = TypeDesc.forClass(Repository.class);
TypeDesc transactionType = TypeDesc.forClass(Transaction.class);
TypeDesc triggerSupportType = TypeDesc.forClass(TriggerSupport.class);
TypeDesc masterSupportType = TypeDesc.forClass(MasterSupport.class);
+ TypeDesc isolationLevelType = TypeDesc.forClass(IsolationLevel.class);
b.loadThis();
b.loadField(StorableGenerator.SUPPORT_FIELD_NAME, triggerSupportType);
b.invokeInterface(masterSupportType, "getRootRepository",
repositoryType, null);
- b.invokeInterface(repositoryType, ENTER_TRANSACTION_METHOD_NAME,
- transactionType, null);
- b.storeLocal(txnVar);
+
if (requiresTxnForUpdate(opType)) {
+ // Always create nested transaction.
+
+ // txn = repo.enterTransaction();
// txn.setForUpdate(true);
+
+ b.invokeInterface(repositoryType, ENTER_TRANSACTION_METHOD_NAME,
+ transactionType, null);
+ b.storeLocal(txnVar);
b.loadLocal(txnVar);
b.loadConstant(true);
b.invokeInterface(transactionType, SET_FOR_UPDATE_METHOD_NAME, null,
new TypeDesc[] {TypeDesc.BOOLEAN});
+ } else {
+ LocalVariable repoVar = b.createLocalVariable(null, repositoryType);
+ b.storeLocal(repoVar);
+
+ // if (repo.getTransactionIsolationLevel() != null) {
+ // txn = null;
+ // } else {
+ // txn = repo.enterTransaction();
+ // }
+
+ b.loadLocal(repoVar);
+ b.invokeInterface(repositoryType, GET_TRANSACTION_ISOLATION_LEVEL_METHOD_NAME,
+ isolationLevelType, null);
+ Label notInTxn = b.createLabel();
+ b.ifNullBranch(notInTxn, true);
+
+ b.loadNull();
+ Label storeTxn = b.createLabel();
+ b.branch(storeTxn);
+
+ notInTxn.setLocation();
+ b.loadLocal(repoVar);
+ b.invokeInterface(repositoryType, ENTER_TRANSACTION_METHOD_NAME,
+ transactionType, null);
+
+ storeTxn.setLocation();
+ b.storeLocal(txnVar);
}
return b.createLabel().setLocation();
@@ -879,12 +913,24 @@ public final class MasterStorableGenerator<S extends Storable> { TypeDesc transactionType = TypeDesc.forClass(Transaction.class);
+ Label noTxn = b.createLabel();
+
+ if (!requiresTxnForUpdate(opType)) {
+ // Might be null, if transaction was already in progress. If
+ // requires transaction for update, then a new transaction is
+ // always created.
+ b.loadLocal(txnVar);
+ b.ifNullBranch(noTxn, true);
+ }
+
// txn.commit();
// txn.exit();
b.loadLocal(txnVar);
b.invokeInterface(transactionType, COMMIT_METHOD_NAME, null, null);
b.loadLocal(txnVar);
b.invokeInterface(transactionType, EXIT_METHOD_NAME, null, null);
+
+ noTxn.setLocation();
}
/**
@@ -898,9 +944,21 @@ public final class MasterStorableGenerator<S extends Storable> { TypeDesc transactionType = TypeDesc.forClass(Transaction.class);
+ Label noTxn = b.createLabel();
+
+ if (!requiresTxnForUpdate(opType)) {
+ // Might be null, if transaction was already in progress. If
+ // requires transaction for update, then a new transaction is
+ // always created.
+ b.loadLocal(txnVar);
+ b.ifNullBranch(noTxn, true);
+ }
+
// txn.exit();
b.loadLocal(txnVar);
b.invokeInterface(transactionType, EXIT_METHOD_NAME, null, null);
+
+ noTxn.setLocation();
}
/**
diff --git a/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCRepository.java b/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCRepository.java index 9e54694..0d93570 100644 --- a/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCRepository.java +++ b/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCRepository.java @@ -176,6 +176,9 @@ public class JDBCRepository extends AbstractRepository<JDBCTransaction> // Maps Storable types which should have automatic version management.
private Map<String, Boolean> mAutoVersioningMap;
+ // Maps Storable types which should not auto reload after insert or update.
+ private Map<String, Boolean> mSuppressReloadMap;
+
// Track all open connections so that they can be closed when this
// repository is closed.
private Map<Connection, Object> mOpenConnections;
@@ -217,6 +220,7 @@ public class JDBCRepository extends AbstractRepository<JDBCTransaction> String catalog, String schema,
Integer fetchSize,
Map<String, Boolean> autoVersioningMap,
+ Map<String, Boolean> suppressReloadMap,
String sequenceSelectStatement, boolean forceStoredSequence)
throws RepositoryException
{
@@ -234,6 +238,7 @@ public class JDBCRepository extends AbstractRepository<JDBCTransaction> mFetchSize = fetchSize;
mAutoVersioningMap = autoVersioningMap;
+ mSuppressReloadMap = suppressReloadMap;
mOpenConnections = new IdentityHashMap<Connection, Object>();
mOpenConnectionsLock = new ReentrantLock(true);
@@ -291,7 +296,11 @@ public class JDBCRepository extends AbstractRepository<JDBCTransaction> } catch (SQLException e) {
throw toRepositoryException(e);
} finally {
- forceYieldConnection(con);
+ try {
+ closeConnection(con);
+ } catch (SQLException e) {
+ // Don't care.
+ }
}
mSupportStrategy = JDBCSupportStrategy.createStrategy(this);
@@ -483,34 +492,16 @@ public class JDBCRepository extends AbstractRepository<JDBCTransaction> public void yieldConnection(Connection con) throws FetchException {
try {
if (con.getAutoCommit()) {
- mOpenConnectionsLock.lock();
- try {
- if (mOpenConnections != null) {
- mOpenConnections.remove(con);
- }
- } finally {
- mOpenConnectionsLock.unlock();
- }
- // Close connection outside lock section since it may block.
- if (con.getTransactionIsolation() != mJdbcDefaultIsolationLevel) {
- con.setTransactionIsolation(mJdbcDefaultIsolationLevel);
- }
- con.close();
+ closeConnection(con);
}
-
- // Connections which aren't auto-commit are in a transaction.
- // When transaction is finished, JDBCTransactionManager switches
- // connection back to auto-commit and calls yieldConnection.
+ // Connections which aren't auto-commit are in a transaction. Keep
+ // them around instead of closing them.
} catch (Exception e) {
throw toFetchException(e);
}
}
- /**
- * Yields connection without attempting to restore isolation level. Ignores
- * any exceptions too.
- */
- private void forceYieldConnection(Connection con) {
+ void closeConnection(Connection con) throws SQLException {
mOpenConnectionsLock.lock();
try {
if (mOpenConnections != null) {
@@ -520,11 +511,7 @@ public class JDBCRepository extends AbstractRepository<JDBCTransaction> mOpenConnectionsLock.unlock();
}
// Close connection outside lock section since it may block.
- try {
- con.close();
- } catch (SQLException e) {
- // Don't care.
- }
+ con.close();
}
boolean supportsSavepoints() {
@@ -693,7 +680,19 @@ public class JDBCRepository extends AbstractRepository<JDBCTransaction> }
}
- return new JDBCStorage<S>(this, info, autoVersioning);
+ Boolean suppressReload = false;
+ if (mSuppressReloadMap != null) {
+ suppressReload = mSuppressReloadMap.get(type.getName());
+ if (suppressReload == null) {
+ // No explicit setting, so check wildcard setting.
+ suppressReload = mSuppressReloadMap.get(null);
+ if (suppressReload == null) {
+ suppressReload = false;
+ }
+ }
+ }
+
+ return new JDBCStorage<S>(this, info, autoVersioning, suppressReload);
}
protected SequenceValueProducer createSequenceValueProducer(String name)
diff --git a/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCRepositoryBuilder.java b/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCRepositoryBuilder.java index 12e21cc..1fbe2dd 100644 --- a/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCRepositoryBuilder.java +++ b/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCRepositoryBuilder.java @@ -72,6 +72,7 @@ public class JDBCRepositoryBuilder extends AbstractRepositoryBuilder { private String mPassword;
private Integer mFetchSize;
private Map<String, Boolean> mAutoVersioningMap;
+ private Map<String, Boolean> mSuppressReloadMap;
private String mSequenceSelectStatement;
private boolean mForceStoredSequence;
@@ -86,6 +87,7 @@ public class JDBCRepositoryBuilder extends AbstractRepositoryBuilder { mCatalog, mSchema,
mFetchSize,
getAutoVersioningMap(),
+ getSuppressReloadMap(),
mSequenceSelectStatement, mForceStoredSequence);
rootRef.set(repo);
return repo;
@@ -321,6 +323,35 @@ public class JDBCRepositoryBuilder extends AbstractRepositoryBuilder { }
/**
+ * By default, JDBCRepository reloads Storables after every insert or
+ * update. This ensures that any applied defaults or triggered changes are
+ * available to the Storable. If the database has no such defaults or
+ * triggers, suppressing reload can improve performance.
+ *
+ * <p>Note: If Storable has a version property and auto versioning is not
+ * enabled, or if the Storable has any automatic properties, the Storable
+ * might still be reloaded.
+ *
+ * @param suppress true to suppress, false to unsuppress
+ * @param className name of Storable type to suppress reload for; pass null
+ * to suppress all
+ * @since 1.1.3
+ */
+ public void setSuppressReload(boolean suppress, String className) {
+ if (mSuppressReloadMap == null) {
+ mSuppressReloadMap = new HashMap<String, Boolean>();
+ }
+ mSuppressReloadMap.put(className, suppress);
+ }
+
+ private Map<String, Boolean> getSuppressReloadMap() {
+ if (mSuppressReloadMap == null) {
+ return null;
+ }
+ return new HashMap<String, Boolean>(mSuppressReloadMap);
+ }
+
+ /**
* Returns the native sequence select statement, which is null if the
* default is chosen.
*
diff --git a/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCStorableGenerator.java b/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCStorableGenerator.java index ad568d8..d136206 100644 --- a/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCStorableGenerator.java +++ b/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCStorableGenerator.java @@ -90,18 +90,19 @@ class JDBCStorableGenerator<S extends Storable> { }
static <S extends Storable> Class<? extends S> getGeneratedClass(JDBCStorableInfo<S> info,
- boolean autoVersioning)
+ boolean autoVersioning,
+ boolean suppressReload)
throws SupportException
{
- Object key = KeyFactory.createKey(new Object[] {info, autoVersioning});
+ Object key = KeyFactory.createKey(new Object[] {info, autoVersioning, suppressReload});
synchronized (cCache) {
Class<? extends S> generatedClass = (Class<? extends S>) cCache.get(key);
if (generatedClass != null) {
return generatedClass;
}
- generatedClass =
- new JDBCStorableGenerator<S>(info, autoVersioning).generateAndInjectClass();
+ generatedClass = new JDBCStorableGenerator<S>(info, autoVersioning, suppressReload)
+ .generateAndInjectClass();
cCache.put(key, generatedClass);
return generatedClass;
}
@@ -110,13 +111,15 @@ class JDBCStorableGenerator<S extends Storable> { private final Class<S> mStorableType;
private final JDBCStorableInfo<S> mInfo;
private final boolean mAutoVersioning;
+ private final boolean mSuppressReload;
private final Map<String, ? extends JDBCStorableProperty<S>> mAllProperties;
private final ClassLoader mParentClassLoader;
private final ClassInjector mClassInjector;
private final ClassFile mClassFile;
- private JDBCStorableGenerator(JDBCStorableInfo<S> info, boolean autoVersioning)
+ private JDBCStorableGenerator(JDBCStorableInfo<S> info,
+ boolean autoVersioning, boolean suppressReload)
throws SupportException
{
mStorableType = info.getStorableType();
@@ -130,6 +133,35 @@ class JDBCStorableGenerator<S extends Storable> { MasterFeature.INSERT_TXN, // Required because of reload after insert.
MasterFeature.UPDATE_TXN); // Required because of reload after update.
+ if (suppressReload) {
+ // No need to be in a transaction if reload never happens.
+ honorSuppression: {
+ Map<String, JDBCStorableProperty<S>> identityProperties =
+ info.getIdentityProperties();
+
+ for (JDBCStorableProperty<S> prop : mAllProperties.values()) {
+ if (prop.isAutomatic() && !identityProperties.containsKey(prop.getName())) {
+ // Might still need to reload. This could be determined
+ // dynamically, but this is an optimization that be
+ // implemented later.
+ // TODO: leave suppressReload alone and perform dynamic check
+ suppressReload = false;
+ break honorSuppression;
+ }
+ if (prop.isVersion() && !mAutoVersioning) {
+ // Always need to reload for version.
+ suppressReload = false;
+ break honorSuppression;
+ }
+ }
+
+ features.remove(MasterFeature.INSERT_TXN);
+ features.remove(MasterFeature.UPDATE_TXN);
+ }
+ }
+
+ mSuppressReload = suppressReload;
+
final Class<? extends S> abstractClass =
MasterStorableGenerator.getAbstractClass(mStorableType, features);
@@ -711,23 +743,25 @@ class JDBCStorableGenerator<S extends Storable> { closeStatement(b, psVar, tryAfterPs);
- // Immediately reload object, to ensure that any database supplied
- // default values are properly retrieved. Since INSERT_TXN is
- // enabled, superclass ensures that transaction is still in
- // progress at this point.
+ if (!mSuppressReload) {
+ // Immediately reload object, to ensure that any database supplied
+ // default values are properly retrieved. Since INSERT_TXN is
+ // enabled, superclass ensures that transaction is still in
+ // progress at this point.
- b.loadThis();
- b.loadLocal(repoVar);
- b.loadLocal(conVar);
- if (lobArrayVar == null) {
- b.loadNull();
- } else {
- b.loadLocal(lobArrayVar);
+ b.loadThis();
+ b.loadLocal(repoVar);
+ b.loadLocal(conVar);
+ if (lobArrayVar == null) {
+ b.loadNull();
+ } else {
+ b.loadLocal(lobArrayVar);
+ }
+ b.invokeVirtual(MasterStorableGenerator.DO_TRY_LOAD_MASTER_METHOD_NAME,
+ TypeDesc.BOOLEAN,
+ new TypeDesc[] {jdbcRepoType, connectionType, lobArrayType});
+ b.pop();
}
- b.invokeVirtual(MasterStorableGenerator.DO_TRY_LOAD_MASTER_METHOD_NAME,
- TypeDesc.BOOLEAN,
- new TypeDesc[] {jdbcRepoType, connectionType, lobArrayType});
- b.pop();
// Note: yieldConAndHandleException is not called, allowing any
// SQLException to be thrown. The insert or tryInsert methods must handle it.
@@ -787,8 +821,8 @@ class JDBCStorableGenerator<S extends Storable> { propNumber++;
if (property.isSelectable() && !property.isPrimaryKeyMember()) {
- // Assume database trigger manages version.
if (property.isVersion() && !mAutoVersioning) {
+ // Assume database trigger manages version.
continue;
}
@@ -938,8 +972,8 @@ class JDBCStorableGenerator<S extends Storable> { propNumber++;
if (property.isSelectable() && !property.isPrimaryKeyMember()) {
- // Assume database trigger manages version.
if (property.isVersion() && !mAutoVersioning) {
+ // Assume database trigger manages version.
continue;
}
@@ -1061,26 +1095,28 @@ class JDBCStorableGenerator<S extends Storable> { }
}
- // Immediately reload object, to ensure that any database supplied
- // default values are properly retrieved. Since UPDATE_TXN is
- // enabled, superclass ensures that transaction is still in
- // progress at this point.
-
doReload.setLocation();
- b.loadThis();
- b.loadLocal(repoVar);
- b.loadLocal(conVar);
- if (lobArrayVar == null) {
- b.loadNull();
- } else {
- b.loadLocal(lobArrayVar);
+ if (!mSuppressReload) {
+ // Immediately reload object, to ensure that any database supplied
+ // default values are properly retrieved. Since UPDATE_TXN is
+ // enabled, superclass ensures that transaction is still in
+ // progress at this point.
+
+ b.loadThis();
+ b.loadLocal(repoVar);
+ b.loadLocal(conVar);
+ if (lobArrayVar == null) {
+ b.loadNull();
+ } else {
+ b.loadLocal(lobArrayVar);
+ }
+ b.invokeVirtual(MasterStorableGenerator.DO_TRY_LOAD_MASTER_METHOD_NAME,
+ TypeDesc.BOOLEAN,
+ new TypeDesc[] {jdbcRepoType, connectionType, lobArrayType});
+ // Even though a boolean is returned, the actual value for true and
+ // false is an int, 1 or 0.
+ b.storeLocal(updateCount);
}
- b.invokeVirtual(MasterStorableGenerator.DO_TRY_LOAD_MASTER_METHOD_NAME,
- TypeDesc.BOOLEAN,
- new TypeDesc[] {jdbcRepoType, connectionType, lobArrayType});
- // Even though a boolean is returned, the actual value for true and
- // false is an int, 1 or 0.
- b.storeLocal(updateCount);
skipReload.setLocation();
diff --git a/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCStorage.java b/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCStorage.java index 2a1212a..393986e 100644 --- a/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCStorage.java +++ b/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCStorage.java @@ -90,7 +90,8 @@ class JDBCStorage<S extends Storable> extends StandardQueryFactory<S> final TriggerManager<S> mTriggerManager;
- JDBCStorage(JDBCRepository repository, JDBCStorableInfo<S> info, boolean autoVersioning)
+ JDBCStorage(JDBCRepository repository, JDBCStorableInfo<S> info,
+ boolean autoVersioning, boolean suppressReload)
throws SupportException, RepositoryException
{
super(info.getStorableType());
@@ -99,7 +100,7 @@ class JDBCStorage<S extends Storable> extends StandardQueryFactory<S> mInfo = info;
Class<? extends S> generatedStorableClass = JDBCStorableGenerator
- .getGeneratedClass(info, autoVersioning);
+ .getGeneratedClass(info, autoVersioning, suppressReload);
mInstanceFactory = QuickConstructorGenerator
.getInstance(generatedStorableClass, InstanceFactory.class);
diff --git a/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCTransaction.java b/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCTransaction.java index 832745b..07fc04e 100644 --- a/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCTransaction.java +++ b/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCTransaction.java @@ -39,13 +39,18 @@ class JDBCTransaction { // avoid a round trip call to the remote database.
private static final int LEVEL_NOT_CHANGED = -1;
+ private final boolean mIsNested;
private final Connection mConnection;
private final int mOriginalLevel;
+
+ private boolean mReady = true;
+
private Savepoint mSavepoint;
private List<JDBCLob> mRegisteredLobs;
JDBCTransaction(Connection con) {
+ mIsNested = false;
mConnection = con;
// Don't change level upon abort.
mOriginalLevel = LEVEL_NOT_CHANGED;
@@ -55,6 +60,7 @@ class JDBCTransaction { * Construct a nested transaction.
*/
JDBCTransaction(JDBCTransaction parent, IsolationLevel level) throws SQLException {
+ mIsNested = true;
mConnection = parent.mConnection;
if (level == null) {
@@ -83,14 +89,20 @@ class JDBCTransaction { return mConnection;
}
+ void reuse() throws SQLException {
+ if (mIsNested && mSavepoint == null) {
+ mSavepoint = mConnection.setSavepoint();
+ }
+ mReady = true;
+ }
+
void commit() throws SQLException {
- if (mSavepoint == null) {
- mConnection.commit();
+ if (mIsNested) {
+ mSavepoint = null;
} else {
- // Don't commit, make a new savepoint. Root transaction has no
- // savepoint, and so it will do the real commit.
- mSavepoint = mConnection.setSavepoint();
+ mConnection.commit();
}
+ mReady = false;
}
/**
@@ -104,12 +116,16 @@ class JDBCTransaction { }
mRegisteredLobs = null;
}
- if (mSavepoint == null) {
- mConnection.rollback();
- mConnection.setAutoCommit(true);
- return mConnection;
- } else {
- mConnection.rollback(mSavepoint);
+
+ if (mIsNested) {
+ if (mReady) {
+ if (mSavepoint != null) {
+ mConnection.rollback(mSavepoint);
+ mSavepoint = null;
+ }
+ mReady = false;
+ }
+
if (mOriginalLevel != LEVEL_NOT_CHANGED) {
if (mOriginalLevel == Connection.TRANSACTION_NONE) {
mConnection.setAutoCommit(true);
@@ -117,8 +133,14 @@ class JDBCTransaction { mConnection.setTransactionIsolation(mOriginalLevel);
}
}
- mSavepoint = null;
+
return null;
+ } else {
+ if (mReady) {
+ mConnection.rollback();
+ mReady = false;
+ }
+ return mConnection;
}
}
diff --git a/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCTransactionManager.java b/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCTransactionManager.java index 862152d..a70e4c3 100644 --- a/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCTransactionManager.java +++ b/src/main/java/com/amazon/carbonado/repo/jdbc/JDBCTransactionManager.java @@ -78,6 +78,11 @@ class JDBCTransactionManager extends TransactionManager<JDBCTransaction> { return new JDBCTransaction(repo.getConnectionForTxn(level));
}
+ @Override
+ protected void reuseTxn(JDBCTransaction txn) throws SQLException {
+ txn.reuse();
+ }
+
protected boolean commitTxn(JDBCTransaction txn) throws PersistException {
try {
txn.commit();
@@ -95,7 +100,7 @@ class JDBCTransactionManager extends TransactionManager<JDBCTransaction> { if (repo == null) {
con.close();
} else {
- repo.yieldConnection(con);
+ repo.closeConnection(con);
}
}
} catch (Throwable e) {
diff --git a/src/main/java/com/amazon/carbonado/repo/jdbc/LoggingConnection.java b/src/main/java/com/amazon/carbonado/repo/jdbc/LoggingConnection.java index 8ca4226..3f79473 100644 --- a/src/main/java/com/amazon/carbonado/repo/jdbc/LoggingConnection.java +++ b/src/main/java/com/amazon/carbonado/repo/jdbc/LoggingConnection.java @@ -126,6 +126,7 @@ class LoggingConnection implements Connection { }
public void setAutoCommit(boolean autoCommit) throws SQLException {
+ mLog.debug("Connection.setAutoCommit(" + autoCommit + ')');
mCon.setAutoCommit(autoCommit);
}
@@ -174,6 +175,29 @@ class LoggingConnection implements Connection { }
public void setTransactionIsolation(int level) throws SQLException {
+ String levelStr;
+ switch (level) {
+ default:
+ levelStr = String.valueOf(level);
+ break;
+ case Connection.TRANSACTION_NONE:
+ levelStr = "TRANSACTION_NONE";
+ break;
+ case Connection.TRANSACTION_READ_UNCOMMITTED:
+ levelStr = "TRANSACTION_READ_UNCOMMITTED";
+ break;
+ case Connection.TRANSACTION_READ_COMMITTED:
+ levelStr = "TRANSACTION_READ_COMMITTED";
+ break;
+ case Connection.TRANSACTION_REPEATABLE_READ:
+ levelStr = "TRANSACTION_REPEATABLE_READ";
+ break;
+ case Connection.TRANSACTION_SERIALIZABLE:
+ levelStr = "TRANSACTION_SERIALIZABLE";
+ break;
+ }
+
+ mLog.debug("Connection.setTransactionIsolation(" + levelStr + ')');
mCon.setTransactionIsolation(level);
}
diff --git a/src/main/java/com/amazon/carbonado/spi/TransactionManager.java b/src/main/java/com/amazon/carbonado/spi/TransactionManager.java index f16f548..fe08a01 100644 --- a/src/main/java/com/amazon/carbonado/spi/TransactionManager.java +++ b/src/main/java/com/amazon/carbonado/spi/TransactionManager.java @@ -249,7 +249,7 @@ public abstract class TransactionManager<Txn> { /**
* Returns null if no transaction is in progress.
*
- * @throws Exception thrown by createTxn
+ * @throws Exception thrown by createTxn or reuseTxn
*/
public Txn getTxn() throws Exception {
mLock.lock();
@@ -342,6 +342,17 @@ public abstract class TransactionManager<Txn> { }
/**
+ * Called when a transaction is about to be reused. The default
+ * implementation of this method does nothing. Override if any preparation
+ * is required to ready a transaction for reuse.
+ *
+ * @param txn transaction to reuse, never null
+ * @since 1.1.3
+ */
+ protected void reuseTxn(Txn txn) throws Exception {
+ }
+
+ /**
* Commits and closes the given internal transaction.
*
* @return true if transaction object is still valid
@@ -502,13 +513,28 @@ public abstract class TransactionManager<Txn> { // Caller must hold mLock.
Txn getTxn() throws Exception {
- if (mTxn == null) {
- TransactionManager<Txn> txnMgr = mTxnMgr;
- Txn parent = (mParent == null || mTop) ? null : mParent.getTxn();
+ TransactionManager<Txn> txnMgr = mTxnMgr;
+ if (mTxn != null) {
+ txnMgr.reuseTxn(mTxn);
+ } else {
+ Txn parentTxn;
+ if (mParent == null || mTop) {
+ parentTxn = null;
+ } else if ((parentTxn = mParent.mTxn) == null) {
+ // No point in creating nested transaction if parent
+ // has never been used. Create parent transaction
+ // and use it in child transaction, just like a fake
+ // nested transaction.
+ if ((parentTxn = mParent.getTxn()) != null) {
+ return mTxn = parentTxn;
+ }
+ // Isolation level of parent is none, so proceed to create
+ // a real transaction.
+ }
if (mTimeoutUnit == null) {
- mTxn = txnMgr.createTxn(parent, mLevel);
+ mTxn = txnMgr.createTxn(parentTxn, mLevel);
} else {
- mTxn = txnMgr.createTxn(parent, mLevel, mDesiredLockTimeout, mTimeoutUnit);
+ mTxn = txnMgr.createTxn(parentTxn, mLevel, mDesiredLockTimeout, mTimeoutUnit);
}
}
return mTxn;
|