Fix for Kotlin

This change removes the old extension methods in favor of builder classes. This is important because there was a possibility of incorrect code generating if the wrong imports were used. The old method had such highly overloaded methods names that the wrong method could have easily been specified which would cause unpredictable results.

Author: jeffgbutler

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

@@ -16,36 +16,113 @@
 package org.mybatis.dynamic.sql.util.kotlin
 
 import org.mybatis.dynamic.sql.BindableColumn
+import org.mybatis.dynamic.sql.SqlTable
 import org.mybatis.dynamic.sql.VisitableCondition
 import org.mybatis.dynamic.sql.select.CountDSL
 import org.mybatis.dynamic.sql.select.SelectModel
-import org.mybatis.dynamic.sql.util.Buildable
 
-typealias CountCompleter = CountDSL<SelectModel>.() -> Buildable<SelectModel>
+typealias CountCompleter = KotlinCountBuilder.() -> KotlinCountBuilder
 
-fun <T> CountDSL<SelectModel>.where(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
-    apply {
-        where().where(column, condition, collect)
-    }
+class KotlinCountBuilder(val dsl: CountDSL<SelectModel>) {
+    fun join(table: SqlTable, receiver: JoinReceiver) =
+            apply {
+                val collector = JoinCollector()
+                receiver(collector)
+                dsl.join(table, collector.onJoinCriterion, collector.andJoinCriteria)
+            }
 
-fun <T> CountDSL<SelectModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>) =
-    apply {
-        where().and(column, condition)
-    }
+    fun join(table: SqlTable, alias: String, receiver: JoinReceiver) =
+            apply {
+                val collector = JoinCollector()
+                receiver(collector)
+                dsl.join(table, alias, collector.onJoinCriterion, collector.andJoinCriteria)
+            }
 
-fun <T> CountDSL<SelectModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
-    apply {
-        where().and(column, condition, collect)
-    }
+    fun fullJoin(table: SqlTable, receiver: JoinReceiver) =
+            apply {
+                val collector = JoinCollector()
+                receiver(collector)
+                dsl.fullJoin(table, collector.onJoinCriterion, collector.andJoinCriteria)
+            }
 
-fun <T> CountDSL<SelectModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>) =
-    apply {
-        where().or(column, condition)
-    }
+    fun fullJoin(table: SqlTable, alias: String, receiver: JoinReceiver) =
+            apply {
+                val collector = JoinCollector()
+                receiver(collector)
+                dsl.fullJoin(table, alias, collector.onJoinCriterion, collector.andJoinCriteria)
+            }
 
-fun <T> CountDSL<SelectModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
-    apply {
-        where().or(column, condition, collect)
-    }
+    fun leftJoin(table: SqlTable, receiver: JoinReceiver) =
+            apply {
+                val collector = JoinCollector()
+                receiver(collector)
+                dsl.leftJoin(table, collector.onJoinCriterion, collector.andJoinCriteria)
+            }
 
-fun CountDSL<SelectModel>.allRows() = this as Buildable<SelectModel>
+    fun leftJoin(table: SqlTable, alias: String, receiver: JoinReceiver) =
+            apply {
+                val collector = JoinCollector()
+                receiver(collector)
+                dsl.leftJoin(table, alias, collector.onJoinCriterion, collector.andJoinCriteria)
+            }
+
+    fun rightJoin(table: SqlTable, receiver: JoinReceiver) =
+            apply {
+                val collector = JoinCollector()
+                receiver(collector)
+                dsl.rightJoin(table, collector.onJoinCriterion, collector.andJoinCriteria)
+            }
+
+    fun rightJoin(table: SqlTable, alias: String, receiver: JoinReceiver) =
+            apply {
+                val collector = JoinCollector()
+                receiver(collector)
+                dsl.rightJoin(table, alias, collector.onJoinCriterion, collector.andJoinCriteria)
+            }
+
+    fun <T> where(column: BindableColumn<T>, condition: VisitableCondition<T>) =
+            apply {
+                dsl.where(column, condition)
+            }
+
+    fun <T> where(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+            apply {
+                val collector = CriteriaCollector()
+                collect(collector)
+                // TODO...awkward
+                dsl.where(column, condition, *collector.criteria.toTypedArray())
+            }
+
+    fun applyWhere(whereApplier: WhereApplier) =
+            apply {
+                dsl.applyWhere(whereApplier)
+            }
+
+    fun <T> and(column: BindableColumn<T>, condition: VisitableCondition<T>) =
+            apply {
+                dsl.where().and(column, condition)
+            }
+
+    fun <T> and(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+            apply {
+                val collector = CriteriaCollector()
+                collect(collector)
+                // TODO...awkward
+                dsl.where().and(column, condition, *collector.criteria.toTypedArray())
+            }
+
+    fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>) =
+            apply {
+                dsl.where().or(column, condition)
+            }
+
+    fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+            apply {
+                val collector = CriteriaCollector()
+                collect(collector)
+                // TODO...awkward
+                dsl.where().or(column, condition, *collector.criteria.toTypedArray())
+            }
+
+    fun allRows() = this
+}

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

