change the default isolation to null #231

Author: vincentlauvlwj

ktorm-core/src/main/kotlin/org/ktorm/database/Database.kt

@@ -313,16 +313,15 @@ public class Database(
      * - Any exceptions thrown in the callback function can trigger a rollback.
      * - This function is reentrant, so it can be called nested. However, the inner calls don’t open new transactions
      * but share the same ones with outers.
+     * - Since version 3.3.0, the default isolation has changed to null (stands for the default isolation level of the
+     * underlying datastore), not [TransactionIsolation.REPEATABLE_READ] anymore.
      *
-     * @param isolation transaction isolation, enums defined in [TransactionIsolation].
+     * @param isolation transaction isolation, null for the default isolation level of the underlying datastore.
      * @param func the executed callback function.
      * @return the result of the callback function.
      */
     @OptIn(ExperimentalContracts::class)
-    public inline fun <T> useTransaction(
-        isolation: TransactionIsolation = TransactionIsolation.REPEATABLE_READ,
-        func: (Transaction) -> T
-    ): T {
+    public inline fun <T> useTransaction(isolation: TransactionIsolation? = null, func: (Transaction) -> T): T {
         contract {
             callsInPlace(func, InvocationKind.EXACTLY_ONCE)
         }

ktorm-core/src/main/kotlin/org/ktorm/database/JdbcTransactionManager.kt

@@ -35,11 +35,11 @@ import javax.sql.DataSource
 public class JdbcTransactionManager(public val connector: () -> Connection) : TransactionManager {
     private val threadLocal = ThreadLocal<Transaction>()
 
-    override val defaultIsolation: TransactionIsolation = TransactionIsolation.REPEATABLE_READ
+    override val defaultIsolation: TransactionIsolation? = null
 
     override val currentTransaction: Transaction? get() = threadLocal.get()
 
-    override fun newTransaction(isolation: TransactionIsolation): Transaction {
+    override fun newTransaction(isolation: TransactionIsolation?): Transaction {
         if (currentTransaction != null) {
             throw IllegalStateException("Current thread is already in a transaction.")
         }
@@ -51,16 +51,18 @@ public class JdbcTransactionManager(public val connector: () -> Connection) : Tr
         return connector.invoke()
     }
 
-    private inner class JdbcTransaction(private val desiredIsolation: TransactionIsolation) : Transaction {
-        private var originIsolation = defaultIsolation.level
+    private inner class JdbcTransaction(private val desiredIsolation: TransactionIsolation?) : Transaction {
+        private var originIsolation = -1
         private var originAutoCommit = true
 
         private val connectionLazy = lazy(LazyThreadSafetyMode.NONE) {
             newConnection().apply {
                 try {
-                    originIsolation = transactionIsolation
-                    if (originIsolation != desiredIsolation.level) {
-                        transactionIsolation = desiredIsolation.level
+                    if (desiredIsolation != null) {
+                        originIsolation = transactionIsolation
+                        if (originIsolation != desiredIsolation.level) {
+                            transactionIsolation = desiredIsolation.level
+                        }
                     }
 
                     originAutoCommit = autoCommit
@@ -83,7 +85,7 @@ public class JdbcTransactionManager(public val connector: () -> Connection) : Tr
         }
 
         override fun rollback() {
-            if (connectionLazy.isInitialized() && !connection.isClosed) {
+            if (connectionLazy.isInitialized()) {
                 connection.rollback()
             }
         }
@@ -101,7 +103,7 @@ public class JdbcTransactionManager(public val connector: () -> Connection) : Tr
         @Suppress("SwallowedException")
         private fun Connection.closeSilently() {
             try {
-                if (originIsolation != desiredIsolation.level) {
+                if (desiredIsolation != null && originIsolation != desiredIsolation.level) {
                     transactionIsolation = originIsolation
                 }
                 if (originAutoCommit) {

ktorm-core/src/main/kotlin/org/ktorm/database/SpringManagedTransactionManager.kt

@@ -35,11 +35,11 @@ public class SpringManagedTransactionManager(public val dataSource: DataSource)
 
     private val proxy = dataSource as? TransactionAwareDataSourceProxy ?: TransactionAwareDataSourceProxy(dataSource)
 
-    override val defaultIsolation: TransactionIsolation get() = TransactionIsolation.REPEATABLE_READ
+    override val defaultIsolation: TransactionIsolation? = null
 
     override val currentTransaction: Transaction? = null
 
-    override fun newTransaction(isolation: TransactionIsolation): Nothing {
+    override fun newTransaction(isolation: TransactionIsolation?): Nothing {
         val msg = "Transaction is managed by Spring, please use Spring's @Transactional annotation instead."
         throw UnsupportedOperationException(msg)
     }

ktorm-core/src/main/kotlin/org/ktorm/database/TransactionManager.kt

@@ -30,9 +30,9 @@ import java.sql.Connection
 public interface TransactionManager {
 
     /**
-     * The default transaction isolation.
+     * The default transaction isolation, null for the default isolation level of the underlying datastore.
      */
-    public val defaultIsolation: TransactionIsolation
+    public val defaultIsolation: TransactionIsolation?
 
     /**
      * The opened transaction of the current thread, null if there is no transaction opened.
@@ -46,7 +46,7 @@ public interface TransactionManager {
      * @return the new-created transaction.
      * @throws [IllegalStateException] if there is already a transaction opened.
      */
-    public fun newTransaction(isolation: TransactionIsolation = defaultIsolation): Transaction
+    public fun newTransaction(isolation: TransactionIsolation? = defaultIsolation): Transaction
 
     /**
      * Create a native JDBC connection to the database.

ktorm-global/src/main/kotlin/org/ktorm/global/Global.kt

@@ -247,17 +247,16 @@ public inline fun <T> useConnection(func: (Connection) -> T): T {
  * - Any exceptions thrown in the callback function can trigger a rollback.
  * - This function is reentrant, so it can be called nested. However, the inner calls don’t open new transactions
  * but share the same ones with outers.
+ * - Since version 3.3.0, the default isolation has changed to null (stands for the default isolation level of the
+ * underlying datastore), not [TransactionIsolation.REPEATABLE_READ] anymore.
  *
- * @param isolation transaction isolation, enums defined in [TransactionIsolation].
+ * @param isolation transaction isolation, null for the default isolation level of the underlying datastore.
  * @param func the executed callback function.
  * @return the result of the callback function.
  * @see Database.useTransaction
  */
 @OptIn(ExperimentalContracts::class)
-public inline fun <T> useTransaction(
-    isolation: TransactionIsolation = TransactionIsolation.REPEATABLE_READ,
-    func: (Transaction) -> T
-): T {
+public inline fun <T> useTransaction(isolation: TransactionIsolation?, func: (Transaction) -> T): T {
     contract {
         callsInPlace(func, InvocationKind.EXACTLY_ONCE)
     }