Make the receivers more typical for Kotlin

Author: jeffgbutler

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

@@ -19,7 +19,7 @@ import org.mybatis.dynamic.sql.BindableColumn
 import org.mybatis.dynamic.sql.SqlCriterion
 import org.mybatis.dynamic.sql.VisitableCondition
 
-typealias CriteriaReceiver = CriteriaCollector.() -> CriteriaCollector
+typealias CriteriaReceiver = CriteriaCollector.() -> Unit
 
 @MyBatisDslMarker
 class CriteriaCollector {
@@ -38,13 +38,13 @@ class CriteriaCollector {
     fun <T> and(
         column: BindableColumn<T>,
         condition: VisitableCondition<T>,
-        collect: CriteriaReceiver
+        criteriaReceiver: CriteriaReceiver
     ) =
         apply {
             criteria.add(
                 SqlCriterion.withColumn(column)
                     .withCondition(condition)
-                    .withSubCriteria(collect(CriteriaCollector()).criteria)
+                    .withSubCriteria(CriteriaCollector().apply(criteriaReceiver).criteria)
                     .withConnector("and")
                     .build()
             )
@@ -63,13 +63,13 @@ class CriteriaCollector {
     fun <T> or(
         column: BindableColumn<T>,
         condition: VisitableCondition<T>,
-        collect: CriteriaReceiver
+        criteriaReceiver: CriteriaReceiver
     ) =
         apply {
             criteria.add(
                 SqlCriterion.withColumn(column)
                     .withCondition(condition)
-                    .withSubCriteria(collect(CriteriaCollector()).criteria)
+                    .withSubCriteria(CriteriaCollector().apply(criteriaReceiver).criteria)
                     .withConnector("or")
                     .build()
             )

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

@@ -19,7 +19,7 @@ import org.mybatis.dynamic.sql.BasicColumn
 import org.mybatis.dynamic.sql.select.join.JoinCondition
 import org.mybatis.dynamic.sql.select.join.JoinCriterion
 
-typealias JoinReceiver = JoinCollector.() -> JoinCollector
+typealias JoinReceiver = JoinCollector.() -> Unit
 
 @MyBatisDslMarker
 class JoinCollector {

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

@@ -38,7 +38,7 @@ abstract class KotlinBaseBuilder<W : AbstractWhereDSL<W>, B : KotlinBaseBuilder<
 
     fun <T> where(column: BindableColumn<T>, condition: VisitableCondition<T>, subCriteria: CriteriaReceiver): B =
         applySelf {
-            getWhere().where(column, condition, subCriteria(CriteriaCollector()).criteria)
+            getWhere().where(column, condition, CriteriaCollector().apply(subCriteria).criteria)
         }
 
     fun applyWhere(whereApplier: WhereApplier): B =
@@ -53,7 +53,7 @@ abstract class KotlinBaseBuilder<W : AbstractWhereDSL<W>, B : KotlinBaseBuilder<
 
     fun <T> and(column: BindableColumn<T>, condition: VisitableCondition<T>, subCriteria: CriteriaReceiver): B =
         applySelf {
-            getWhere().and(column, condition, subCriteria(CriteriaCollector()).criteria)
+            getWhere().and(column, condition, CriteriaCollector().apply(subCriteria).criteria)
         }
 
     fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>): B =
@@ -63,7 +63,7 @@ abstract class KotlinBaseBuilder<W : AbstractWhereDSL<W>, B : KotlinBaseBuilder<
 
     fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>, subCriteria: CriteriaReceiver): B =
         applySelf {
-            getWhere().or(column, condition, subCriteria(CriteriaCollector()).criteria)
+            getWhere().or(column, condition, CriteriaCollector().apply(subCriteria).criteria)
         }
 
     fun allRows() = self()
@@ -91,11 +91,11 @@ abstract class KotlinBaseJoiningBuilder<T : AbstractQueryExpressionDSL<T, Select
         }
 
     fun join(
-        subQuery: KotlinQualifiedSubQueryBuilder.() -> KotlinQualifiedSubQueryBuilder,
+        subQuery: KotlinQualifiedSubQueryBuilder.() -> Unit,
         joinCriteria: JoinReceiver
     ) =
         applyJoin(joinCriteria) {
-            val builder = subQuery(KotlinQualifiedSubQueryBuilder())
+            val builder = KotlinQualifiedSubQueryBuilder().apply(subQuery)
             getDsl().join(builder, builder.correlationName, it.onJoinCriterion, it.andJoinCriteria)
         }
 
@@ -110,11 +110,11 @@ abstract class KotlinBaseJoiningBuilder<T : AbstractQueryExpressionDSL<T, Select
         }
 
     fun fullJoin(
-        subQuery: KotlinQualifiedSubQueryBuilder.() -> KotlinQualifiedSubQueryBuilder,
+        subQuery: KotlinQualifiedSubQueryBuilder.() -> Unit,
         joinCriteria: JoinReceiver
     ) =
         applyJoin(joinCriteria) {
-            val builder = subQuery(KotlinQualifiedSubQueryBuilder())
+            val builder = KotlinQualifiedSubQueryBuilder().apply(subQuery)
             getDsl().fullJoin(builder, builder.correlationName, it.onJoinCriterion, it.andJoinCriteria)
         }
 
@@ -129,11 +129,11 @@ abstract class KotlinBaseJoiningBuilder<T : AbstractQueryExpressionDSL<T, Select
         }
 
     fun leftJoin(
-        subQuery: KotlinQualifiedSubQueryBuilder.() -> KotlinQualifiedSubQueryBuilder,
+        subQuery: KotlinQualifiedSubQueryBuilder.() -> Unit,
         joinCriteria: JoinReceiver
     ) =
         applyJoin(joinCriteria) {
-            val builder = subQuery(KotlinQualifiedSubQueryBuilder())
+            val builder = KotlinQualifiedSubQueryBuilder().apply(subQuery)
             getDsl().leftJoin(builder, builder.correlationName, it.onJoinCriterion, it.andJoinCriteria)
         }
 
@@ -148,17 +148,17 @@ abstract class KotlinBaseJoiningBuilder<T : AbstractQueryExpressionDSL<T, Select
         }
 
     fun rightJoin(
-        subQuery: KotlinQualifiedSubQueryBuilder.() -> KotlinQualifiedSubQueryBuilder,
+        subQuery: KotlinQualifiedSubQueryBuilder.() -> Unit,
         joinCriteria: JoinReceiver
     ) =
         applyJoin(joinCriteria) {
-            val builder = subQuery(KotlinQualifiedSubQueryBuilder())
+            val builder = KotlinQualifiedSubQueryBuilder().apply(subQuery)
             getDsl().rightJoin(builder, builder.correlationName, it.onJoinCriterion, it.andJoinCriteria)
         }
 
     private fun applyJoin(joinCriteria: JoinReceiver, block: (JoinCollector) -> Unit) =
         applySelf {
-            joinCriteria(JoinCollector()).also(block)
+            JoinCollector().apply(joinCriteria).apply(block)
         }
 
     protected abstract fun getDsl(): AbstractQueryExpressionDSL<T, SelectModel>

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

