Better Kotlin Pattern

Author: jeffgbutler

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

@@ -16,6 +16,7 @@
 package org.mybatis.dynamic.sql.util.kotlin
 
 import org.mybatis.dynamic.sql.BindableColumn
+import org.mybatis.dynamic.sql.SqlCriterion
 import org.mybatis.dynamic.sql.SqlTable
 import org.mybatis.dynamic.sql.VisitableCondition
 import org.mybatis.dynamic.sql.select.AbstractQueryExpressionDSL
@@ -31,39 +32,39 @@ typealias WhereApplier = AbstractWhereDSL<*>.() -> Unit
 @MyBatisDslMarker
 @Suppress("TooManyFunctions")
 abstract class KotlinBaseBuilder<D: AbstractWhereSupportingDSL<*>, B: KotlinBaseBuilder<D, B>> {
-    fun <T> where(column: BindableColumn<T>, condition: VisitableCondition<T>): B =
+    fun <T> where(column: BindableColumn<T>, condition: VisitableCondition<T>) =
         applyToWhere {
             where(column, condition)
         }
 
-    fun <T> where(column: BindableColumn<T>, condition: VisitableCondition<T>, subCriteria: CriteriaReceiver): B =
-        applyToWhere {
-            where(column, condition, CriteriaCollector().apply(subCriteria).criteria)
+    fun <T> where(column: BindableColumn<T>, condition: VisitableCondition<T>, subCriteria: CriteriaReceiver) =
+        applyToWhere(subCriteria) { sq ->
+            where(column, condition, sq)
         }
 
-    fun applyWhere(whereApplier: WhereApplier): B =
+    fun applyWhere(whereApplier: WhereApplier) =
         applyToWhere {
             applyWhere(whereApplier)
         }
 
-    fun <T> and(column: BindableColumn<T>, condition: VisitableCondition<T>): B =
+    fun <T> and(column: BindableColumn<T>, condition: VisitableCondition<T>) =
         applyToWhere {
             and(column, condition)
         }
 
-    fun <T> and(column: BindableColumn<T>, condition: VisitableCondition<T>, subCriteria: CriteriaReceiver): B =
-        applyToWhere {
-            and(column, condition, CriteriaCollector().apply(subCriteria).criteria)
+    fun <T> and(column: BindableColumn<T>, condition: VisitableCondition<T>, subCriteria: CriteriaReceiver) =
+        applyToWhere(subCriteria) { sq ->
+            and(column, condition, sq)
         }
 
     fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>) =
         applyToWhere {
             or(column, condition)
         }
 
-    fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>, subCriteria: CriteriaReceiver): B =
-        applyToWhere {
-            or(column, condition, CriteriaCollector().apply(subCriteria).criteria)
+    fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>, subCriteria: CriteriaReceiver) =
+        applyToWhere(subCriteria) { sq ->
+            or(column, condition, sq)
         }
 
     fun allRows() = self()
@@ -73,120 +74,106 @@ abstract class KotlinBaseBuilder<D: AbstractWhereSupportingDSL<*>, B: KotlinBase
         return self()
     }
 
+    private fun applyToWhere(
+        subCriteria: CriteriaReceiver,
+        block: AbstractWhereDSL<*>.(List<SqlCriterion<*>>) -> Unit
+    ): B {
+        getDsl().where().block(CriteriaCollector().apply(subCriteria).criteria)
+        return self()
+    }
+
     protected abstract fun self(): B
 
     protected abstract fun getDsl(): D
 }
 
 @Suppress("TooManyFunctions")
