Merge pull request #291 from jeffgbutler/remove-extensions

Kotlin DSL Improvements

Author: jeffgbutler

README.md

@@ -20,7 +20,8 @@ For example, a typical search can be coded with a query like this (the following
 
 ```kotlin
    fun search(id: String?, firstName: String?, lastName: String?) =
-        select(Customer.id, Customer.firstName, Customer.lastName).from(Customer) {
+        select(Customer.id, Customer.firstName, Customer.lastName) {
+            from(Customer)
             where(Customer.active, isEqualTo(true))
             and(Customer.id, isEqualToWhenPresent(id).then{ it?.padStart(5, '0') })
             and(Customer.firstName, isLikeCaseInsensitiveWhenPresent(firstName)

src/main/java/org/mybatis/dynamic/sql/insert/InsertSelectDSL.java

@@ -19,12 +19,13 @@
 import java.util.List;
 import java.util.Objects;
 
+import org.jetbrains.annotations.NotNull;
 import org.mybatis.dynamic.sql.SqlColumn;
 import org.mybatis.dynamic.sql.SqlTable;
 import org.mybatis.dynamic.sql.select.SelectModel;
 import org.mybatis.dynamic.sql.util.Buildable;
 
-public class InsertSelectDSL {
+public class InsertSelectDSL implements Buildable<InsertSelectModel> {
 
     private final SqlTable table;
     private final InsertColumnListModel columnList;
@@ -42,6 +43,8 @@ private InsertSelectDSL(SqlTable table, SelectModel selectModel) {
         this.columnList = null;
     }
 
+    @NotNull
+    @Override
     public InsertSelectModel build() {
         return InsertSelectModel.withTable(table)
                 .withColumnList(columnList)

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

@@ -26,6 +26,8 @@ import org.mybatis.dynamic.sql.where.AbstractWhereDSL
 @DslMarker
 annotation class MyBatisDslMarker
 
+typealias WhereApplier = AbstractWhereDSL<*>.() -> Unit
+
 @MyBatisDslMarker
 @Suppress("TooManyFunctions")
 abstract class KotlinBaseBuilder<W : AbstractWhereDSL<W>, B : KotlinBaseBuilder<W, B>> {
@@ -34,9 +36,9 @@ abstract class KotlinBaseBuilder<W : AbstractWhereDSL<W>, B : KotlinBaseBuilder<
             getWhere().where(column, condition)
         }
 
-    fun <T> where(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver): B =
+    fun <T> where(column: BindableColumn<T>, condition: VisitableCondition<T>, subCriteria: CriteriaReceiver): B =
         applySelf {
-            getWhere().where(column, condition, collect)
+            getWhere().where(column, condition, subCriteria(CriteriaCollector()).criteria)
         }
 
     fun applyWhere(whereApplier: WhereApplier): B =
@@ -49,19 +51,19 @@ abstract class KotlinBaseBuilder<W : AbstractWhereDSL<W>, B : KotlinBaseBuilder<
             getWhere().and(column, condition)
         }
 
-    fun <T> and(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver): B =
+    fun <T> and(column: BindableColumn<T>, condition: VisitableCondition<T>, subCriteria: CriteriaReceiver): B =
         applySelf {
-            getWhere().and(column, condition, collect)
+            getWhere().and(column, condition, subCriteria(CriteriaCollector()).criteria)
         }
 
     fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>): B =
         applySelf {
             getWhere().or(column, condition)
         }
 
-    fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver): B =
+    fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>, subCriteria: CriteriaReceiver): B =
         applySelf {
-            getWhere().or(column, condition, collect)
+            getWhere().or(column, condition, subCriteria(CriteriaCollector()).criteria)
         }
 
     fun allRows() = self()
@@ -77,44 +79,49 @@ abstract class KotlinBaseBuilder<W : AbstractWhereDSL<W>, B : KotlinBaseBuilder<
 abstract class KotlinBaseJoiningBuilder<T : AbstractQueryExpressionDSL<T, SelectModel>, W : AbstractWhereDSL<W>,
         B : KotlinBaseJoiningBuilder<T, W, B>> : KotlinBaseBuilder<W, B>() {
 
-    fun join(table: SqlTable, receiver: JoinReceiver): B =
-        applySelf {
-            getDsl().join(table, receiver)
+    fun join(table: SqlTable, joinCriteria: JoinReceiver) =
+        applyJoin(joinCriteria) {
+            getDsl().join(table, it.onJoinCriterion, it.andJoinCriteria)
         }
 
-    fun join(table: SqlTable, alias: String, receiver: JoinReceiver): B =
-        applySelf {
-            getDsl().join(table, alias, receiver)
+    fun join(table: SqlTable, alias: String, joinCriteria: JoinReceiver) =
+        applyJoin(joinCriteria) {
+            getDsl().join(table, alias, it.onJoinCriterion, it.andJoinCriteria)
         }
 
-    fun fullJoin(table: SqlTable, receiver: JoinReceiver): B =
-        applySelf {
-            getDsl().fullJoin(table, receiver)
+    fun fullJoin(table: SqlTable, joinCriteria: JoinReceiver) =
+        applyJoin(joinCriteria) {
+            getDsl().fullJoin(table, it.onJoinCriterion, it.andJoinCriteria)
         }
 
-    fun fullJoin(table: SqlTable, alias: String, receiver: JoinReceiver): B =
-        applySelf {
-            getDsl().fullJoin(table, alias, receiver)
+    fun fullJoin(table: SqlTable, alias: String, joinCriteria: JoinReceiver) =
+        applyJoin(joinCriteria) {
+            getDsl().fullJoin(table, alias, it.onJoinCriterion, it.andJoinCriteria)
         }
 
-    fun leftJoin(table: SqlTable, receiver: JoinReceiver): B =
-        applySelf {
-            getDsl().leftJoin(table, receiver)
+    fun leftJoin(table: SqlTable, joinCriteria: JoinReceiver) =
+        applyJoin(joinCriteria) {
+            getDsl().leftJoin(table, it.onJoinCriterion, it.andJoinCriteria)
         }
 
-    fun leftJoin(table: SqlTable, alias: String, receiver: JoinReceiver): B =
-        applySelf {
-            getDsl().leftJoin(table, alias, receiver)
+    fun leftJoin(table: SqlTable, alias: String, joinCriteria: JoinReceiver) =
+        applyJoin(joinCriteria) {
+            getDsl().leftJoin(table, alias, it.onJoinCriterion, it.andJoinCriteria)
         }
 
-    fun rightJoin(table: SqlTable, receiver: JoinReceiver): B =
-        applySelf {
-            getDsl().rightJoin(table, receiver)
+    fun rightJoin(table: SqlTable, joinCriteria: JoinReceiver) =
+        applyJoin(joinCriteria) {
+            getDsl().rightJoin(table, it.onJoinCriterion, it.andJoinCriteria)
+        }
+
+    fun rightJoin(table: SqlTable, alias: String, joinCriteria: JoinReceiver) =
+        applyJoin(joinCriteria) {
+            getDsl().rightJoin(table, alias, it.onJoinCriterion, it.andJoinCriteria)
         }
 
-    fun rightJoin(table: SqlTable, alias: String, receiver: JoinReceiver): B =
+    private fun applyJoin(joinCriteria: JoinReceiver, block: (JoinCollector) -> Unit) =
         applySelf {
-            getDsl().rightJoin(table, alias, receiver)
+            joinCriteria(JoinCollector()).also(block)
         }
 
     protected abstract fun getDsl(): AbstractQueryExpressionDSL<T, SelectModel>

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

@@ -20,26 +20,11 @@ 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 CountCompleter = KotlinCountBuilder.() -> KotlinCountBuilder
 
-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>) :
+class KotlinCountBuilder(private val fromGatherer: CountDSL.FromGatherer<SelectModel>) :
     KotlinBaseJoiningBuilder<CountDSL<SelectModel>,
-            CountDSL<SelectModel>.CountWhereBuilder, KotlinCountColumnBuilder>(),
+            CountDSL<SelectModel>.CountWhereBuilder, KotlinCountBuilder>(),
     Buildable<SelectModel> {
 
     private lateinit var dsl: CountDSL<SelectModel>

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinBaseBuilders.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.() -> Buildable<DeleteModel>
+typealias DeleteCompleter = KotlinDeleteBuilder.() -> KotlinDeleteBuilder
 
 class KotlinDeleteBuilder(private val dsl: DeleteDSL<DeleteModel>) :
         KotlinBaseBuilder<DeleteDSL<DeleteModel>.DeleteWhereBuilder, KotlinDeleteBuilder>(), Buildable<DeleteModel> {

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

@@ -0,0 +1,81 @@
+/*
+ *    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.BasicColumn
+import org.mybatis.dynamic.sql.SqlBuilder
+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.MultiRowInsertDSL
+
+/**
+ * Collection of functions that will create various DSL models in a Kotlin native way.
+ * They are wrapped in an object as a namespacing technique to avoid collision
+ * with the similar functions that build providers for the different rendering
+ * strategies.
+ */
+object KotlinModelBuilderFunctions {
+    fun count(column: BasicColumn, completer: CountCompleter) =
+        completer(KotlinCountBuilder(SqlBuilder.countColumn(column))).build()
+
+    fun countDistinct(column: BasicColumn, completer: CountCompleter) =
+        completer(KotlinCountBuilder(SqlBuilder.countDistinctColumn(column))).build()
+
+    fun countFrom(table: SqlTable, completer: CountCompleter) =
+        with(KotlinCountBuilder(SqlBuilder.countColumn(SqlBuilder.constant<Long>("*")))) {
+            completer(from(table)).build()
+        }
+
+    fun deleteFrom(table: SqlTable, completer: DeleteCompleter) =
+        completer(KotlinDeleteBuilder(SqlBuilder.deleteFrom(table))).build()
+
+    fun insertInto(table: SqlTable, completer: GeneralInsertCompleter) =
+        completer(GeneralInsertDSL.insertInto(table)).build()
+
+    fun insertSelect(table: SqlTable, completer: InsertSelectCompleter) =
+        with(completer(KotlinInsertSelectSubQueryBuilder())) {
+            SqlBuilder.insertInto(table)
+                .withColumnList(columnList)
+                .withSelectStatement(selectBuilder)
+                .build()
+        }
+
+    fun <T> BatchInsertDSL.IntoGatherer<T>.into(table: SqlTable, completer: BatchInsertCompleter<T>) =
+        completer(into(table)).build()
+
+    fun <T> InsertDSL.IntoGatherer<T>.into(table: SqlTable, completer: InsertCompleter<T>) =
+        completer(into(table)).build()
+
+    fun <T> MultiRowInsertDSL.IntoGatherer<T>.into(table: SqlTable, completer: MultiRowInsertCompleter<T>) =
+        completer(into(table)).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()
+
+    fun selectDistinct(vararg columns: BasicColumn, completer: SelectCompleter) =
+        selectDistinct(columns.asList(), completer)
+
+    fun selectDistinct(columns: List<BasicColumn>, completer: SelectCompleter) =
+        completer(KotlinSelectBuilder(SqlBuilder.selectDistinct(columns))).build()
+
+    fun update(table: SqlTable, completer: UpdateCompleter) =
+        completer(KotlinUpdateBuilder(SqlBuilder.update(table))).build()
+}