@@ -19,33 +19,53 @@ import org.mybatis.dynamic.sql.BindableColumn
 import org.mybatis.dynamic.sql.VisitableCondition
 import org.mybatis.dynamic.sql.delete.DeleteDSL
 import org.mybatis.dynamic.sql.delete.DeleteModel
-import org.mybatis.dynamic.sql.util.Buildable
 
-typealias DeleteCompleter = DeleteDSL<DeleteModel>.() -> Buildable<DeleteModel>
+typealias DeleteCompleter = KotlinDeleteBuilder.() -> KotlinDeleteBuilder
 
-fun <T> DeleteDSL<DeleteModel>.where(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
-    apply {
-        where().where(column, condition, collect)
-    }
+class KotlinDeleteBuilder(val dsl: DeleteDSL<DeleteModel>) {
+    fun <T> where(column: BindableColumn<T>, condition: VisitableCondition<T>) =
+            apply {
+                dsl.where(column, condition)
+            }
 
-fun <T> DeleteDSL<DeleteModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>) =
-    apply {
-        where().and(column, condition)
-    }
+    fun <T> where(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+            apply {
+                val collector = CriteriaCollector()
+                collect(collector)
+                // TODO...awkward
+                dsl.where(column, condition, *collector.criteria.toTypedArray())
+            }
 
-fun <T> DeleteDSL<DeleteModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
-    apply {
-        where().and(column, condition, collect)
-    }
+    fun applyWhere(whereApplier: WhereApplier) =
+            apply {
+                dsl.applyWhere(whereApplier)
+            }
 
-fun <T> DeleteDSL<DeleteModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>) =
-    apply {
-        where().or(column, condition)
-    }
+    fun <T> and(column: BindableColumn<T>, condition: VisitableCondition<T>) =
+            apply {
+                dsl.where().and(column, condition)
+            }
 
-fun <T> DeleteDSL<DeleteModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
-    apply {
-        where().or(column, condition, collect)
-    }
+    fun <T> and(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+            apply {
+                val collector = CriteriaCollector()
+                collect(collector)
+                // TODO...awkward
+                dsl.where().and(column, condition, *collector.criteria.toTypedArray())
+            }
 
-fun DeleteDSL<DeleteModel>.allRows() = this as Buildable<DeleteModel>
+    fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>) =
+            apply {
+                dsl.where().or(column, condition)
+            }
+
+    fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+            apply {
+                val collector = CriteriaCollector()
+                collect(collector)
+                // TODO...awkward
+                dsl.where().or(column, condition, *collector.criteria.toTypedArray())
+            }
+
+    fun allRows() = this
+}

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

@@ -15,37 +15,137 @@
  */
 package org.mybatis.dynamic.sql.util.kotlin
 
-import org.mybatis.dynamic.sql.BindableColumn
-import org.mybatis.dynamic.sql.VisitableCondition
+import org.mybatis.dynamic.sql.*
 import org.mybatis.dynamic.sql.select.QueryExpressionDSL
 import org.mybatis.dynamic.sql.select.SelectModel
-import org.mybatis.dynamic.sql.util.Buildable
 
-typealias SelectCompleter = QueryExpressionDSL<SelectModel>.() -> Buildable<SelectModel>
+typealias SelectCompleter = KotlinQueryBuilder.() -> KotlinQueryBuilder
 