@@ -24,26 +24,26 @@ import org.mybatis.dynamic.sql.where.condition.IsLessThanWithSubselect
 import org.mybatis.dynamic.sql.where.condition.IsNotEqualToWithSubselect
 import org.mybatis.dynamic.sql.where.condition.IsNotInWithSubselect
 
-fun <T> isEqualTo(subQuery: KotlinSubQueryBuilder.() -> KotlinSubQueryBuilder) =
-    IsEqualToWithSubselect.of<T>(subQuery(KotlinSubQueryBuilder()))
+fun <T> isEqualTo(subQuery: KotlinSubQueryBuilder.() -> Unit) =
+    IsEqualToWithSubselect.of<T>(KotlinSubQueryBuilder().apply(subQuery))
 
-fun <T> isNotEqualTo(subQuery: KotlinSubQueryBuilder.() -> KotlinSubQueryBuilder) =
-    IsNotEqualToWithSubselect.of<T>(subQuery(KotlinSubQueryBuilder()))
+fun <T> isNotEqualTo(subQuery: KotlinSubQueryBuilder.() -> Unit) =
+    IsNotEqualToWithSubselect.of<T>(KotlinSubQueryBuilder().apply(subQuery))
 
-fun <T> isIn(subQuery: KotlinSubQueryBuilder.() -> KotlinSubQueryBuilder) =
-    IsInWithSubselect.of<T>(subQuery(KotlinSubQueryBuilder()))
+fun <T> isIn(subQuery: KotlinSubQueryBuilder.() -> Unit) =
+    IsInWithSubselect.of<T>(KotlinSubQueryBuilder().apply(subQuery))
 
