[Kotlin] Update to Definitely Non-Null Types Where Appropriate

CHANGELOG.md

@@ -12,6 +12,9 @@ GitHub milestone: [https://github.com/mybatis/mybatis-dynamic-sql/issues?q=miles
 2. Added the ability to specify a table alias on DELETE and UPDATE statements.
    This is especially useful when working with a sub-query with an exists or not exists condition.
    ([#489](https://github.com/mybatis/mybatis-dynamic-sql/pull/489))
+3. Updated the Kotlin DSL to use Kotlin 1.7's new "definitely non-null" types where appropriate. This helps us to more
+   accurately represent the nullable/non-nullable expectations for API method calls.
+   ([#496](https://github.com/mybatis/mybatis-dynamic-sql/pull/496))
 
 ## Release 1.4.0 - March 3, 2022
 

pom.xml

@@ -230,6 +230,12 @@
       <optional>true</optional>
     </dependency>
 
+    <dependency>
+      <groupId>org.jetbrains.kotlin</groupId>
+      <artifactId>kotlin-compiler</artifactId>
+      <version>${kotlin.version}</version>
+      <scope>test</scope>
+    </dependency>
     <dependency>
       <groupId>org.junit.jupiter</groupId>
       <artifactId>junit-jupiter-api</artifactId>

src/main/java/org/mybatis/dynamic/sql/delete/DeleteDSL.java

@@ -59,7 +59,8 @@ public R build() {
         return adapterFunction.apply(deleteModel);
     }
 
-    public static <R> DeleteDSL<R> deleteFrom(Function<DeleteModel, R> adapterFunction, SqlTable table, String tableAlias) {
+    public static <R> DeleteDSL<R> deleteFrom(Function<DeleteModel, R> adapterFunction, SqlTable table,
+                                              String tableAlias) {
         return new DeleteDSL<>(table, tableAlias, adapterFunction);
     }
 

src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultInsertStatementProvider.java

@@ -1,5 +1,5 @@
 /*
- *    Copyright 2016-2021 the original author or authors.
+ *    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.
@@ -17,6 +17,8 @@
 
 import java.util.Objects;
 
+import org.jetbrains.annotations.NotNull;
+
 public class DefaultInsertStatementProvider<T> implements InsertStatementProvider<T> {
     private final String insertStatement;
     // need to keep both row and record for now so we don't break
@@ -37,6 +39,7 @@ public T getRecord() {
     }
 
     @Override
+    @NotNull
     public T getRow() {
         return row;
     }

src/main/java/org/mybatis/dynamic/sql/insert/render/InsertStatementProvider.java

@@ -15,6 +15,8 @@
  */
 package org.mybatis.dynamic.sql.insert.render;
 
+import org.jetbrains.annotations.NotNull;
+
 public interface InsertStatementProvider<T> {
     /**
      * Return the row associated with this insert statement.
@@ -30,6 +32,7 @@ public interface InsertStatementProvider<T> {
      *
      * @return the row associated with this insert statement.
      */
+    @NotNull
     T getRow();
 
     /**

src/main/java/org/mybatis/dynamic/sql/update/render/SetPhraseVisitor.java

@@ -55,7 +55,8 @@ public SetPhraseVisitor(AtomicInteger sequence, RenderingStrategy renderingStrat
 
     @Override
     public Optional<FragmentAndParameters> visit(NullMapping mapping) {
-        return FragmentAndParameters.withFragment(mapping.mapColumn(aliasedColumnNameFunction) + " = null") //$NON-NLS-1$
+        return FragmentAndParameters
+                .withFragment(mapping.mapColumn(aliasedColumnNameFunction) + " = null") //$NON-NLS-1$
                 .buildOptional();
     }
 

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

@@ -243,7 +243,7 @@ class GroupingCriteriaCollector {
 
     fun BindableColumn<*>.isNotNull() = invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotNull())
 
-    infix fun <T : Any> BindableColumn<T>.isEqualTo(value: T) =
+    infix fun <T> BindableColumn<T>.isEqualTo(value: T & Any) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isEqualTo(value))
 
     infix fun BindableColumn<*>.isEqualTo(subQuery: KotlinSubQueryBuilder.() -> Unit) =
@@ -252,10 +252,10 @@ class GroupingCriteriaCollector {
     infix fun BindableColumn<*>.isEqualTo(column: BasicColumn) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isEqualTo(column))
 
-    infix fun <T : Any> BindableColumn<T>.isEqualToWhenPresent(value: T?) =
+    infix fun <T> BindableColumn<T>.isEqualToWhenPresent(value: T?) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isEqualToWhenPresent(value))
 
-    infix fun <T : Any> BindableColumn<T>.isNotEqualTo(value: T) =
+    infix fun <T> BindableColumn<T>.isNotEqualTo(value: T & Any) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotEqualTo(value))
 
     infix fun BindableColumn<*>.isNotEqualTo(subQuery: KotlinSubQueryBuilder.() -> Unit) =
@@ -264,10 +264,10 @@ class GroupingCriteriaCollector {
     infix fun BindableColumn<*>.isNotEqualTo(column: BasicColumn) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotEqualTo(column))
 
-    infix fun <T : Any> BindableColumn<T>.isNotEqualToWhenPresent(value: T?) =
+    infix fun <T> BindableColumn<T>.isNotEqualToWhenPresent(value: T?) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotEqualToWhenPresent(value))
 
-    infix fun <T : Any> BindableColumn<T>.isGreaterThan(value: T) =
+    infix fun <T> BindableColumn<T>.isGreaterThan(value: T & Any) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isGreaterThan(value))
 
     infix fun BindableColumn<*>.isGreaterThan(subQuery: KotlinSubQueryBuilder.() -> Unit) =
@@ -276,10 +276,10 @@ class GroupingCriteriaCollector {
     infix fun BindableColumn<*>.isGreaterThan(column: BasicColumn) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isGreaterThan(column))
 
-    infix fun <T : Any> BindableColumn<T>.isGreaterThanWhenPresent(value: T?) =
+    infix fun <T> BindableColumn<T>.isGreaterThanWhenPresent(value: T?) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isGreaterThanWhenPresent(value))
 
-    infix fun <T : Any> BindableColumn<T>.isGreaterThanOrEqualTo(value: T) =
+    infix fun <T> BindableColumn<T>.isGreaterThanOrEqualTo(value: T & Any) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isGreaterThanOrEqualTo(value))
 
     infix fun BindableColumn<*>.isGreaterThanOrEqualTo(subQuery: KotlinSubQueryBuilder.() -> Unit) =
@@ -288,10 +288,10 @@ class GroupingCriteriaCollector {
     infix fun BindableColumn<*>.isGreaterThanOrEqualTo(column: BasicColumn) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isGreaterThanOrEqualTo(column))
 
-    infix fun <T : Any> BindableColumn<T>.isGreaterThanOrEqualToWhenPresent(value: T?) =
+    infix fun <T> BindableColumn<T>.isGreaterThanOrEqualToWhenPresent(value: T?) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isGreaterThanOrEqualToWhenPresent(value))
 
-    infix fun <T : Any> BindableColumn<T>.isLessThan(value: T) =
+    infix fun <T> BindableColumn<T>.isLessThan(value: T & Any) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isLessThan(value))
 
     infix fun BindableColumn<*>.isLessThan(subQuery: KotlinSubQueryBuilder.() -> Unit) =
@@ -300,10 +300,10 @@ class GroupingCriteriaCollector {
     infix fun BindableColumn<*>.isLessThan(column: BasicColumn) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isLessThan(column))
 
-    infix fun <T : Any> BindableColumn<T>.isLessThanWhenPresent(value: T?) =
+    infix fun <T> BindableColumn<T>.isLessThanWhenPresent(value: T?) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isLessThanWhenPresent(value))
 
-    infix fun <T : Any> BindableColumn<T>.isLessThanOrEqualTo(value: T) =
+    infix fun <T> BindableColumn<T>.isLessThanOrEqualTo(value: T & Any) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isLessThanOrEqualTo(value))
 
     infix fun BindableColumn<*>.isLessThanOrEqualTo(subQuery: KotlinSubQueryBuilder.() -> Unit) =
@@ -312,66 +312,66 @@ class GroupingCriteriaCollector {
     infix fun BindableColumn<*>.isLessThanOrEqualTo(column: BasicColumn) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isLessThanOrEqualTo(column))
 
-    infix fun <T : Any> BindableColumn<T>.isLessThanOrEqualToWhenPresent(value: T?) =
+    infix fun <T> BindableColumn<T>.isLessThanOrEqualToWhenPresent(value: T?) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isLessThanOrEqualToWhenPresent(value))
 
-    fun <T : Any> BindableColumn<T>.isIn(vararg values: T) = isIn(values.asList())
+    fun <T> BindableColumn<T>.isIn(vararg values: T & Any) = isIn(values.asList())
 
-    infix fun <T : Any> BindableColumn<T>.isIn(values: Collection<T>) =
+    infix fun <T> BindableColumn<T>.isIn(values: Collection<T & Any>) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isIn(values))
 
     infix fun BindableColumn<*>.isIn(subQuery: KotlinSubQueryBuilder.() -> Unit) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isIn(subQuery))
 
-    fun <T : Any> BindableColumn<T>.isInWhenPresent(vararg values: T?) = isInWhenPresent(values.asList())
+    fun <T> BindableColumn<T>.isInWhenPresent(vararg values: T?) = isInWhenPresent(values.asList())
 
-    infix fun <T : Any> BindableColumn<T>.isInWhenPresent(values: Collection<T?>?) =
+    infix fun <T> BindableColumn<T>.isInWhenPresent(values: Collection<T?>?) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isInWhenPresent(values))
 
-    fun <T : Any> BindableColumn<T>.isNotIn(vararg values: T) = isNotIn(values.asList())
+    fun <T> BindableColumn<T>.isNotIn(vararg values: T & Any) = isNotIn(values.asList())
 
-    infix fun <T : Any> BindableColumn<T>.isNotIn(values: Collection<T>) =
+    infix fun <T> BindableColumn<T>.isNotIn(values: Collection<T & Any>) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotIn(values))
 
     infix fun BindableColumn<*>.isNotIn(subQuery: KotlinSubQueryBuilder.() -> Unit) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotIn(subQuery))
 
-    fun <T : Any> BindableColumn<T>.isNotInWhenPresent(vararg values: T?) = isNotInWhenPresent(values.asList())
+    fun <T> BindableColumn<T>.isNotInWhenPresent(vararg values: T?) = isNotInWhenPresent(values.asList())
 
-    infix fun <T : Any> BindableColumn<T>.isNotInWhenPresent(values: Collection<T?>?) =
+    infix fun <T> BindableColumn<T>.isNotInWhenPresent(values: Collection<T?>?) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotInWhenPresent(values))
 
-    infix fun <T : Any> BindableColumn<T>.isBetween(value1: T) =
-        SecondValueCollector<T> {
+    infix fun <T> BindableColumn<T>.isBetween(value1: T & Any) =
+        SecondValueCollector<T & Any> {
             invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isBetween(value1).and(it))
         }
 
-    infix fun <T : Any> BindableColumn<T>.isBetweenWhenPresent(value1: T?) =
+    infix fun <T> BindableColumn<T>.isBetweenWhenPresent(value1: T?) =
         NullableSecondValueCollector<T> {
             invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isBetweenWhenPresent(value1).and(it))
         }
 
-    infix fun <T : Any> BindableColumn<T>.isNotBetween(value1: T) =
-        SecondValueCollector<T> {
+    infix fun <T> BindableColumn<T>.isNotBetween(value1: T & Any) =
+        SecondValueCollector<T & Any> {
             invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotBetween(value1).and(it))
         }
 
-    infix fun <T : Any> BindableColumn<T>.isNotBetweenWhenPresent(value1: T?) =
+    infix fun <T> BindableColumn<T>.isNotBetweenWhenPresent(value1: T?) =
         NullableSecondValueCollector<T> {
             invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotBetweenWhenPresent(value1).and(it))
         }
 
     // for string columns, but generic for columns with type handlers
-    infix fun <T : Any> BindableColumn<T>.isLike(value: T) =
+    infix fun <T> BindableColumn<T>.isLike(value: T & Any) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isLike(value))
 
-    infix fun <T : Any> BindableColumn<T>.isLikeWhenPresent(value: T?) =
+    infix fun <T> BindableColumn<T>.isLikeWhenPresent(value: T?) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isLikeWhenPresent(value))
 
-    infix fun <T : Any> BindableColumn<T>.isNotLike(value: T) =
+    infix fun <T> BindableColumn<T>.isNotLike(value: T & Any) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotLike(value))
 
-    infix fun <T : Any> BindableColumn<T>.isNotLikeWhenPresent(value: T?) =
+    infix fun <T> BindableColumn<T>.isNotLikeWhenPresent(value: T?) =
         invoke(org.mybatis.dynamic.sql.util.kotlin.elements.isNotLikeWhenPresent(value))
 
     // shortcuts for booleans

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

@@ -25,15 +25,15 @@ import org.mybatis.dynamic.sql.util.Buildable
 typealias KotlinBatchInsertCompleter<T> = KotlinBatchInsertBuilder<T>.() -> Unit
 
 @MyBatisDslMarker
-class KotlinBatchInsertBuilder<T> (private val rows: Collection<T>): Buildable<BatchInsertModel<T>> {
+class KotlinBatchInsertBuilder<T : Any> (private val rows: Collection<T>): Buildable<BatchInsertModel<T>> {
     private var table: SqlTable? = null
     private val columnMappings = mutableListOf<AbstractColumnMapping>()
 
     fun into(table: SqlTable) {
         this.table = table
     }
 
-    fun <C : Any> map(column: SqlColumn<C>) = MultiRowInsertColumnMapCompleter(column) {
+    fun <C> map(column: SqlColumn<C>) = MultiRowInsertColumnMapCompleter(column) {
         columnMappings.add(it)
     }
 

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

@@ -29,7 +29,7 @@ class KotlinGeneralInsertBuilder(private val table: SqlTable) : Buildable<Genera
 
     private val columnMappings = mutableListOf<AbstractColumnMapping>()
 
-    fun <T : Any> set(column: SqlColumn<T>) = GeneralInsertColumnSetCompleter(column) {
+    fun <T> set(column: SqlColumn<T>) = GeneralInsertColumnSetCompleter(column) {
         columnMappings.add(it)
     }
 

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

@@ -25,15 +25,15 @@ import org.mybatis.dynamic.sql.util.Buildable
 typealias KotlinInsertCompleter<T> = KotlinInsertBuilder<T>.() -> Unit
 
 @MyBatisDslMarker
-class KotlinInsertBuilder<T> (private val row: T): Buildable<InsertModel<T>> {
+class KotlinInsertBuilder<T : Any> (private val row: T): Buildable<InsertModel<T>> {
     private var table: SqlTable? = null
     private val columnMappings = mutableListOf<AbstractColumnMapping>()
 
     fun into(table: SqlTable) {
         this.table = table
     }
 
-    fun <C : Any> map(column: SqlColumn<C>) = SingleRowInsertColumnMapCompleter(column) {
+    fun <C> map(column: SqlColumn<C>) = SingleRowInsertColumnMapCompleter(column) {
         columnMappings.add(it)
     }
 

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

@@ -27,7 +27,7 @@ import org.mybatis.dynamic.sql.util.ValueOrNullMapping
 import org.mybatis.dynamic.sql.util.ValueWhenPresentMapping
 
 @MyBatisDslMarker
-sealed class AbstractInsertColumnMapCompleter<T : Any>(
+sealed class AbstractInsertColumnMapCompleter<T>(
     internal val column: SqlColumn<T>,
     internal val mappingConsumer: (AbstractColumnMapping) -> Unit) {
 
@@ -38,15 +38,15 @@ sealed class AbstractInsertColumnMapCompleter<T : Any>(
     infix fun toStringConstant(constant: String) = mappingConsumer.invoke(StringConstantMapping.of(column, constant))
 }
 
-class MultiRowInsertColumnMapCompleter<T : Any>(
+class MultiRowInsertColumnMapCompleter<T>(
     column: SqlColumn<T>,
     mappingConsumer: (AbstractColumnMapping) -> Unit)
     : AbstractInsertColumnMapCompleter<T>(column, mappingConsumer) {
 
     infix fun toProperty(property: String) = mappingConsumer.invoke(PropertyMapping.of(column, property))
 }
 
-class SingleRowInsertColumnMapCompleter<T : Any>(
+class SingleRowInsertColumnMapCompleter<T>(
     column: SqlColumn<T>,
     mappingConsumer: (AbstractColumnMapping) -> Unit)
     : AbstractInsertColumnMapCompleter<T>(column, mappingConsumer) {
@@ -57,14 +57,14 @@ class SingleRowInsertColumnMapCompleter<T : Any>(
         mappingConsumer.invoke(PropertyWhenPresentMapping.of(column, property, valueSupplier))
 }
 
-class GeneralInsertColumnSetCompleter<T : Any>(
+class GeneralInsertColumnSetCompleter<T>(
     column: SqlColumn<T>,
     mappingConsumer: (AbstractColumnMapping) -> Unit)
     : AbstractInsertColumnMapCompleter<T>(column, mappingConsumer) {
 
-    infix fun toValue(value: T) = toValue { value }
+    infix fun toValue(value: T & Any) = toValue { value }
 
-    infix fun toValue(value: () -> T) = mappingConsumer.invoke(ValueMapping.of(column, value))
+    infix fun toValue(value: () -> T & Any) = mappingConsumer.invoke(ValueMapping.of(column, value))
 
     infix fun toValueOrNull(value: T?) = toValueOrNull { value }
 

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

@@ -25,15 +25,15 @@ import org.mybatis.dynamic.sql.util.Buildable
 typealias KotlinMultiRowInsertCompleter<T> = KotlinMultiRowInsertBuilder<T>.() -> Unit
 
 @MyBatisDslMarker
-class KotlinMultiRowInsertBuilder<T> (private val rows: Collection<T>): Buildable<MultiRowInsertModel<T>> {
+class KotlinMultiRowInsertBuilder<T : Any> (private val rows: Collection<T>): Buildable<MultiRowInsertModel<T>> {
     private var table: SqlTable? = null
     private val columnMappings = mutableListOf<AbstractColumnMapping>()
 
     fun into(table: SqlTable) {
         this.table = table
     }
 
-    fun <C : Any> map(column: SqlColumn<C>) = MultiRowInsertColumnMapCompleter(column) {
+    fun <C> map(column: SqlColumn<C>) = MultiRowInsertColumnMapCompleter(column) {
         columnMappings.add(it)
     }
 

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

@@ -50,9 +50,9 @@ class KotlinUpdateBuilder(private val dsl: UpdateDSL<UpdateModel>) :
                 set(column).equalToStringConstant(constant)
             }
 
-        infix fun equalTo(value: T): Unit = equalTo { value }
+        infix fun equalTo(value: T & Any): Unit = equalTo { value }
 
-        infix fun equalTo(value: () -> T): Unit =
+        infix fun equalTo(value: () -> T & Any): Unit =
             applyToDsl {
                 set(column).equalTo(value)
             }