Merge pull request #785 from jeffgbutler/improve-kotlin-case-dsl

jeffgbutler · web-flow · commit e8f18900003b · 2024-05-01T10:24:22.000-04:00
Improve Kotlin CASE DSL
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -2,12 +2,16 @@
 
 This log will detail notable changes to MyBatis Dynamic SQL. Full details are available on the GitHub milestone pages.
 
-## Release 1.5.1 - April 30, 2024
+## Release 1.5.2 - Unreleased
 
-This is a minor release with several enhancements.
+This is a small maintenance release with improvements to the Kotlin DSL for CASE expressions.
 
 **Important:** This is the last release that will be compatible with Java 8.
 
+## Release 1.5.1 - April 30, 2024
+
+This is a minor release with several enhancements.
+
 GitHub milestone: [https://github.com/mybatis/mybatis-dynamic-sql/milestone/13?closed=1](https://github.com/mybatis/mybatis-dynamic-sql/milestone/13?closed=1)
 
 ### Case Expressions and Cast Function
diff --git a/pom.xml b/pom.xml
@@ -26,7 +26,7 @@
 
   <groupId>org.mybatis.dynamic-sql</groupId>
   <artifactId>mybatis-dynamic-sql</artifactId>
-  <version>1.6.0-SNAPSHOT</version>
+  <version>1.5.2-SNAPSHOT</version>
 
   <name>MyBatis Dynamic SQL</name>
   <description>MyBatis framework for generating dynamic SQL</description>
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/elements/CaseDSLs.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/elements/CaseDSLs.kt
@@ -38,10 +38,9 @@ class KSearchedCaseDSL : KElseDSL {
                 .withSubCriteria(subCriteria)
                 .withThenValue(thenValue)
                 .build())
-
         }
 
-    override fun `else`(column: BasicColumn) {
+    override infix fun `else`(column: BasicColumn) {
         this.elseValue = column
     }
 }
@@ -53,7 +52,7 @@ class SearchedCaseCriteriaCollector : GroupingCriteriaCollector(), KThenDSL {
             field = value
         }
 
-    override fun then(column: BasicColumn) {
+    override infix fun then(column: BasicColumn) {
         thenValue = column
     }
 }
@@ -66,88 +65,71 @@ class KSimpleCaseDSL<T : Any> : KElseDSL {
         }
     internal val whenConditions = mutableListOf<SimpleCaseWhenCondition<T>>()
 