-fun <T> isNotIn(subQuery: KotlinSubQueryBuilder.() -> KotlinSubQueryBuilder) =
-    IsNotInWithSubselect.of<T>(subQuery(KotlinSubQueryBuilder()))
+fun <T> isNotIn(subQuery: KotlinSubQueryBuilder.() -> Unit) =
+    IsNotInWithSubselect.of<T>(KotlinSubQueryBuilder().apply(subQuery))
 
-fun <T> isGreaterThan(subQuery: KotlinSubQueryBuilder.() -> KotlinSubQueryBuilder) =
-    IsGreaterThanWithSubselect.of<T>(subQuery(KotlinSubQueryBuilder()))
+fun <T> isGreaterThan(subQuery: KotlinSubQueryBuilder.() -> Unit) =
+    IsGreaterThanWithSubselect.of<T>(KotlinSubQueryBuilder().apply(subQuery))
 
-fun <T> isGreaterThanOrEqualTo(subQuery: KotlinSubQueryBuilder.() -> KotlinSubQueryBuilder) =
-    IsGreaterThanOrEqualToWithSubselect.of<T>(subQuery(KotlinSubQueryBuilder()))
+fun <T> isGreaterThanOrEqualTo(subQuery: KotlinSubQueryBuilder.() -> Unit) =
+    IsGreaterThanOrEqualToWithSubselect.of<T>(KotlinSubQueryBuilder().apply(subQuery))
 
-fun <T> isLessThan(subQuery: KotlinSubQueryBuilder.() -> KotlinSubQueryBuilder) =
-    IsLessThanWithSubselect.of<T>(subQuery(KotlinSubQueryBuilder()))
+fun <T> isLessThan(subQuery: KotlinSubQueryBuilder.() -> Unit) =
+    IsLessThanWithSubselect.of<T>(KotlinSubQueryBuilder().apply(subQuery))
 
-fun <T> isLessThanOrEqualTo(subQuery: KotlinSubQueryBuilder.() -> KotlinSubQueryBuilder) =
-    IsLessThanOrEqualToWithSubselect.of<T>(subQuery(KotlinSubQueryBuilder()))
+fun <T> isLessThanOrEqualTo(subQuery: KotlinSubQueryBuilder.() -> Unit) =
+    IsLessThanOrEqualToWithSubselect.of<T>(KotlinSubQueryBuilder().apply(subQuery))

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

@@ -20,7 +20,7 @@ import org.mybatis.dynamic.sql.select.CountDSL
 import org.mybatis.dynamic.sql.select.SelectModel
 import org.mybatis.dynamic.sql.util.Buildable
 
-typealias CountCompleter = KotlinCountBuilder.() -> KotlinCountBuilder
+typealias CountCompleter = KotlinCountBuilder.() -> Unit
 
 class KotlinCountBuilder(private val fromGatherer: CountDSL.FromGatherer<SelectModel>) :
     KotlinBaseJoiningBuilder<CountDSL<SelectModel>,

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

@@ -19,7 +19,7 @@ import org.mybatis.dynamic.sql.delete.DeleteDSL
 import org.mybatis.dynamic.sql.delete.DeleteModel
 import org.mybatis.dynamic.sql.util.Buildable
 
