Merge pull request #281 from jeffgbutler/rework-kotlin-select

Refactor Kotlin Select and Count DSL

Author: jeffgbutler

CHANGELOG.md

@@ -4,6 +4,33 @@ This log will detail notable changes to MyBatis Dynamic SQL. Full details are av
 
 ## Release 1.3.0 - Unreleased
 
+GitHub milestone: [https://github.com/mybatis/mybatis-dynamic-sql/issues?q=milestone%3A1.3.0+](https://github.com/mybatis/mybatis-dynamic-sql/issues?q=milestone%3A1.3.0+)
+
+### Breaking Change for Kotlin
+
+In this release the Kotlin support for `select` and `count` statements has been refactored. This will not impact code
+created by MyBatis generator. It will have an impact on Spring users as well as MyBatis users that coded joins or
+other queries directly in Kotlin. The difference is that the `from` clause has been moved inside the lambda for select
+and count statements.
+
+Previously, code looked like this:
+```kotlin
+   val selectStatement = select(foo).from(bar) {
+       where(id, isLessThan(3))
+   }
+```
+  
+The new code looks like this:
+```kotlin
+   val selectStatement = select(foo) {
+       from(bar)
+       where(id, isLessThan(3))
+   }
+```
+  
+This change makes the Kotlin DSL a bit more consistent and also makes it easier to implement sub-query support in the
+Kotlin DSL.
+
 ### Added
 
 - Added a new sort specification that is useful in selects with joins ([#269](https://github.com/mybatis/mybatis-dynamic-sql/pull/269))

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/AbstractWhereDSLExtensions.kt

@@ -22,7 +22,9 @@ import org.mybatis.dynamic.sql.where.AbstractWhereDSL
 typealias WhereApplier = AbstractWhereDSL<*>.() -> Unit
 
 fun <T, M : AbstractWhereDSL<M>> AbstractWhereDSL<M>.where(
-    column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver
+    column: BindableColumn<T>,
+    condition: VisitableCondition<T>,
+    collect: CriteriaReceiver
 ) =
     where(column, condition, collect(CriteriaCollector()).criteria)
 

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinBaseBuilders.kt

@@ -27,6 +27,7 @@ import org.mybatis.dynamic.sql.where.AbstractWhereDSL
 annotation class MyBatisDslMarker
 
 @MyBatisDslMarker
+@Suppress("TooManyFunctions")
 abstract class KotlinBaseBuilder<W : AbstractWhereDSL<W>, B : KotlinBaseBuilder<W, B>> {
     fun <T> where(column: BindableColumn<T>, condition: VisitableCondition<T>): B =
         applySelf {
@@ -63,6 +64,8 @@ abstract class KotlinBaseBuilder<W : AbstractWhereDSL<W>, B : KotlinBaseBuilder<
             getWhere().or(column, condition, collect)
         }
 
+    fun allRows() = self()
+
     protected fun applySelf(block: B.() -> Unit): B =
         self().apply { block() }
 
@@ -72,46 +75,47 @@ abstract class KotlinBaseBuilder<W : AbstractWhereDSL<W>, B : KotlinBaseBuilder<
 }
 
 abstract class KotlinBaseJoiningBuilder<T : AbstractQueryExpressionDSL<T, SelectModel>, W : AbstractWhereDSL<W>,
-        B : KotlinBaseJoiningBuilder<T, W, B>>
-    (private val dsl: AbstractQueryExpressionDSL<T, SelectModel>) : KotlinBaseBuilder<W, B>() {
+        B : KotlinBaseJoiningBuilder<T, W, B>> : KotlinBaseBuilder<W, B>() {
 
     fun join(table: SqlTable, receiver: JoinReceiver): B =
         applySelf {
-            dsl.join(table, receiver)
+            getDsl().join(table, receiver)
         }
 
     fun join(table: SqlTable, alias: String, receiver: JoinReceiver): B =
         applySelf {
-            dsl.join(table, alias, receiver)
+            getDsl().join(table, alias, receiver)
         }
 
     fun fullJoin(table: SqlTable, receiver: JoinReceiver): B =
         applySelf {
-            dsl.fullJoin(table, receiver)
+            getDsl().fullJoin(table, receiver)
         }
 
     fun fullJoin(table: SqlTable, alias: String, receiver: JoinReceiver): B =
         applySelf {
-            dsl.fullJoin(table, alias, receiver)
+            getDsl().fullJoin(table, alias, receiver)
         }
 
     fun leftJoin(table: SqlTable, receiver: JoinReceiver): B =
         applySelf {
-            dsl.leftJoin(table, receiver)
+            getDsl().leftJoin(table, receiver)
         }
 
     fun leftJoin(table: SqlTable, alias: String, receiver: JoinReceiver): B =
         applySelf {
-            dsl.leftJoin(table, alias, receiver)
+            getDsl().leftJoin(table, alias, receiver)
         }
 
     fun rightJoin(table: SqlTable, receiver: JoinReceiver): B =
         applySelf {
-            dsl.rightJoin(table, receiver)
+            getDsl().rightJoin(table, receiver)
         }
 
     fun rightJoin(table: SqlTable, alias: String, receiver: JoinReceiver): B =
         applySelf {
-            dsl.rightJoin(table, alias, receiver)
+            getDsl().rightJoin(table, alias, receiver)
         }
+
+    protected abstract fun getDsl(): AbstractQueryExpressionDSL<T, SelectModel>
 }

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinCountBuilder.kt

@@ -0,0 +1,67 @@
+/*
+ *    Copyright 2016-2020 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package org.mybatis.dynamic.sql.util.kotlin
+
+import org.mybatis.dynamic.sql.SqlTable
+import org.mybatis.dynamic.sql.select.CountDSL
+import org.mybatis.dynamic.sql.select.SelectModel
+import org.mybatis.dynamic.sql.util.Buildable
+
+typealias CountCompleter = KotlinCountBuilder.() -> Buildable<SelectModel>
+
+typealias CountColumnCompleter = KotlinCountColumnBuilder.() -> Buildable<SelectModel>
+
+class KotlinCountBuilder(private val dsl: CountDSL<SelectModel>) :
+    KotlinBaseJoiningBuilder<CountDSL<SelectModel>, CountDSL<SelectModel>.CountWhereBuilder, KotlinCountBuilder>(),
+    Buildable<SelectModel> {
+
+    override fun build(): SelectModel = getDsl().build()
+
+    override fun getWhere(): CountDSL<SelectModel>.CountWhereBuilder = getDsl().where()
+
+    override fun self() = this
+
+    override fun getDsl() = dsl
+}
+
+class KotlinCountColumnBuilder(private val fromGatherer: CountDSL.FromGatherer<SelectModel>) :
+    KotlinBaseJoiningBuilder<CountDSL<SelectModel>,
+            CountDSL<SelectModel>.CountWhereBuilder, KotlinCountColumnBuilder>(),
+    Buildable<SelectModel> {
+
+    private lateinit var dsl: CountDSL<SelectModel>
+
+    fun from(table: SqlTable) =
+        apply {
+            dsl = fromGatherer.from(table)
+        }
+
+    override fun build(): SelectModel = getDsl().build()
+
+    override fun getWhere(): CountDSL<SelectModel>.CountWhereBuilder = getDsl().where()
+
+    override fun self() = this
+
+    override fun getDsl(): CountDSL<SelectModel> {
+        try {
+            return dsl
+        } catch (e: UninitializedPropertyAccessException) {
+            throw UninitializedPropertyAccessException(
+                "You must specify a \"from\" clause before any other clauses in a count statement", e
+            )
+        }
+    }
+}

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinCountBuilders.kt

@@ -24,8 +24,6 @@ typealias DeleteCompleter = KotlinDeleteBuilder.() -> Buildable<DeleteModel>
 class KotlinDeleteBuilder(private val dsl: DeleteDSL<DeleteModel>) :
         KotlinBaseBuilder<DeleteDSL<DeleteModel>.DeleteWhereBuilder, KotlinDeleteBuilder>(), Buildable<DeleteModel> {
 
-    fun allRows() = this
-
     override fun build(): DeleteModel = dsl.build()
 
     override fun getWhere(): DeleteDSL<DeleteModel>.DeleteWhereBuilder = dsl.where()