Add infix/shortcut functions for all built-in conditions

Author: jeffgbutler

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

@@ -0,0 +1,26 @@
+/*
+ *    Copyright 2016-2022 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
+
+/**
+ * This exception is thrown when a where clause contains more than one criterion and there
+ * is not an "and" or an "or" to connect them.
+ *
+ * @since 1.4.0
+ */
+class DuplicateInitialCriterionException : RuntimeException(
+    "Setting more than one initial criterion is not allowed. " +
+            "Additional criteria should be added with \"and\" or \"or\" expression")

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

@@ -19,6 +19,7 @@ import org.mybatis.dynamic.sql.BindableColumn
 import org.mybatis.dynamic.sql.ColumnAndConditionCriterion
 import org.mybatis.dynamic.sql.CriteriaGroup
 import org.mybatis.dynamic.sql.AndOrCriteriaGroup
+import org.mybatis.dynamic.sql.BasicColumn
 import org.mybatis.dynamic.sql.ExistsCriterion
 import org.mybatis.dynamic.sql.NotCriterion
 import org.mybatis.dynamic.sql.SqlBuilder
@@ -40,9 +41,17 @@ typealias GroupingCriteriaReceiver = GroupingCriteriaCollector.() -> Unit
  * Only one of these initial criterion functions should be called within each scope. If you need more than one,
  * use a sub-criteria joined with "and" or "or"
  */