-abstract class KotlinBaseJoiningBuilder<D: AbstractQueryExpressionDSL<*, *, *>, B: KotlinBaseJoiningBuilder<D, B>> : KotlinBaseBuilder<D, B>() {
+abstract class KotlinBaseJoiningBuilder<D: AbstractQueryExpressionDSL<*, *, *>, B: KotlinBaseJoiningBuilder<D, B>>
+    : KotlinBaseBuilder<D, B>() {
 
-    fun join(table: SqlTable, joinCriteria: JoinReceiver): B =
-        buildAndApply(joinCriteria) {
-            applyToDsl {
-                join(table, it.onJoinCriterion, it.andJoinCriteria)
-            }
+    fun join(table: SqlTable, joinCriteria: JoinReceiver) =
+        applyToDsl(joinCriteria) { jc ->
+            join(table, jc.onJoinCriterion, jc.andJoinCriteria)
         }
 
-    fun join(table: SqlTable, alias: String, joinCriteria: JoinReceiver): B =
-        buildAndApply(joinCriteria) {
-            applyToDsl {
-                join(table, alias, it.onJoinCriterion, it.andJoinCriteria)
-            }
+    fun join(table: SqlTable, alias: String, joinCriteria: JoinReceiver) =
+        applyToDsl(joinCriteria) { jc ->
+            join(table, alias, jc.onJoinCriterion, jc.andJoinCriteria)
         }
 
     fun join(
         subQuery: KotlinQualifiedSubQueryBuilder.() -> Unit,
         joinCriteria: JoinReceiver
-    ): B =
-        buildAndApply(joinCriteria) {
-            val builder = KotlinQualifiedSubQueryBuilder().apply(subQuery)
-            applyToDsl {
-                join(builder, builder.correlationName, it.onJoinCriterion, it.andJoinCriteria)
-            }
+    ) =
+        applyToDsl(subQuery, joinCriteria) { sq, jc ->
+            join(sq, sq.correlationName, jc.onJoinCriterion, jc.andJoinCriteria)
         }
 
-    fun fullJoin(table: SqlTable, joinCriteria: JoinReceiver): B =
-        buildAndApply(joinCriteria) {
-            applyToDsl {
-                fullJoin(table, it.onJoinCriterion, it.andJoinCriteria)
-            }
+    fun fullJoin(table: SqlTable, joinCriteria: JoinReceiver) =
+        applyToDsl(joinCriteria) { jc ->
+            fullJoin(table, jc.onJoinCriterion, jc.andJoinCriteria)
         }
 
-    fun fullJoin(table: SqlTable, alias: String, joinCriteria: JoinReceiver): B =
-        buildAndApply(joinCriteria) {
-            applyToDsl {
-                fullJoin(table, alias, it.onJoinCriterion, it.andJoinCriteria)
-            }
+    fun fullJoin(table: SqlTable, alias: String, joinCriteria: JoinReceiver) =
+        applyToDsl(joinCriteria) { jc ->
+            fullJoin(table, alias, jc.onJoinCriterion, jc.andJoinCriteria)
         }
 
     fun fullJoin(
         subQuery: KotlinQualifiedSubQueryBuilder.() -> Unit,
         joinCriteria: JoinReceiver
-    ): B =
-        buildAndApply(joinCriteria) {
-            val builder = KotlinQualifiedSubQueryBuilder().apply(subQuery)
-            applyToDsl {
-                fullJoin(builder, builder.correlationName, it.onJoinCriterion, it.andJoinCriteria)
-            }
+    ) =
+        applyToDsl(subQuery, joinCriteria) { sq, jc ->
+            fullJoin(sq, sq.correlationName, jc.onJoinCriterion, jc.andJoinCriteria)
         }
 
-    fun leftJoin(table: SqlTable, joinCriteria: JoinReceiver): B =
-        buildAndApply(joinCriteria) {
-            applyToDsl {
-                leftJoin(table, it.onJoinCriterion, it.andJoinCriteria)
-            }
+    fun leftJoin(table: SqlTable, joinCriteria: JoinReceiver) =
+        applyToDsl(joinCriteria) { jc ->
+            leftJoin(table, jc.onJoinCriterion, jc.andJoinCriteria)
         }
 
-    fun leftJoin(table: SqlTable, alias: String, joinCriteria: JoinReceiver): B =
-        buildAndApply(joinCriteria) {
-            applyToDsl {
-                leftJoin(table, alias, it.onJoinCriterion, it.andJoinCriteria)
-            }
+    fun leftJoin(table: SqlTable, alias: String, joinCriteria: JoinReceiver) =
+        applyToDsl(joinCriteria) { jc ->
+            leftJoin(table, alias, jc.onJoinCriterion, jc.andJoinCriteria)
         }
 
     fun leftJoin(
         subQuery: KotlinQualifiedSubQueryBuilder.() -> Unit,
         joinCriteria: JoinReceiver
-    ): B =
-        buildAndApply(joinCriteria) {
-            val builder = KotlinQualifiedSubQueryBuilder().apply(subQuery)
-            applyToDsl {
-                leftJoin(builder, builder.correlationName, it.onJoinCriterion, it.andJoinCriteria)
-            }
+    ) =
+        applyToDsl(subQuery, joinCriteria) { sq, jc ->
+            leftJoin(sq, sq.correlationName, jc.onJoinCriterion, jc.andJoinCriteria)
         }
 
-    fun rightJoin(table: SqlTable, joinCriteria: JoinReceiver): B =
-        buildAndApply(joinCriteria) {
-            applyToDsl {
-                rightJoin(table, it.onJoinCriterion, it.andJoinCriteria)
-            }
+    fun rightJoin(table: SqlTable, joinCriteria: JoinReceiver) =
+        applyToDsl(joinCriteria) { jc ->
+            rightJoin(table, jc.onJoinCriterion, jc.andJoinCriteria)
         }
 
-    fun rightJoin(table: SqlTable, alias: String, joinCriteria: JoinReceiver): B =
-        buildAndApply(joinCriteria) {
-            applyToDsl {
-                rightJoin(table, alias, it.onJoinCriterion, it.andJoinCriteria)
-            }
+    fun rightJoin(table: SqlTable, alias: String, joinCriteria: JoinReceiver) =
+        applyToDsl(joinCriteria) { jc ->
+            rightJoin(table, alias, jc.onJoinCriterion, jc.andJoinCriteria)
         }
 
     fun rightJoin(
         subQuery: KotlinQualifiedSubQueryBuilder.() -> Unit,
         joinCriteria: JoinReceiver
-    ): B =
-        buildAndApply(joinCriteria) {
-            val builder = KotlinQualifiedSubQueryBuilder().apply(subQuery)
-            applyToDsl {
-                rightJoin(builder, builder.correlationName, it.onJoinCriterion, it.andJoinCriteria)
-            }
+    ) =
+        applyToDsl(subQuery, joinCriteria) { sq, jc ->
+            rightJoin(sq, sq.correlationName, jc.onJoinCriterion, jc.andJoinCriteria)
         }
 
-    private fun buildAndApply(joinCriteria: JoinReceiver, block: (JoinCollector) -> B): B {
-        return block(JoinCollector().apply(joinCriteria))
+    private fun applyToDsl(joinCriteria: JoinReceiver, applyJoin: D.(JoinCollector) -> Unit): B {
+        getDsl().applyJoin(JoinCollector().apply(joinCriteria))
+        return self()
     }
 
-    private fun applyToDsl(block: D.() -> Unit): B {
-        getDsl().apply(block)
+    private fun applyToDsl(
+        subQuery: KotlinQualifiedSubQueryBuilder.() -> Unit,
+        joinCriteria: JoinReceiver,
+        applyJoin: D.(KotlinQualifiedSubQueryBuilder, JoinCollector) -> Unit
+    ): B {
+        getDsl().applyJoin(KotlinQualifiedSubQueryBuilder().apply(subQuery), JoinCollector().apply(joinCriteria))
         return self()
     }
 }