-typealias DeleteCompleter = KotlinDeleteBuilder.() -> KotlinDeleteBuilder
+typealias DeleteCompleter = KotlinDeleteBuilder.() -> Unit
 
 class KotlinDeleteBuilder(private val dsl: DeleteDSL<DeleteModel>) :
         KotlinBaseBuilder<DeleteDSL<DeleteModel>.DeleteWhereBuilder, KotlinDeleteBuilder>(), Buildable<DeleteModel> {

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

@@ -16,22 +16,16 @@
 package org.mybatis.dynamic.sql.util.kotlin
 
 import org.mybatis.dynamic.sql.insert.BatchInsertDSL
-import org.mybatis.dynamic.sql.insert.BatchInsertModel
 import org.mybatis.dynamic.sql.insert.GeneralInsertDSL
-import org.mybatis.dynamic.sql.insert.GeneralInsertModel
 import org.mybatis.dynamic.sql.insert.InsertDSL
-import org.mybatis.dynamic.sql.insert.InsertModel
 import org.mybatis.dynamic.sql.insert.MultiRowInsertDSL
-import org.mybatis.dynamic.sql.insert.MultiRowInsertModel
-import org.mybatis.dynamic.sql.util.Buildable
 
-typealias GeneralInsertCompleter = @MyBatisDslMarker GeneralInsertDSL.() -> Buildable<GeneralInsertModel>
+typealias GeneralInsertCompleter = @MyBatisDslMarker GeneralInsertDSL.() -> Unit
 
-typealias InsertCompleter<T> = @MyBatisDslMarker InsertDSL<T>.() -> Buildable<InsertModel<T>>
+typealias InsertCompleter<T> = @MyBatisDslMarker InsertDSL<T>.() -> Unit
 
-typealias MultiRowInsertCompleter<T> = @MyBatisDslMarker MultiRowInsertDSL<T>.() -> Buildable<MultiRowInsertModel<T>>
+typealias MultiRowInsertCompleter<T> = @MyBatisDslMarker MultiRowInsertDSL<T>.() -> Unit
 
-typealias BatchInsertCompleter<T> = @MyBatisDslMarker BatchInsertDSL<T>.() -> Buildable<BatchInsertModel<T>>
+typealias BatchInsertCompleter<T> = @MyBatisDslMarker BatchInsertDSL<T>.() -> Unit
 
-typealias InsertSelectCompleter =
-        @MyBatisDslMarker KotlinInsertSelectSubQueryBuilder.() -> KotlinInsertSelectSubQueryBuilder
+typealias InsertSelectCompleter = @MyBatisDslMarker KotlinInsertSelectSubQueryBuilder.() -> Unit

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

@@ -21,6 +21,7 @@ import org.mybatis.dynamic.sql.SqlTable
 import org.mybatis.dynamic.sql.insert.BatchInsertDSL
 import org.mybatis.dynamic.sql.insert.GeneralInsertDSL
 import org.mybatis.dynamic.sql.insert.InsertDSL
+import org.mybatis.dynamic.sql.insert.InsertSelectModel
 import org.mybatis.dynamic.sql.insert.MultiRowInsertDSL
 
 /**
@@ -32,51 +33,51 @@ import org.mybatis.dynamic.sql.insert.MultiRowInsertDSL
 @Suppress("TooManyFunctions")
 object KotlinModelBuilderFunctions {
     fun count(column: BasicColumn, completer: CountCompleter) =
-        completer(KotlinCountBuilder(SqlBuilder.countColumn(column))).build()
+        KotlinCountBuilder(SqlBuilder.countColumn(column)).apply(completer).build()
 
     fun countDistinct(column: BasicColumn, completer: CountCompleter) =
-        completer(KotlinCountBuilder(SqlBuilder.countDistinctColumn(column))).build()
+        KotlinCountBuilder(SqlBuilder.countDistinctColumn(column)).apply(completer).build()
 
     fun countFrom(table: SqlTable, completer: CountCompleter) =
-        with(KotlinCountBuilder(SqlBuilder.countColumn(SqlBuilder.constant<Long>("*")))) {
-            completer(from(table)).build()
-        }
+        KotlinCountBuilder(SqlBuilder.countColumn(SqlBuilder.constant<Long>("*")))
+            .from(table).apply(completer).build()
 
     fun deleteFrom(table: SqlTable, completer: DeleteCompleter) =
-        completer(KotlinDeleteBuilder(SqlBuilder.deleteFrom(table))).build()
+        KotlinDeleteBuilder(SqlBuilder.deleteFrom(table)).apply(completer).build()
 
     fun insertInto(table: SqlTable, completer: GeneralInsertCompleter) =
-        completer(GeneralInsertDSL.insertInto(table)).build()
+        GeneralInsertDSL.insertInto(table).apply(completer).build()
 
-    fun insertSelect(table: SqlTable, completer: InsertSelectCompleter) =
-        with(completer(KotlinInsertSelectSubQueryBuilder())) {
-            SqlBuilder.insertInto(table)
+    fun insertSelect(table: SqlTable, completer: InsertSelectCompleter): InsertSelectModel {
+        with(KotlinInsertSelectSubQueryBuilder().apply(completer)) {
+            return SqlBuilder.insertInto(table)
                 .withColumnList(columnList)
                 .withSelectStatement(this)
                 .build()
         }
+    }
 
     fun <T> BatchInsertDSL.IntoGatherer<T>.into(table: SqlTable, completer: BatchInsertCompleter<T>) =
-        completer(into(table)).build()
+        into(table).also(completer).build()
 
     fun <T> InsertDSL.IntoGatherer<T>.into(table: SqlTable, completer: InsertCompleter<T>) =
-        completer(into(table)).build()
+        into(table).apply(completer).build()
 
     fun <T> MultiRowInsertDSL.IntoGatherer<T>.into(table: SqlTable, completer: MultiRowInsertCompleter<T>) =
-        completer(into(table)).build()
+        into(table).apply(completer).build()
 
     fun select(vararg columns: BasicColumn, completer: SelectCompleter) =
         select(columns.asList(), completer)
 
     fun select(columns: List<BasicColumn>, completer: SelectCompleter) =
-        completer(KotlinSelectBuilder(SqlBuilder.select(columns))).build()
+        KotlinSelectBuilder(SqlBuilder.select(columns)).apply(completer).build()
 
     fun selectDistinct(vararg columns: BasicColumn, completer: SelectCompleter) =
         selectDistinct(columns.asList(), completer)
 
     fun selectDistinct(columns: List<BasicColumn>, completer: SelectCompleter) =
-        completer(KotlinSelectBuilder(SqlBuilder.selectDistinct(columns))).build()
+        KotlinSelectBuilder(SqlBuilder.selectDistinct(columns)).apply(completer).build()
 
     fun update(table: SqlTable, completer: UpdateCompleter) =
-        completer(KotlinUpdateBuilder(SqlBuilder.update(table))).build()
+        KotlinUpdateBuilder(SqlBuilder.update(table)).apply(completer).build()
 }

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

@@ -22,7 +22,7 @@ import org.mybatis.dynamic.sql.select.SelectModel
 import org.mybatis.dynamic.sql.util.Buildable
 import org.mybatis.dynamic.sql.select.QueryExpressionDSL
 
-typealias SelectCompleter = KotlinSelectBuilder.() -> KotlinSelectBuilder
+typealias SelectCompleter = KotlinSelectBuilder.() -> Unit
 
 @Suppress("TooManyFunctions")
 class KotlinSelectBuilder(private val fromGatherer: QueryExpressionDSL.FromGatherer<SelectModel>) :
@@ -42,9 +42,9 @@ class KotlinSelectBuilder(private val fromGatherer: QueryExpressionDSL.FromGathe
             dsl = fromGatherer.from(table, alias)
         }
 
-    fun from(subQuery: KotlinQualifiedSubQueryBuilder.() -> KotlinQualifiedSubQueryBuilder) =
+    fun from(subQuery: KotlinQualifiedSubQueryBuilder.() -> Unit) =
         apply {
-            val builder = subQuery(KotlinQualifiedSubQueryBuilder())
+            val builder = KotlinQualifiedSubQueryBuilder().apply(subQuery)
             dsl = fromGatherer.from(builder, builder.correlationName)
         }
 

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

@@ -30,15 +30,15 @@ sealed class KotlinBaseSubQueryBuilder<T : KotlinBaseSubQueryBuilder<T>> : Build
 
     fun select(selectList: List<BasicColumn>, completer: SelectCompleter) =
         applySelf {
-            selectBuilder = completer(KotlinSelectBuilder(SqlBuilder.select(selectList)))
+            selectBuilder = KotlinSelectBuilder(SqlBuilder.select(selectList)).apply(completer)
         }
 
     fun selectDistinct(vararg selectList: BasicColumn, completer: SelectCompleter) =
         selectDistinct(selectList.toList(), completer)
 
     fun selectDistinct(selectList: List<BasicColumn>, completer: SelectCompleter) =
         applySelf {
-            selectBuilder = completer(KotlinSelectBuilder(SqlBuilder.selectDistinct(selectList)))
+            selectBuilder = KotlinSelectBuilder(SqlBuilder.selectDistinct(selectList)).apply(completer)
         }
 
     override fun build() = selectBuilder.build()