+@Suppress("TooManyFunctions")
 @MyBatisDslMarker
 class GroupingCriteriaCollector {
     internal var initialCriterion: SqlCriterion? = null
+        private set(value) {
+            if (field != null) {
+                throw DuplicateInitialCriterionException()
+            }
+            field = value
+        }
+
     internal val subCriteria = mutableListOf<AndOrCriteriaGroup>()
 
     fun and(criteriaReceiver: GroupingCriteriaReceiver): Unit =
@@ -104,9 +113,168 @@ class GroupingCriteriaCollector {
      * Build an initial criterion for a where clause, or a nested and/or/not group.
      * You can use it like A (isEqualTo(3))
      */
-    infix operator fun <T : Any> BindableColumn<T>.invoke(condition: VisitableCondition<T>) {
+    operator fun <T> BindableColumn<T>.invoke(condition: VisitableCondition<T>) {
         initialCriterion = ColumnAndConditionCriterion.withColumn(this)
             .withCondition(condition)
             .build()
     }
+
+    // infix functions...we may be able to rewrite these as extension functions once Kotlin solves the multiple
+    // receivers problem (https://youtrack.jetbrains.com/issue/KT-42435)
+
+    // conditions for all data types
+    fun <T> BindableColumn<T>.isNull() = invoke(SqlBuilder.isNull())
+
+    fun <T> BindableColumn<T>.isNotNull() = invoke(SqlBuilder.isNotNull())
+
+    infix fun <T : Any> BindableColumn<T>.isEqualTo(value: T) = invoke(SqlBuilder.isEqualTo(value))
+
+    infix fun <T> BindableColumn<T>.isEqualToSubQuery(subQuery: KotlinSubQueryBuilder.() -> Unit) =
+        invoke(SqlBuilder.isEqualTo(KotlinSubQueryBuilder().apply(subQuery)))
+
+    infix fun <T> BindableColumn<T>.isEqualTo(column: BasicColumn) = invoke(SqlBuilder.isEqualTo(column))
+
+    infix fun <T : Any> BindableColumn<T>.isEqualToWhenPresent(value: T?) =
+        invoke(SqlBuilder.isEqualToWhenPresent<T>(value))
+
+    infix fun <T : Any> BindableColumn<T>.isNotEqualTo(value: T) = invoke(SqlBuilder.isNotEqualTo(value))
+
+    infix fun <T> BindableColumn<T>.isNotEqualToSubQuery(subQuery: KotlinSubQueryBuilder.() -> Unit) =
+        invoke(SqlBuilder.isNotEqualTo(KotlinSubQueryBuilder().apply(subQuery)))
+
+    infix fun <T> BindableColumn<T>.isNotEqualTo(column: BasicColumn) = invoke(SqlBuilder.isNotEqualTo(column))
+
+    infix fun <T : Any> BindableColumn<T>.isNotEqualToWhenPresent(value: T?) =
+        invoke(SqlBuilder.isNotEqualToWhenPresent<T>(value))
+
+    infix fun <T : Any> BindableColumn<T>.isGreaterThan(value: T) = invoke(SqlBuilder.isGreaterThan(value))
+
+    infix fun <T> BindableColumn<T>.isGreaterThanSubQuery(subQuery: KotlinSubQueryBuilder.() -> Unit) =
+        invoke(SqlBuilder.isGreaterThan(KotlinSubQueryBuilder().apply(subQuery)))
+
+    infix fun <T> BindableColumn<T>.isGreaterThan(column: BasicColumn) = invoke(SqlBuilder.isGreaterThan(column))
+
+    infix fun <T : Any> BindableColumn<T>.isGreaterThanWhenPresent(value: T?) =
+        invoke(SqlBuilder.isGreaterThanWhenPresent<T>(value))
+
+    infix fun <T : Any> BindableColumn<T>.isGreaterThanOrEqualTo(value: T) =
+        invoke(SqlBuilder.isGreaterThanOrEqualTo(value))
+
+    infix fun <T> BindableColumn<T>.isGreaterThanOrEqualToSubQuery(subQuery: KotlinSubQueryBuilder.() -> Unit) =
+        invoke(SqlBuilder.isGreaterThanOrEqualTo(KotlinSubQueryBuilder().apply(subQuery)))
+
+    infix fun <T> BindableColumn<T>.isGreaterThanOrEqualTo(column: BasicColumn) =
+        invoke(SqlBuilder.isGreaterThanOrEqualTo(column))
+
+    infix fun <T : Any> BindableColumn<T>.isGreaterThanOrEqualToWhenPresent(value: T?) =
+        invoke(SqlBuilder.isGreaterThanOrEqualToWhenPresent<T>(value))
+
+    infix fun <T : Any> BindableColumn<T>.isLessThan(value: T) = invoke(SqlBuilder.isLessThan(value))
+
+    infix fun <T> BindableColumn<T>.isLessThanSubQuery(subQuery: KotlinSubQueryBuilder.() -> Unit) =
+        invoke(SqlBuilder.isLessThan(KotlinSubQueryBuilder().apply(subQuery)))
+
+    infix fun <T> BindableColumn<T>.isLessThan(column: BasicColumn) = invoke(SqlBuilder.isLessThan(column))
+
+    infix fun <T : Any> BindableColumn<T>.isLessThanWhenPresent(value: T?) =
+        invoke(SqlBuilder.isLessThanWhenPresent<T>(value))
+
+    infix fun <T : Any> BindableColumn<T>.isLessThanOrEqualTo(value: T) = invoke(SqlBuilder.isLessThanOrEqualTo(value))
+
+    infix fun <T> BindableColumn<T>.isLessThanOrEqualToSubQuery(subQuery: KotlinSubQueryBuilder.() -> Unit) =
+        invoke(SqlBuilder.isLessThanOrEqualTo(KotlinSubQueryBuilder().apply(subQuery)))
+
+    infix fun <T> BindableColumn<T>.isLessThanOrEqualTo(column: BasicColumn) =
+        invoke(SqlBuilder.isLessThanOrEqualTo(column))
+
+    infix fun <T : Any> BindableColumn<T>.isLessThanOrEqualToWhenPresent(value: T?) =
+        invoke(SqlBuilder.isLessThanOrEqualToWhenPresent<T>(value))
+
+    fun <T : Any> BindableColumn<T>.isIn(vararg values: T) = isIn(values.asList())
+
+    infix fun <T : Any> BindableColumn<T>.isIn(values: Collection<T>) = invoke(SqlBuilder.isIn(values))
+
+    infix fun <T> BindableColumn<T>.isIn(subQuery: KotlinSubQueryBuilder.() -> Unit) =
+        invoke(SqlBuilder.isIn(KotlinSubQueryBuilder().apply(subQuery)))
+
+    fun <T : Any> BindableColumn<T>.isInWhenPresent(vararg values: T?) = isInWhenPresent(values.asList())
+
+    infix fun <T : Any> BindableColumn<T>.isInWhenPresent(values: Collection<T?>?) =
+        invoke(SqlBuilder.isInWhenPresent<T>(values))
+
+    fun <T : Any> BindableColumn<T>.isNotIn(vararg values: T) = isNotIn(values.asList())
+
+    infix fun <T : Any> BindableColumn<T>.isNotIn(values: Collection<T>) = invoke(SqlBuilder.isNotIn(values))
+
+    infix fun <T> BindableColumn<T>.isNotIn(subQuery: KotlinSubQueryBuilder.() -> Unit) =
+        invoke(SqlBuilder.isNotIn(KotlinSubQueryBuilder().apply(subQuery)))
+
+    fun <T : Any> BindableColumn<T>.isNotInWhenPresent(vararg values: T?) = isNotInWhenPresent(values.asList())
+
+    infix fun <T : Any> BindableColumn<T>.isNotInWhenPresent(values: Collection<T?>?) =
+        invoke(SqlBuilder.isNotInWhenPresent<T>(values))
+
+    infix fun <T : Any> BindableColumn<T>.isBetween(value1: T) =
+        InfixBetweenBuilder(value1) { invoke(it) }
+
+    infix fun <T : Any> BindableColumn<T>.isBetweenWhenPresent(value1: T?) =
+        InfixBetweenWhenPresentBuilder(value1) { invoke(it) }
+
+    infix fun <T : Any> BindableColumn<T>.isNotBetween(value1: T) =
+        InfixNotBetweenBuilder(value1) { invoke(it) }
+
+    infix fun <T : Any> BindableColumn<T>.isNotBetweenWhenPresent(value1: T?) =
+        InfixNotBetweenWhenPresentBuilder(value1) { invoke(it) }
+
+    // for string columns, but generic for columns with type handlers
+    infix fun <T : Any> BindableColumn<T>.isLike(value: T) = invoke(SqlBuilder.isLike(value))
+
+    infix fun <T : Any> BindableColumn<T>.isLikeWhenPresent(value: T?) =
+        invoke(SqlBuilder.isLikeWhenPresent<T>(value))
+
+    infix fun <T : Any> BindableColumn<T>.isNotLike(value: T) = invoke(SqlBuilder.isNotLike(value))
+
+    infix fun <T : Any> BindableColumn<T>.isNotLikeWhenPresent(value: T?) =
+        invoke(SqlBuilder.isNotLikeWhenPresent<T>(value))
+
+    // shortcuts for booleans
+    fun BindableColumn<Boolean>.isTrue() = isEqualTo(true)
+
+    fun BindableColumn<Boolean>.isFalse() = isEqualTo(false)
+
+    // conditions for strings only
+    infix fun BindableColumn<String>.isLikeCaseInsensitive(value: String) =
+        invoke(SqlBuilder.isLikeCaseInsensitive(value))
+
+    infix fun BindableColumn<String>.isLikeCaseInsensitiveWhenPresent(value: String?) =
+        invoke(SqlBuilder.isLikeCaseInsensitiveWhenPresent(value))
+
+    infix fun BindableColumn<String>.isNotLikeCaseInsensitive(value: String) =
+        invoke(SqlBuilder.isNotLikeCaseInsensitive(value))
+
+    infix fun BindableColumn<String>.isNotLikeCaseInsensitiveWhenPresent(value: String?) =
+        invoke(SqlBuilder.isNotLikeCaseInsensitiveWhenPresent(value))
+
+    fun BindableColumn<String>.isInCaseInsensitive(vararg values: String) = isInCaseInsensitive(values.asList())
+
+    infix fun BindableColumn<String>.isInCaseInsensitive(values: Collection<String>) =
+        invoke(SqlBuilder.isInCaseInsensitive(values))
+
+    fun BindableColumn<String>.isInCaseInsensitiveWhenPresent(vararg values: String?) =
+        isInCaseInsensitiveWhenPresent(values.asList())
+
+    infix fun BindableColumn<String>.isInCaseInsensitiveWhenPresent(values: Collection<String?>?) =
+        invoke(SqlBuilder.isInCaseInsensitiveWhenPresent(values))
+
+    fun BindableColumn<String>.isNotInCaseInsensitive(vararg values: String) =
+        isNotInCaseInsensitive(values.asList())
+
+    infix fun BindableColumn<String>.isNotInCaseInsensitive(values: Collection<String>) =
+        invoke(SqlBuilder.isNotInCaseInsensitive(values))
+
+    fun BindableColumn<String>.isNotInCaseInsensitiveWhenPresent(vararg values: String?) =
+        isNotInCaseInsensitiveWhenPresent(values.asList())
+
+    infix fun BindableColumn<String>.isNotInCaseInsensitiveWhenPresent(values: Collection<String?>?) =
+        invoke(SqlBuilder.isNotInCaseInsensitiveWhenPresent(values))
 }

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

@@ -0,0 +1,44 @@
+/*
+ *    Copyright 2016-2022 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.SqlBuilder
+import org.mybatis.dynamic.sql.VisitableCondition
+
+class InfixBetweenBuilder<T> (private val value1: T, private val conditionConsumer: (VisitableCondition<T>) -> Unit) {
+    infix fun and(value2: T) = conditionConsumer.invoke(SqlBuilder.isBetween(value1).and(value2))
+}
+
+class InfixBetweenWhenPresentBuilder<T>(
+    private val value1: T?,
+    private val conditionConsumer: (VisitableCondition<T>) -> Unit
+) {
+    infix fun and(value2: T?) = conditionConsumer.invoke(SqlBuilder.isBetweenWhenPresent<T>(value1).and(value2))
+}
+
+class InfixNotBetweenBuilder<T>(
+    private val value1: T,
+    private val conditionConsumer: (VisitableCondition<T>) -> Unit
+) {
+    infix fun and(value2: T) = conditionConsumer.invoke(SqlBuilder.isNotBetween(value1).and(value2))
+}
+
+class InfixNotBetweenWhenPresentBuilder<T>(
+    private val value1: T?,
+    private val conditionConsumer: (VisitableCondition<T>) -> Unit
+) {
+    infix fun and(value2: T?) = conditionConsumer.invoke(SqlBuilder.isNotBetweenWhenPresent<T>(value1).and(value2))
+}

src/test/kotlin/examples/kotlin/mybatis3/canonical/ReusableWhereTest.kt

@@ -31,10 +31,6 @@ import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
 import org.mybatis.dynamic.sql.util.kotlin.WhereApplier
 import org.mybatis.dynamic.sql.util.kotlin.andThen
-import org.mybatis.dynamic.sql.util.kotlin.elements.isEqualTo
-import org.mybatis.dynamic.sql.util.kotlin.elements.isLessThan
-import org.mybatis.dynamic.sql.util.kotlin.elements.isNotNull
-import org.mybatis.dynamic.sql.util.kotlin.elements.isNull
 import org.mybatis.dynamic.sql.util.kotlin.mybatis3.select
 import java.io.InputStreamReader
 import java.sql.DriverManager
@@ -114,12 +110,10 @@ class ReusableWhereTest {
 
     @Test
     fun testComposition() {
-        var whereApplier = commonWhere.andThen {
-            and(birthDate, isNotNull())
-        }
-
-        whereApplier = whereApplier.andThen {
-            or(addressId, isLessThan(3))
+        val whereApplier = commonWhere.andThen {
+            and { birthDate.isNotNull() }
+        }.andThen {
+            or { addressId isLessThan 3 }
         }
 
         val selectStatement = select(person.allColumns()) {
@@ -136,8 +130,8 @@ class ReusableWhereTest {
     }
 
     private val commonWhere: WhereApplier = {
-        where(id, isEqualTo(1))
-        or(occupation, isNull<String>())
+        where { id isEqualTo 1 }
+        or { occupation.isNull() }
     }
 
     companion object {