kotlin-orm · vincentlauvlwj · Feb 28, 2021 · Jan 29, 2021 · Feb 5, 2021 · Feb 5, 2021
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
@@ -7,6 +7,6 @@ Pull requests are always welcome and can be a quick way to get your fix or impro
 
 - By contributing to Ktorm, you agree to uphold our [Code of Conduct](CODE_OF_CONDUCT.md).
 - By contributing to Ktorm, you agree that your contributions will be licensed under [Apache License 2.0](LICENSE).
-- Coding Conventions are very import. Refer to the [Kotlin Style Guide](https://kotlinlang.org/docs/reference/coding-conventions.html) for the recommended coding standards of Ktorm.
+- Coding Conventions are very important. Refer to the [Kotlin Style Guide](https://kotlinlang.org/docs/reference/coding-conventions.html) for the recommended coding standards of Ktorm.
 - If you've added code that should be tested, add tests and ensure they all pass. If you've changed APIs, update the documentation. 
 - If it's your first time contributing to Ktorm, please also update the `build.gradle` file, add your GitHub ID to the developers info, which will let more people know your contributions.
diff --git a/build.gradle b/build.gradle
@@ -2,7 +2,7 @@
 buildscript {
     ext {
         kotlinVersion = "1.4.21"
-        detektVersion = "1.12.0-RC1"
+        detektVersion = "1.15.0"
     }
     repositories {
         jcenter()

diff --git a/ktorm-core/src/main/kotlin/org/ktorm/database/SqlDialect.kt b/ktorm-core/src/main/kotlin/org/ktorm/database/SqlDialect.kt
@@ -17,6 +17,7 @@
 package org.ktorm.database
 
 import org.ktorm.expression.ArgumentExpression
+import org.ktorm.expression.ForUpdateOption
 import org.ktorm.expression.QueryExpression
 import org.ktorm.expression.SqlFormatter
 import java.sql.Statement
@@ -50,6 +51,10 @@ public interface SqlDialect {
      */
     public fun createSqlFormatter(database: Database, beautifySql: Boolean, indentSize: Int): SqlFormatter {
         return object : SqlFormatter(database, beautifySql, indentSize) {
+            override fun writeForUpdate(forUpdate: ForUpdateOption) {
+                throw DialectFeatureNotSupportedException("ForUpdate is not supported in Standard SQL.")
+            }
+
             override fun writePagination(expr: QueryExpression) {
                 throw DialectFeatureNotSupportedException("Pagination is not supported in Standard SQL.")
             }

diff --git a/ktorm-core/src/main/kotlin/org/ktorm/dsl/Query.kt b/ktorm-core/src/main/kotlin/org/ktorm/dsl/Query.kt
@@ -763,13 +763,13 @@ public fun Query.joinToString(
 }
 
 /**
- * Indicate that this query should aquire the record-lock, the generated SQL would be `select ... for update`.
+ * Indicate that this query should acquire the record-lock, the generated SQL will depend on the SqlDialect.
  *
  * @since 3.1.0
  */
-public fun Query.forUpdate(): Query {
+public fun Query.forUpdate(forUpdate: ForUpdateOption): Query {
     val expr = when (expression) {
-        is SelectExpression -> expression.copy(forUpdate = true)
+        is SelectExpression -> expression.copy(forUpdate = forUpdate)
         is UnionExpression -> throw IllegalStateException("SELECT FOR UPDATE is not supported in a union expression.")
     }
 

diff --git a/ktorm-core/src/main/kotlin/org/ktorm/entity/EntitySequence.kt b/ktorm-core/src/main/kotlin/org/ktorm/entity/EntitySequence.kt
@@ -19,6 +19,7 @@ package org.ktorm.entity
 import org.ktorm.database.Database
 import org.ktorm.database.DialectFeatureNotSupportedException
 import org.ktorm.dsl.*
+import org.ktorm.expression.ForUpdateOption
 import org.ktorm.expression.OrderByExpression
 import org.ktorm.expression.SelectExpression
 import org.ktorm.schema.BaseTable
@@ -1505,10 +1506,11 @@ public fun <E : Any> EntitySequence<E, *>.joinToString(
 }
 
 /**
- * Indicate that this query should aquire the record-lock, the generated SQL would be `select ... for update`.
+ * Indicate that this query should acquire the record-lock, the generated SQL will depend on the SqlDialect.
  *
  * @since 3.1.0
  */
-public fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.forUpdate(): EntitySequence<E, T> {
-    return this.withExpression(expression.copy(forUpdate = true))
+public fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.forUpdate(
+    forUpdate: ForUpdateOption): EntitySequence<E, T> {
+    return this.withExpression(expression.copy(forUpdate = forUpdate))
 }
diff --git a/ktorm-core/src/main/kotlin/org/ktorm/expression/SqlExpressions.kt b/ktorm-core/src/main/kotlin/org/ktorm/expression/SqlExpressions.kt
@@ -115,7 +115,8 @@ public sealed class QueryExpression : QuerySourceExpression() {
  * @property groupBy the grouping conditions, represents the `group by` clause of SQL.
  * @property having the having condition, represents the `having` clause of SQL.
  * @property isDistinct mark if this query is distinct, true means the SQL is `select distinct ...`.
- * @property forUpdate mark if this query should aquire the record-lock, true means the SQL is `select ... for update`.
+ * @property forUpdate mark if this query should acquire the record-lock, non-null will generate a dialect-specific
+ * `for update` clause.
  */
 public data class SelectExpression(
     val columns: List<ColumnDeclaringExpression<*>> = emptyList(),
@@ -124,14 +125,23 @@ public data class SelectExpression(
     val groupBy: List<ScalarExpression<*>> = emptyList(),
     val having: ScalarExpression<Boolean>? = null,
     val isDistinct: Boolean = false,
-    val forUpdate: Boolean = false,
+    val forUpdate: ForUpdateOption = ForUpdateOption.None,
     override val orderBy: List<OrderByExpression> = emptyList(),
     override val offset: Int? = null,
     override val limit: Int? = null,
     override val tableAlias: String? = null,
     override val extraProperties: Map<String, Any> = emptyMap()
 ) : QueryExpression()
 
+/**
+ * ForUpdateOption, database-specific implementations are in support module for each database dialect.
+ */
+public interface ForUpdateOption {
+    public companion object {
+        public val None: ForUpdateOption = object : ForUpdateOption {}
+    }
+}
+
 /**
  * Union expression, represents a `union` statement of SQL.
  *

diff --git a/ktorm-core/src/main/kotlin/org/ktorm/expression/SqlFormatter.kt b/ktorm-core/src/main/kotlin/org/ktorm/expression/SqlFormatter.kt
@@ -388,12 +388,14 @@ public abstract class SqlFormatter(
         if (expr.offset != null || expr.limit != null) {
             writePagination(expr)
         }
-        if (expr.forUpdate) {
-            writeKeyword("for update ")
+        if (expr.forUpdate != ForUpdateOption.None) {
+            writeForUpdate(expr.forUpdate)
         }
         return expr
     }
 
+    protected abstract fun writeForUpdate(forUpdate: ForUpdateOption)
+
     override fun visitQuerySource(expr: QuerySourceExpression): QuerySourceExpression {
         when (expr) {
             is TableExpression -> {

diff --git a/ktorm-core/src/test/kotlin/org/ktorm/dsl/QueryTest.kt b/ktorm-core/src/test/kotlin/org/ktorm/dsl/QueryTest.kt
@@ -259,33 +259,6 @@ class QueryTest : BaseTest() {
         println(query.sql)
     }
 
-    @Test
-    fun testSelctForUpdate() {
-        database.useTransaction {
-            val employee = database
-                .sequenceOf(Employees, withReferences = false)
-                .filter { it.id eq 1 }
-                .forUpdate()
-                .first()
-
-            val future = Executors.newSingleThreadExecutor().submit {
-                employee.name = "vince"
-                employee.flushChanges()
-            }
-
-            try {
-                future.get(5, TimeUnit.SECONDS)
-                throw AssertionError()
-            } catch (e: ExecutionException) {
-                // Expected, the record is locked.
-                e.printStackTrace()
-            } catch (e: TimeoutException) {
-                // Expected, the record is locked.
-                e.printStackTrace()
-            }
-        }
-    }
-
     @Test
     fun testFlatMap() {
         val names = database

diff --git a/ktorm-support-mysql/ktorm-support-mysql.gradle b/ktorm-support-mysql/ktorm-support-mysql.gradle
@@ -5,5 +5,5 @@ dependencies {
     testImplementation project(path: ":ktorm-core", configuration: "testOutput")
     testImplementation project(":ktorm-jackson")
     testImplementation "mysql:mysql-connector-java:8.0.13"
-    testImplementation "org.testcontainers:mysql:1.11.3"
+    testImplementation "org.testcontainers:mysql:1.15.1"
 }
diff --git a/ktorm-support-mysql/src/main/kotlin/org/ktorm/support/mysql/MySqlDialect.kt b/ktorm-support-mysql/src/main/kotlin/org/ktorm/support/mysql/MySqlDialect.kt
@@ -17,10 +17,15 @@
 package org.ktorm.support.mysql
 
 import org.ktorm.database.Database
+import org.ktorm.database.DialectFeatureNotSupportedException
 import org.ktorm.database.SqlDialect
 import org.ktorm.expression.*
 import org.ktorm.schema.IntSqlType
 import org.ktorm.schema.VarcharSqlType
+import org.ktorm.support.mysql.MySqlForUpdateOption.ForShare
+import org.ktorm.support.mysql.MySqlForUpdateOption.ForUpdate
+import org.ktorm.support.mysql.Version.MySql5
+import org.ktorm.support.mysql.Version.MySql8
 
 /**
  * [SqlDialect] implementation for MySQL database.
@@ -32,12 +37,33 @@ public open class MySqlDialect : SqlDialect {
     }
 }
 
+private enum class Version {
+    MySql5, MySql8
+}
+
+/**
+ * Thrown to indicate that the MySql version is not supported by the dialect.
+ *
+ * @param databaseMetaData used to format the exception's message.
+ */
+public class UnsupportedMySqlVersionException(productVersion: String) :
+    UnsupportedOperationException("Unsupported MySql version $productVersion.") {
+    private companion object {
+        private const val serialVersionUID = 1L
+    }
+}
+
 /**
  * [SqlFormatter] implementation for MySQL, formatting SQL expressions as strings with their execution arguments.
  */
 public open class MySqlFormatter(
     database: Database, beautifySql: Boolean, indentSize: Int
 ) : SqlFormatter(database, beautifySql, indentSize) {
+    private val version: Version = when {
+        database.productVersion.startsWith("5") -> MySql5
+        database.productVersion.startsWith("8") -> MySql8
+        else -> throw UnsupportedMySqlVersionException(database.productVersion)
+    }
 
     override fun visit(expr: SqlExpression): SqlExpression {
         val result = when (expr) {
@@ -129,6 +155,30 @@ public open class MySqlFormatter(
         write(") ")
         return expr
     }
+
+    override fun writeForUpdate(forUpdate: ForUpdateOption) {
+        when {
+            forUpdate == ForUpdate -> writeKeyword("for update ")
+            forUpdate == ForShare && version == MySql5 -> writeKeyword("lock in share mode ")
+            forUpdate == ForShare && version == MySql8 -> writeKeyword("for share ")
+            else -> throw DialectFeatureNotSupportedException(
+                "Unsupported ForUpdateOption ${forUpdate::class.java.name}."
+            )
+        }
+    }
+}
+
+/**
+ * MySql Specific ForUpdateOptions.
+ */
+public sealed class MySqlForUpdateOption : ForUpdateOption {
+    /**
+     * The generated SQL would be `select ... lock in share mode` for MySql 5 and `select ... for share` for MySql 8.
+     **/
+    public object ForShare : MySqlForUpdateOption()
+
+    /** The generated SQL would be `select ... for update`. */
+    public object ForUpdate : MySqlForUpdateOption()
 }
 
 /**

diff --git a/ktorm-support-mysql/src/test/kotlin/org/ktorm/support/mysql/MySqlTest.kt b/ktorm-support-mysql/src/test/kotlin/org/ktorm/support/mysql/MySqlTest.kt
@@ -36,7 +36,7 @@ class MySqlTest : BaseTest() {
         const val ID_3 = 3
         const val ID_4 = 4
 
-        class KMySqlContainer : MySQLContainer<KMySqlContainer>()
+        class KMySqlContainer : MySQLContainer<KMySqlContainer>("mysql:8")
 
         @ClassRule
         @JvmField
@@ -417,12 +417,12 @@ class MySqlTest : BaseTest() {
     }
 
     @Test
-    fun testSelctForUpdate() {
+    fun testSelectForUpdate() {
         database.useTransaction {
             val employee = database
                 .sequenceOf(Employees, withReferences = false)
                 .filter { it.id eq 1 }
-                .forUpdate()
+                .forUpdate(MySqlForUpdateOption.ForUpdate)
                 .first()
 
             val future = Executors.newSingleThreadExecutor().submit {

diff --git a/ktorm-support-oracle/ktorm-support-oracle.gradle b/ktorm-support-oracle/ktorm-support-oracle.gradle
@@ -4,5 +4,5 @@ dependencies {
 
     testImplementation project(path: ":ktorm-core", configuration: "testOutput")
     testImplementation fileTree(dir: "lib", includes: ["*.jar"])
-    testImplementation "org.testcontainers:oracle-xe:1.11.3"
+    testImplementation "org.testcontainers:oracle-xe:1.15.1"
 }
diff --git a/ktorm-support-oracle/src/main/kotlin/org/ktorm/support/oracle/OracleDialect.kt b/ktorm-support-oracle/src/main/kotlin/org/ktorm/support/oracle/OracleDialect.kt
@@ -21,6 +21,7 @@ import org.ktorm.database.DialectFeatureNotSupportedException
 import org.ktorm.database.SqlDialect
 import org.ktorm.expression.*
 import org.ktorm.schema.IntSqlType
+import org.ktorm.support.oracle.OracleForUpdateOption.ForUpdate
 
 /**
  * [SqlDialect] implementation for Oracle database.
@@ -32,6 +33,14 @@ public open class OracleDialect : SqlDialect {
     }
 }
 
+/**
+ * Oracle Specific ForUpdateOptions.
+ */
+public sealed class OracleForUpdateOption : ForUpdateOption {
+    /** The generated SQL would be `select ... for update`. */
+    public object ForUpdate : OracleForUpdateOption()
+}
+
 /**
  * [SqlFormatter] implementation for Oracle, formatting SQL expressions as strings with their execution arguments.
  */
@@ -51,11 +60,20 @@ public open class OracleFormatter(
         return identifier.startsWith('_') || super.shouldQuote(identifier)
     }
 
+    override fun writeForUpdate(forUpdate: ForUpdateOption) {
+        when (forUpdate) {
+            ForUpdate -> writeKeyword("for update ")
+            else -> throw DialectFeatureNotSupportedException(
+                "Unsupported ForUpdateOption ${forUpdate::class.java.name}."
+            )
+        }
+    }
+
     override fun visitQuery(expr: QueryExpression): QueryExpression {
         if (expr.offset == null && expr.limit == null) {
             return super.visitQuery(expr)
         }
-        if (expr is SelectExpression && expr.forUpdate) {
+        if (expr is SelectExpression && expr.forUpdate != ForUpdateOption.None) {
             throw DialectFeatureNotSupportedException("SELECT FOR UPDATE not supported when using offset/limit params.")
         }
 

diff --git a/ktorm-support-oracle/src/test/kotlin/org/ktorm/support/oracle/OracleTest.kt b/ktorm-support-oracle/src/test/kotlin/org/ktorm/support/oracle/OracleTest.kt
@@ -155,7 +155,7 @@ class OracleTest : BaseTest() {
             val employee = database
                 .sequenceOf(Employees, withReferences = false)
                 .filter { it.id eq 1 }
-                .forUpdate()
+                .forUpdate(OracleForUpdateOption.ForUpdate)
                 .single()
 
             val future = Executors.newSingleThreadExecutor().submit {

diff --git a/ktorm-support-postgresql/ktorm-support-postgresql.gradle b/ktorm-support-postgresql/ktorm-support-postgresql.gradle
@@ -4,5 +4,5 @@ dependencies {
 
     testImplementation project(path: ":ktorm-core", configuration: "testOutput")
     testImplementation "org.postgresql:postgresql:42.2.5"
-    testImplementation "org.testcontainers:postgresql:1.11.3"
+    testImplementation "org.testcontainers:postgresql:1.15.1"
 }