-fun <T> QueryExpressionDSL<SelectModel>.where(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
-    apply {
-        where().where(column, condition, collect)
-    }
+class KotlinQueryBuilder(val dsl: QueryExpressionDSL<SelectModel>) {
+    fun join(table: SqlTable, receiver: JoinReceiver) =
+            apply {
+                val collector = JoinCollector()
+                receiver(collector)
+                dsl.join(table, collector.onJoinCriterion, collector.andJoinCriteria)
+            }
 
-fun <T> QueryExpressionDSL<SelectModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>) =
-    apply {
-        where().and(column, condition)
-    }
+    fun join(table: SqlTable, alias: String, receiver: JoinReceiver) =
+            apply {
+                val collector = JoinCollector()
+                receiver(collector)
+                dsl.join(table, alias, collector.onJoinCriterion, collector.andJoinCriteria)
+            }
 
-fun <T> QueryExpressionDSL<SelectModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
-    apply {
-        where().and(column, condition, collect)
-    }
+    fun fullJoin(table: SqlTable, receiver: JoinReceiver) =
+            apply {
+                val collector = JoinCollector()
+                receiver(collector)
+                dsl.fullJoin(table, collector.onJoinCriterion, collector.andJoinCriteria)
+            }
 
-fun <T> QueryExpressionDSL<SelectModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>) =
-    apply {
-        where().or(column, condition)
-    }
+    fun fullJoin(table: SqlTable, alias: String, receiver: JoinReceiver) =
+            apply {
+                val collector = JoinCollector()
+                receiver(collector)
+                dsl.fullJoin(table, alias, collector.onJoinCriterion, collector.andJoinCriteria)
+            }
 
-fun <T> QueryExpressionDSL<SelectModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
-    apply {
-        where().or(column, condition, collect)
-    }
+    fun leftJoin(table: SqlTable, receiver: JoinReceiver) =
+            apply {
+                val collector = JoinCollector()
+                receiver(collector)
+                dsl.leftJoin(table, collector.onJoinCriterion, collector.andJoinCriteria)
+            }
 
-fun QueryExpressionDSL<SelectModel>.allRows() = this as Buildable<SelectModel>
+    fun leftJoin(table: SqlTable, alias: String, receiver: JoinReceiver) =
+            apply {
+                val collector = JoinCollector()
+                receiver(collector)
+                dsl.leftJoin(table, alias, collector.onJoinCriterion, collector.andJoinCriteria)
+            }
+
+    fun rightJoin(table: SqlTable, receiver: JoinReceiver) =
+            apply {
+                val collector = JoinCollector()
+                receiver(collector)
+                dsl.rightJoin(table, collector.onJoinCriterion, collector.andJoinCriteria)
+            }
+
+    fun rightJoin(table: SqlTable, alias: String, receiver: JoinReceiver) =
+            apply {
+                val collector = JoinCollector()
+                receiver(collector)
+                dsl.rightJoin(table, alias, collector.onJoinCriterion, collector.andJoinCriteria)
+            }
+
+    fun <T> where(column: BindableColumn<T>, condition: VisitableCondition<T>) =
+            apply {
+                dsl.where(column, condition)
+            }
+
+    fun <T> where(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+            apply {
+                val collector = CriteriaCollector()
+                collect(collector)
+                // TODO...awkward
+                dsl.where(column, condition, *collector.criteria.toTypedArray())
+            }
+
+    fun applyWhere(whereApplier: WhereApplier) =
+            apply {
+                dsl.applyWhere(whereApplier)
+            }
+
+    fun <T> and(column: BindableColumn<T>, condition: VisitableCondition<T>) =
+            apply {
+                dsl.where().and(column, condition)
+            }
+
+    fun <T> and(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+            apply {
+                val collector = CriteriaCollector()
+                collect(collector)
+                // TODO...awkward
+                dsl.where().and(column, condition, *collector.criteria.toTypedArray())
+            }
+
+    fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>) =
+            apply {
+                dsl.where().or(column, condition)
+            }
+
+    fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+            apply {
+                val collector = CriteriaCollector()
+                collect(collector)
+                // TODO...awkward
+                dsl.where().or(column, condition, *collector.criteria.toTypedArray())
+            }
+
+    fun groupBy(vararg columns: BasicColumn) =
+            apply {
+                dsl.groupBy(*columns)
+            }
+
+    fun orderBy(vararg columns: SortSpecification) =
+            apply {
+                dsl.orderBy(*columns)
+            }
+
+    fun limit(limit: Long) =
+            apply {
+                dsl.limit(limit)
+            }
+
+    fun offset(offset: Long) =
+            apply {
+                dsl.offset(offset)
+            }
+
+    fun fetchFirst(fetchFirstRows: Long) =
+            apply {
+                dsl.fetchFirst(fetchFirstRows)
+            }
+
+    fun allRows() = this
+}