-    fun `when`(firstCondition: VisitableCondition<T>, vararg subsequentConditions: VisitableCondition<T>,
-               completer: SimpleCaseThenGatherer.() -> Unit) =
-        SimpleCaseThenGatherer().apply(completer).run {
-            val allConditions = buildList {
-                add(firstCondition)
-                addAll(subsequentConditions)
-            }
-
-            whenConditions.add(ConditionBasedWhenCondition(allConditions, thenValue))
+    fun `when`(vararg conditions: VisitableCondition<T>) =
+        SimpleCaseThenGatherer { thenValue ->
+            whenConditions.add(ConditionBasedWhenCondition(conditions.asList(), thenValue))
         }
 
-    fun `when`(firstValue: T, vararg subsequentValues: T, completer: SimpleCaseThenGatherer.() -> Unit) =
-        SimpleCaseThenGatherer().apply(completer).run {
-            val allConditions = buildList {
-                add(firstValue)
-                addAll(subsequentValues)
-            }
-
-            whenConditions.add(BasicWhenCondition(allConditions, thenValue))
+    fun `when`(vararg values: T) =
+        SimpleCaseThenGatherer { thenValue ->
+            whenConditions.add(BasicWhenCondition(values.asList(), thenValue))
         }
 
-    override fun `else`(column: BasicColumn) {
+    override infix fun `else`(column: BasicColumn) {
         this.elseValue = column
     }
 }
 
-class SimpleCaseThenGatherer: KThenDSL {
-    internal var thenValue: BasicColumn? = null
-        private set(value) {
-            assertNull(field, "ERROR.41") //$NON-NLS-1$
-            field = value
-        }
-
-    override fun then(column: BasicColumn) {
-        thenValue = column
+class SimpleCaseThenGatherer(private val consumer: (BasicColumn) -> Unit): KThenDSL {
+    override infix fun then(column: BasicColumn) {
+        consumer.invoke(column)
     }
 }
 
 interface KThenDSL {
-    fun then(value: String) {
+    infix fun then(value: String) {
         then(stringConstant(value))
     }
 
-    fun then(value: Boolean) {
+    infix fun then(value: Boolean) {
         then(constant<String>(value.toString()))
     }
 
-    fun then(value: Int) {
+    infix fun then(value: Int) {
         then(constant<String>(value.toString()))
     }
 
-    fun then(value: Long) {
+    infix fun then(value: Long) {
         then(constant<String>(value.toString()))
     }
 
-    fun then(value: Double) {
+    infix fun then(value: Double) {
         then(constant<String>(value.toString()))
     }
 
-    fun then(column: BasicColumn)
+    infix fun then(column: BasicColumn)
 }
 
 interface KElseDSL {
-    fun `else`(value: String) {
+    infix fun `else`(value: String) {
         `else`(stringConstant(value))
     }
 
-    fun `else`(value: Boolean) {
+    infix fun `else`(value: Boolean) {
         `else`(constant<String>(value.toString()))
     }
 
-    fun `else`(value: Int) {
+    infix fun `else`(value: Int) {
         `else`(constant<String>(value.toString()))
     }
 
-    fun `else`(value: Long) {
+    infix fun `else`(value: Long) {
         `else`(constant<String>(value.toString()))
     }
 
-    fun `else`(value: Double) {
+    infix fun `else`(value: Double) {
         `else`(constant<String>(value.toString()))
     }
 
-    fun `else`(column: BasicColumn)
+    infix fun `else`(column: BasicColumn)
 }
diff --git a/src/site/markdown/docs/kotlinCaseExpressions.md b/src/site/markdown/docs/kotlinCaseExpressions.md
@@ -72,7 +72,7 @@ A simple case expression can be coded like the following in the Kotlin DSL:
 
 ```kotlin
 select(case(id) {
-    `when`(1, 2, 3) { then(true) }
+    `when`(1, 2, 3) then true
     `else`(false)
   } `as` "small_id"
 ) {
@@ -91,7 +91,7 @@ you can write the query as follows:
 
 ```kotlin
 select(case(id) {
-    `when`(1, 2, 3) { then(value(true)) }
+    `when`(1, 2, 3) then value(true)
     `else`(value(false))
   } `as` "small_id"
 ) {
@@ -111,7 +111,7 @@ expected data type. Here's an example of using the `cast` function:
 
 ```kotlin
 select(case(id) {
-    `when`(1, 2, 3) { then(value(true)) }
+    `when`(1, 2, 3) then value(true)
     `else`(cast { value(false) `as` "BOOLEAN" })
   } `as` "small_id"
 ) {
@@ -134,8 +134,8 @@ A simple case expression can be coded like the following in the Kotlin DSL:
 
 ```kotlin
 select(case(total_length) {
-    `when`(isLessThan(10)) { then("small") }
-    `when`(isGreaterThan(20)) { then("large") }
+    `when`(isLessThan(10)) then "small"
+    `when`(isGreaterThan(20)) then "large"
     `else`("medium")
   } `as` "tshirt_size"
 ) {
@@ -158,8 +158,8 @@ VARCHAR, you can use the `cast` function as follows:
 
 ```kotlin
 select(case(total_length) {
-    `when`(isLessThan(10)) { then("small") }
-    `when`(isGreaterThan(20)) { then("large") }
+    `when`(isLessThan(10)) then "small"
+    `when`(isGreaterThan(20)) then "large"
     `else`(cast { "medium" `as` "VARCHAR(6)" })
   } `as` "tshirt_size"
 ) {
diff --git a/src/test/kotlin/examples/kotlin/animal/data/KCaseExpressionTest.kt b/src/test/kotlin/examples/kotlin/animal/data/KCaseExpressionTest.kt
@@ -457,7 +457,7 @@ class KCaseExpressionTest {
             val selectStatement = select(
                 animalName,
                 case(animalName) {
-                    `when` (isEqualTo("Artic fox"), isEqualTo("Red fox")) { then("yes") }
+                    `when` (isEqualTo("Artic fox"), isEqualTo("Red fox")) then "yes"
                     `else`("no")
                 } `as` "IsAFox"
             ) {
@@ -511,7 +511,7 @@ class KCaseExpressionTest {
             val selectStatement = select(
                 animalName,
                 case(animalName) {
-                    `when` ("Artic fox", "Red fox") { then("yes") }
+                    `when` ("Artic fox", "Red fox") then "yes"
                     `else`("no")
                 } `as` "IsAFox"
             ) {
@@ -565,7 +565,7 @@ class KCaseExpressionTest {
             val selectStatement = select(
                 animalName,
                 case(animalName) {
-                    `when` (isEqualTo("Artic fox"), isEqualTo("Red fox")) { then(true) }
+                    `when` (isEqualTo("Artic fox"), isEqualTo("Red fox")) then true
                     `else`(false)
                 } `as` "IsAFox"
             ) {
@@ -619,7 +619,7 @@ class KCaseExpressionTest {
             val selectStatement = select(
                 animalName,
                 case(animalName) {
-                    `when` ("Artic fox", "Red fox") { then(true) }
+                    `when` ("Artic fox", "Red fox") then true
                     `else`(false)
                 } `as` "IsAFox"
             ) {
@@ -673,7 +673,7 @@ class KCaseExpressionTest {
             val selectStatement = select(
                 animalName,
                 case(animalName) {
-                    `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")) { then("yes") }
+                    `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")) then "yes"
                 } `as` "IsAFox"
             ) {
                 from(animalData)
@@ -720,7 +720,7 @@ class KCaseExpressionTest {
             val selectStatement = select(
                 animalName,
                 case(animalName) {
-                    `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")) { then(cast { "It's a fox" `as` "VARCHAR(30)" })}
+                    `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")) then cast { "It's a fox" `as` "VARCHAR(30)" }
                     `else`("It's not a fox")
                 } `as` "IsAFox"
             ) {
@@ -763,7 +763,7 @@ class KCaseExpressionTest {
             val selectStatement = select(
                 animalName,
                 case(animalName) {
-                    `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")) { then( 1L) }
+                    `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")) then 1L
                     `else`(2L)
                 } `as` "IsAFox"
             ) {
@@ -806,7 +806,7 @@ class KCaseExpressionTest {
             val selectStatement = select(
                 animalName,
                 case(animalName) {
-                    `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")) { then( 1.1) }
+                    `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")) then 1.1
                     `else`(2.2)
                 } `as` "IsAFox"
             ) {
@@ -849,7 +849,7 @@ class KCaseExpressionTest {
             val selectStatement = select(
                 animalName,
                 case(animalName) {
-                    `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")) { then( 1.1) }
+                    `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")) then  1.1
                     `else`(cast { 2.2 `as` "DOUBLE" })
                 } `as` "IsAFox"
             ) {
@@ -888,35 +888,22 @@ class KCaseExpressionTest {
     fun testInvalidDoubleElseSimple() {
         assertThatExceptionOfType(KInvalidSQLException::class.java).isThrownBy {
             case(animalName) {
-                `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")) { then("'yes'") }
+                `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")) then "yes"
                 `else`("Fred")
                 `else`("Wilma")
             }
         }.withMessage(Messages.getString("ERROR.42"))
     }
 
-    @Test
-    fun testInvalidDoubleThenSimple() {
-        assertThatExceptionOfType(KInvalidSQLException::class.java).isThrownBy {
-            case(animalName) {
-                `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")) {
-                    then("'yes'")
-                    then("no")
-                }
-                `else`("Fred")
-            }
-        }.withMessage(Messages.getString("ERROR.41"))
-    }
-
     @Test
     fun testInvalidDoubleElseSearched() {
         assertThatExceptionOfType(KInvalidSQLException::class.java).isThrownBy {
             case {
                 `when` {
                     id isEqualTo 22
-                    then("'yes'")
+                    this then "yes"
                 }
-                `else`("Fred")
+                this `else` "Fred"
                 `else`("Wilma")
             }
         }.withMessage(Messages.getString("ERROR.42"))
@@ -928,8 +915,8 @@ class KCaseExpressionTest {
             case {
                 `when` {
                     id isEqualTo 22
-                    then("'yes'")
-                    then("'no'")
+                    then("yes")
+                    then("no")
                 }
             }
         }.withMessage(Messages.getString("ERROR.41"))

Original file line number	Diff line number	Diff line change
`@@ -38,10 +38,9 @@ class KSearchedCaseDSL : KElseDSL {`
`38`	`38`	`.withSubCriteria(subCriteria)`
`39`	`39`	`.withThenValue(thenValue)`
`40`	`40`	`.build())`
`41`		`-`
`42`	`41`	`}`
`43`	`42`
`44`		- override fun `else`(column: BasicColumn) {
	`43`	+ override infix fun `else`(column: BasicColumn) {
`45`	`44`	`this.elseValue = column`
`46`	`45`	`}`
`47`	`46`	`}`
`@@ -53,7 +52,7 @@ class SearchedCaseCriteriaCollector : GroupingCriteriaCollector(), KThenDSL {`
`53`	`52`	`field = value`
`54`	`53`	`}`
`55`	`54`
`56`		`- override fun then(column: BasicColumn) {`
	`55`	`+ override infix fun then(column: BasicColumn) {`
`57`	`56`	`thenValue = column`
`58`	`57`	`}`
`59`	`58`	`}`
`@@ -66,88 +65,71 @@ class KSimpleCaseDSL<T : Any> : KElseDSL {`
`66`	`65`	`}`
`67`	`66`	`internal val whenConditions = mutableListOf<SimpleCaseWhenCondition<T>>()`
`68`	`67`
`69`		- fun `when`(firstCondition: VisitableCondition<T>, vararg subsequentConditions: VisitableCondition<T>,
`70`		`- completer: SimpleCaseThenGatherer.() -> Unit) =`
`71`		`- SimpleCaseThenGatherer().apply(completer).run {`
`72`		`- val allConditions = buildList {`
`73`		`- add(firstCondition)`
`74`		`- addAll(subsequentConditions)`
`75`		`- }`
`76`		`-`
`77`		`- whenConditions.add(ConditionBasedWhenCondition(allConditions, thenValue))`
	`68`	+ fun `when`(vararg conditions: VisitableCondition<T>) =
	`69`	`+ SimpleCaseThenGatherer { thenValue ->`
	`70`	`+ whenConditions.add(ConditionBasedWhenCondition(conditions.asList(), thenValue))`
`78`	`71`	`}`
`79`	`72`
`80`		- fun `when`(firstValue: T, vararg subsequentValues: T, completer: SimpleCaseThenGatherer.() -> Unit) =
`81`		`- SimpleCaseThenGatherer().apply(completer).run {`
`82`		`- val allConditions = buildList {`
`83`		`- add(firstValue)`
`84`		`- addAll(subsequentValues)`
`85`		`- }`
`86`		`-`
`87`		`- whenConditions.add(BasicWhenCondition(allConditions, thenValue))`
	`73`	+ fun `when`(vararg values: T) =
	`74`	`+ SimpleCaseThenGatherer { thenValue ->`
	`75`	`+ whenConditions.add(BasicWhenCondition(values.asList(), thenValue))`
`88`	`76`	`}`
`89`	`77`
`90`		- override fun `else`(column: BasicColumn) {
	`78`	+ override infix fun `else`(column: BasicColumn) {
`91`	`79`	`this.elseValue = column`
`92`	`80`	`}`
`93`	`81`	`}`
`94`	`82`
`95`		`-class SimpleCaseThenGatherer: KThenDSL {`
`96`		`- internal var thenValue: BasicColumn? = null`
`97`		`- private set(value) {`
`98`		`- assertNull(field, "ERROR.41") //$NON-NLS-1$`
`99`		`- field = value`
`100`		`- }`
`101`		`-`
`102`		`- override fun then(column: BasicColumn) {`
`103`		`- thenValue = column`
	`83`	`+class SimpleCaseThenGatherer(private val consumer: (BasicColumn) -> Unit): KThenDSL {`
	`84`	`+ override infix fun then(column: BasicColumn) {`
	`85`	`+ consumer.invoke(column)`
`104`	`86`	`}`
`105`	`87`	`}`
`106`	`88`
`107`	`89`	`interface KThenDSL {`
`108`		`- fun then(value: String) {`
	`90`	`+ infix fun then(value: String) {`
`109`	`91`	`then(stringConstant(value))`
`110`	`92`	`}`
`111`	`93`
`112`		`- fun then(value: Boolean) {`
	`94`	`+ infix fun then(value: Boolean) {`
`113`	`95`	`then(constant<String>(value.toString()))`
`114`	`96`	`}`
`115`	`97`
`116`		`- fun then(value: Int) {`
	`98`	`+ infix fun then(value: Int) {`
`117`	`99`	`then(constant<String>(value.toString()))`
`118`	`100`	`}`
`119`	`101`
`120`		`- fun then(value: Long) {`
	`102`	`+ infix fun then(value: Long) {`
`121`	`103`	`then(constant<String>(value.toString()))`
`122`	`104`	`}`
`123`	`105`
`124`		`- fun then(value: Double) {`
	`106`	`+ infix fun then(value: Double) {`
`125`	`107`	`then(constant<String>(value.toString()))`
`126`	`108`	`}`
`127`	`109`
`128`		`- fun then(column: BasicColumn)`
	`110`	`+ infix fun then(column: BasicColumn)`
`129`	`111`	`}`
`130`	`112`
`131`	`113`	`interface KElseDSL {`
`132`		- fun `else`(value: String) {
	`114`	+ infix fun `else`(value: String) {
`133`	`115`	`else`(stringConstant(value))
`134`	`116`	`}`
`135`	`117`
`136`		- fun `else`(value: Boolean) {
	`118`	+ infix fun `else`(value: Boolean) {
`137`	`119`	`else`(constant<String>(value.toString()))
`138`	`120`	`}`
`139`	`121`
`140`		- fun `else`(value: Int) {
	`122`	+ infix fun `else`(value: Int) {
`141`	`123`	`else`(constant<String>(value.toString()))
`142`	`124`	`}`
`143`	`125`
`144`		- fun `else`(value: Long) {
	`126`	+ infix fun `else`(value: Long) {
`145`	`127`	`else`(constant<String>(value.toString()))
`146`	`128`	`}`
`147`	`129`
`148`		- fun `else`(value: Double) {
	`130`	+ infix fun `else`(value: Double) {
`149`	`131`	`else`(constant<String>(value.toString()))
`150`	`132`	`}`
`151`	`133`
`152`		- fun `else`(column: BasicColumn)
	`134`	+ infix fun `else`(column: BasicColumn)
`153`	`135`	`}`