diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8dc2cb462..21e7cb3aa 100644
--- a/CHANGELOG.md
+++ b/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
 
diff --git a/pom.xml b/pom.xml
index 115294d7d..54741a889 100644
--- a/pom.xml
+++ b/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>
diff --git a/src/main/java/org/mybatis/dynamic/sql/delete/DeleteDSL.java b/src/main/java/org/mybatis/dynamic/sql/delete/DeleteDSL.java
index eba241267..4c06507b9 100644
--- a/src/main/java/org/mybatis/dynamic/sql/delete/DeleteDSL.java
+++ b/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);
     }
 
diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultInsertStatementProvider.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultInsertStatementProvider.java
index 9cdc67302..1fc9a54ae 100644
--- a/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultInsertStatementProvider.java
+++ b/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;
     }
diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/InsertStatementProvider.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/InsertStatementProvider.java
index 65d31882d..b5bd1d68c 100644
--- a/src/main/java/org/mybatis/dynamic/sql/insert/render/InsertStatementProvider.java
+++ b/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();
 
     /**
diff --git a/src/main/java/org/mybatis/dynamic/sql/update/render/SetPhraseVisitor.java b/src/main/java/org/mybatis/dynamic/sql/update/render/SetPhraseVisitor.java
index 0b2ef7359..de1937349 100644
--- a/src/main/java/org/mybatis/dynamic/sql/update/render/SetPhraseVisitor.java
+++ b/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();
     }
 
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/GroupingCriteriaCollector.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/GroupingCriteriaCollector.kt
index 2ccd6d4e4..5c3fdd697 100644
--- a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/GroupingCriteriaCollector.kt
+++ b/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
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinBatchInsertBuilder.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinBatchInsertBuilder.kt
index 0f278cd17..84e066dfb 100644
--- a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinBatchInsertBuilder.kt
+++ b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinBatchInsertBuilder.kt
@@ -25,7 +25,7 @@ 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>()
 
@@ -33,7 +33,7 @@ class KotlinBatchInsertBuilder<T> (private val rows: Collection<T>): Buildable<B
         this.table = table
     }
 
-    fun <C : Any> map(column: SqlColumn<C>) = MultiRowInsertColumnMapCompleter(column) {
+    fun <C> map(column: SqlColumn<C>) = MultiRowInsertColumnMapCompleter(column) {
         columnMappings.add(it)
     }
 
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinGeneralInsertBuilder.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinGeneralInsertBuilder.kt
index b7d402bbf..4562680af 100644
--- a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinGeneralInsertBuilder.kt
+++ b/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)
     }
 
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinInsertBuilder.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinInsertBuilder.kt
index ca2bee86e..fb7df5d38 100644
--- a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinInsertBuilder.kt
+++ b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinInsertBuilder.kt
@@ -25,7 +25,7 @@ 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>()
 
@@ -33,7 +33,7 @@ class KotlinInsertBuilder<T> (private val row: T): Buildable<InsertModel<T>> {
         this.table = table
     }
 
-    fun <C : Any> map(column: SqlColumn<C>) = SingleRowInsertColumnMapCompleter(column) {
+    fun <C> map(column: SqlColumn<C>) = SingleRowInsertColumnMapCompleter(column) {
         columnMappings.add(it)
     }
 
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinInsertColumnMapCompleters.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinInsertColumnMapCompleters.kt
index bd6012dae..cd2fa81d0 100644
--- a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinInsertColumnMapCompleters.kt
+++ b/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,7 +38,7 @@ 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) {
@@ -46,7 +46,7 @@ class MultiRowInsertColumnMapCompleter<T : Any>(
     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 }
 
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinMultiRowInsertBuilder.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinMultiRowInsertBuilder.kt
index 71f79f2a7..3a7a48a7f 100644
--- a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinMultiRowInsertBuilder.kt
+++ b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinMultiRowInsertBuilder.kt
@@ -25,7 +25,7 @@ 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>()
 
@@ -33,7 +33,7 @@ class KotlinMultiRowInsertBuilder<T> (private val rows: Collection<T>): Buildabl
         this.table = table
     }
 
-    fun <C : Any> map(column: SqlColumn<C>) = MultiRowInsertColumnMapCompleter(column) {
+    fun <C> map(column: SqlColumn<C>) = MultiRowInsertColumnMapCompleter(column) {
         columnMappings.add(it)
     }
 
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinUpdateBuilder.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinUpdateBuilder.kt
index 17933b69f..83f78c928 100644
--- a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinUpdateBuilder.kt
+++ b/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)
             }
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/elements/SqlElements.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/elements/SqlElements.kt
index 72e04a1bb..6190275cb 100644
--- a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/elements/SqlElements.kt
+++ b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/elements/SqlElements.kt
@@ -182,34 +182,34 @@ fun exists(subQuery: KotlinSubQueryBuilder.() -> Unit): ExistsPredicate =
 fun notExists(subQuery: KotlinSubQueryBuilder.() -> Unit): ExistsPredicate =
     SqlBuilder.notExists(KotlinSubQueryBuilder().apply(subQuery))
 
-fun <T : Any> isEqualTo(value: T): IsEqualTo<T> = SqlBuilder.isEqualTo(value)
+fun <T> isEqualTo(value: T & Any): IsEqualTo<T> = SqlBuilder.isEqualTo(value)
 
 fun <T> isEqualTo(subQuery: KotlinSubQueryBuilder.() -> Unit): IsEqualToWithSubselect<T> =
     SqlBuilder.isEqualTo(KotlinSubQueryBuilder().apply(subQuery))
 
 fun <T> isEqualTo(column: BasicColumn): IsEqualToColumn<T> = SqlBuilder.isEqualTo(column)
 
-fun <T : Any> isEqualToWhenPresent(value: T?): IsEqualTo<T> = SqlBuilder.isEqualToWhenPresent(value)
+fun <T> isEqualToWhenPresent(value: T?): IsEqualTo<T> = SqlBuilder.isEqualToWhenPresent(value)
 
-fun <T : Any> isNotEqualTo(value: T): IsNotEqualTo<T> = SqlBuilder.isNotEqualTo(value)
+fun <T> isNotEqualTo(value: T & Any): IsNotEqualTo<T> = SqlBuilder.isNotEqualTo(value)
 
 fun <T> isNotEqualTo(subQuery: KotlinSubQueryBuilder.() -> Unit): IsNotEqualToWithSubselect<T> =
     SqlBuilder.isNotEqualTo(KotlinSubQueryBuilder().apply(subQuery))
 
 fun <T> isNotEqualTo(column: BasicColumn): IsNotEqualToColumn<T> = SqlBuilder.isNotEqualTo(column)
 
-fun <T : Any> isNotEqualToWhenPresent(value: T?): IsNotEqualTo<T> = SqlBuilder.isNotEqualToWhenPresent(value)
+fun <T> isNotEqualToWhenPresent(value: T?): IsNotEqualTo<T> = SqlBuilder.isNotEqualToWhenPresent(value)
 
-fun <T : Any> isGreaterThan(value: T): IsGreaterThan<T> = SqlBuilder.isGreaterThan(value)
+fun <T> isGreaterThan(value: T & Any): IsGreaterThan<T> = SqlBuilder.isGreaterThan(value)
 
 fun <T> isGreaterThan(subQuery: KotlinSubQueryBuilder.() -> Unit): IsGreaterThanWithSubselect<T> =
     SqlBuilder.isGreaterThan(KotlinSubQueryBuilder().apply(subQuery))
 
 fun <T> isGreaterThan(column: BasicColumn): IsGreaterThanColumn<T> = SqlBuilder.isGreaterThan(column)
 
-fun <T : Any> isGreaterThanWhenPresent(value: T?): IsGreaterThan<T> = SqlBuilder.isGreaterThanWhenPresent(value)
+fun <T> isGreaterThanWhenPresent(value: T?): IsGreaterThan<T> = SqlBuilder.isGreaterThanWhenPresent(value)
 
-fun <T : Any> isGreaterThanOrEqualTo(value: T): IsGreaterThanOrEqualTo<T> = SqlBuilder.isGreaterThanOrEqualTo(value)
+fun <T> isGreaterThanOrEqualTo(value: T & Any): IsGreaterThanOrEqualTo<T> = SqlBuilder.isGreaterThanOrEqualTo(value)
 
 fun <T> isGreaterThanOrEqualTo(subQuery: KotlinSubQueryBuilder.() -> Unit): IsGreaterThanOrEqualToWithSubselect<T> =
     SqlBuilder.isGreaterThanOrEqualTo(KotlinSubQueryBuilder().apply(subQuery))
@@ -217,67 +217,67 @@ fun <T> isGreaterThanOrEqualTo(subQuery: KotlinSubQueryBuilder.() -> Unit): IsGr
 fun <T> isGreaterThanOrEqualTo(column: BasicColumn): IsGreaterThanOrEqualToColumn<T> =
     SqlBuilder.isGreaterThanOrEqualTo(column)
 
-fun <T : Any> isGreaterThanOrEqualToWhenPresent(value: T?): IsGreaterThanOrEqualTo<T> =
+fun <T> isGreaterThanOrEqualToWhenPresent(value: T?): IsGreaterThanOrEqualTo<T> =
     SqlBuilder.isGreaterThanOrEqualToWhenPresent(value)
 
-fun <T : Any> isLessThan(value: T): IsLessThan<T> = SqlBuilder.isLessThan(value)
+fun <T> isLessThan(value: T & Any): IsLessThan<T> = SqlBuilder.isLessThan(value)
 
 fun <T> isLessThan(subQuery: KotlinSubQueryBuilder.() -> Unit): IsLessThanWithSubselect<T> =
     SqlBuilder.isLessThan(KotlinSubQueryBuilder().apply(subQuery))
 
 fun <T> isLessThan(column: BasicColumn): IsLessThanColumn<T> = SqlBuilder.isLessThan(column)
 
-fun <T : Any> isLessThanWhenPresent(value: T?): IsLessThan<T> = SqlBuilder.isLessThanWhenPresent(value)
+fun <T> isLessThanWhenPresent(value: T?): IsLessThan<T> = SqlBuilder.isLessThanWhenPresent(value)
 
-fun <T : Any> isLessThanOrEqualTo(value: T): IsLessThanOrEqualTo<T> = SqlBuilder.isLessThanOrEqualTo(value)
+fun <T> isLessThanOrEqualTo(value: T & Any): IsLessThanOrEqualTo<T> = SqlBuilder.isLessThanOrEqualTo(value)
 
 fun <T> isLessThanOrEqualTo(subQuery: KotlinSubQueryBuilder.() -> Unit): IsLessThanOrEqualToWithSubselect<T> =
     SqlBuilder.isLessThanOrEqualTo(KotlinSubQueryBuilder().apply(subQuery))
 
 fun <T> isLessThanOrEqualTo(column: BasicColumn): IsLessThanOrEqualToColumn<T> = SqlBuilder.isLessThanOrEqualTo(column)
 
-fun <T : Any> isLessThanOrEqualToWhenPresent(value: T?): IsLessThanOrEqualTo<T> =
+fun <T> isLessThanOrEqualToWhenPresent(value: T?): IsLessThanOrEqualTo<T> =
     SqlBuilder.isLessThanOrEqualToWhenPresent(value)
 
-fun <T : Any> isIn(vararg values: T): IsIn<T> = isIn(values.asList())
+fun <T> isIn(vararg values: T & Any): IsIn<T> = isIn(values.asList())
 
-fun <T : Any> isIn(values: Collection<T>): IsIn<T> = SqlBuilder.isIn(values)
+fun <T> isIn(values: Collection<T & Any>): IsIn<T> = SqlBuilder.isIn(values)
 
 fun <T> isIn(subQuery: KotlinSubQueryBuilder.() -> Unit): IsInWithSubselect<T> =
     SqlBuilder.isIn(KotlinSubQueryBuilder().apply(subQuery))
 
-fun <T : Any> isInWhenPresent(vararg values: T?): IsIn<T> = isInWhenPresent(values.asList())
+fun <T> isInWhenPresent(vararg values: T?): IsIn<T> = isInWhenPresent(values.asList())
 
-fun <T : Any> isInWhenPresent(values: Collection<T?>?): IsIn<T> = SqlBuilder.isInWhenPresent(values)
+fun <T> isInWhenPresent(values: Collection<T?>?): IsIn<T> = SqlBuilder.isInWhenPresent(values)
 
-fun <T : Any> isNotIn(vararg values: T): IsNotIn<T> = isNotIn(values.asList())
+fun <T> isNotIn(vararg values: T & Any): IsNotIn<T> = isNotIn(values.asList())
 
-fun <T : Any> isNotIn(values: Collection<T>): IsNotIn<T> = SqlBuilder.isNotIn(values)
+fun <T> isNotIn(values: Collection<T & Any>): IsNotIn<T> = SqlBuilder.isNotIn(values)
 
 fun <T> isNotIn(subQuery: KotlinSubQueryBuilder.() -> Unit): IsNotInWithSubselect<T> =
     SqlBuilder.isNotIn(KotlinSubQueryBuilder().apply(subQuery))
 
-fun <T : Any> isNotInWhenPresent(vararg values: T?): IsNotIn<T> = isNotInWhenPresent(values.asList())
+fun <T> isNotInWhenPresent(vararg values: T?): IsNotIn<T> = isNotInWhenPresent(values.asList())
 
-fun <T : Any> isNotInWhenPresent(values: Collection<T?>?): IsNotIn<T> = SqlBuilder.isNotInWhenPresent(values)
+fun <T> isNotInWhenPresent(values: Collection<T?>?): IsNotIn<T> = SqlBuilder.isNotInWhenPresent(values)
 
-fun <T : Any> isBetween(value1: T): BetweenBuilder<T> = BetweenBuilder(value1)
+fun <T> isBetween(value1: T & Any): BetweenBuilder<T & Any> = BetweenBuilder(value1)
 
-fun <T : Any> isBetweenWhenPresent(value1: T?): BetweenWhenPresentBuilder<T> = BetweenWhenPresentBuilder(value1)
+fun <T> isBetweenWhenPresent(value1: T?): BetweenWhenPresentBuilder<T> = BetweenWhenPresentBuilder(value1)
 
-fun <T : Any> isNotBetween(value1: T): NotBetweenBuilder<T> = NotBetweenBuilder(value1)
+fun <T> isNotBetween(value1: T & Any): NotBetweenBuilder<T & Any> = NotBetweenBuilder(value1)
 
-fun <T : Any> isNotBetweenWhenPresent(value1: T?): NotBetweenWhenPresentBuilder<T> =
+fun <T> isNotBetweenWhenPresent(value1: T?): NotBetweenWhenPresentBuilder<T> =
     NotBetweenWhenPresentBuilder(value1)
 
 // for string columns, but generic for columns with type handlers
-fun <T : Any> isLike(value: T): IsLike<T> = SqlBuilder.isLike(value)
+fun <T> isLike(value: T & Any): IsLike<T> = SqlBuilder.isLike(value)
 
-fun <T : Any> isLikeWhenPresent(value: T?): IsLike<T> = SqlBuilder.isLikeWhenPresent(value)
+fun <T> isLikeWhenPresent(value: T?): IsLike<T> = SqlBuilder.isLikeWhenPresent(value)
 
-fun <T : Any> isNotLike(value: T): IsNotLike<T> = SqlBuilder.isNotLike(value)
+fun <T> isNotLike(value: T & Any): IsNotLike<T> = SqlBuilder.isNotLike(value)
 
-fun <T : Any> isNotLikeWhenPresent(value: T?): IsNotLike<T> = SqlBuilder.isNotLikeWhenPresent(value)
+fun <T> isNotLikeWhenPresent(value: T?): IsNotLike<T> = SqlBuilder.isNotLikeWhenPresent(value)
 
 // shortcuts for booleans
 fun isTrue(): IsEqualTo<Boolean> = isEqualTo(true)
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/model/ModelBuilderFunctions.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/model/ModelBuilderFunctions.kt
index 2e5216133..45478711e 100644
--- a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/model/ModelBuilderFunctions.kt
+++ b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/model/ModelBuilderFunctions.kt
@@ -65,16 +65,16 @@ fun deleteFrom(table: SqlTable, completer: DeleteCompleter): DeleteModel =
 fun deleteFrom(table: SqlTable, tableAlias: String, completer: DeleteCompleter): DeleteModel =
     KotlinDeleteBuilder(SqlBuilder.deleteFrom(table, tableAlias)).apply(completer).build()
 
-fun <T> insert(row: T, completer: KotlinInsertCompleter<T>): InsertModel<T> =
+fun <T : Any> insert(row: T, completer: KotlinInsertCompleter<T>): InsertModel<T> =
     KotlinInsertBuilder(row).apply(completer).build()
 
-fun <T> insertBatch(rows: Collection<T>, completer: KotlinBatchInsertCompleter<T>): BatchInsertModel<T> =
+fun <T : Any> insertBatch(rows: Collection<T>, completer: KotlinBatchInsertCompleter<T>): BatchInsertModel<T> =
     KotlinBatchInsertBuilder(rows).apply(completer).build()
 
 fun insertInto(table: SqlTable, completer: GeneralInsertCompleter): GeneralInsertModel =
     KotlinGeneralInsertBuilder(table).apply(completer).build()
 
-fun <T> insertMultiple(rows: Collection<T>, completer: KotlinMultiRowInsertCompleter<T>): MultiRowInsertModel<T> =
+fun <T : Any> insertMultiple(rows: Collection<T>, completer: KotlinMultiRowInsertCompleter<T>): MultiRowInsertModel<T> =
     KotlinMultiRowInsertBuilder(rows).apply(completer).build()
 
 fun insertSelect(table: SqlTable, completer: InsertSelectCompleter): InsertSelectModel =
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/mybatis3/MapperSupportFunctions.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/mybatis3/MapperSupportFunctions.kt
index fa4643563..941be61af 100644
--- a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/mybatis3/MapperSupportFunctions.kt
+++ b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/mybatis3/MapperSupportFunctions.kt
@@ -63,7 +63,7 @@ fun countFrom(mapper: (SelectStatementProvider) -> Long, table: SqlTable, comple
 fun deleteFrom(mapper: (DeleteStatementProvider) -> Int, table: SqlTable, completer: DeleteCompleter): Int =
     deleteFrom(table, completer).run(mapper)
 
-fun <T> insert(
+fun <T : Any> insert(
     mapper: (InsertStatementProvider<T>) -> Int,
     row: T,
     table: SqlTable,
@@ -81,7 +81,7 @@ fun <T> insert(
  * list will be [org.apache.ibatis.executor.BatchExecutor.BATCH_UPDATE_RETURN_VALUE]).
  * To retrieve update counts, execute [org.apache.ibatis.session.SqlSession.flushStatements].
  */
-fun <T> insertBatch(
+fun <T : Any> insertBatch(
     mapper: (InsertStatementProvider<T>) -> Int,
     records: Collection<T>,
     table: SqlTable,
@@ -99,7 +99,7 @@ fun insertInto(
 ): Int =
     insertInto(table, completer).run(mapper)
 
-fun <T> insertMultiple(
+fun <T : Any> insertMultiple(
     mapper: (MultiRowInsertStatementProvider<T>) -> Int,
     records: Collection<T>,
     table: SqlTable,
@@ -110,7 +110,7 @@ fun <T> insertMultiple(
         run(completer)
     }.run(mapper)
 
-fun <T> insertMultipleWithGeneratedKeys(
+fun <T : Any> insertMultipleWithGeneratedKeys(
     mapper: (String, List<T>) -> Int,
     records: Collection<T>,
     table: SqlTable,
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/mybatis3/ProviderBuilderFunctions.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/mybatis3/ProviderBuilderFunctions.kt
index e58e7c707..2b1950b77 100644
--- a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/mybatis3/ProviderBuilderFunctions.kt
+++ b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/mybatis3/ProviderBuilderFunctions.kt
@@ -68,16 +68,16 @@ fun deleteFrom(table: SqlTable, completer: DeleteCompleter): DeleteStatementProv
 fun deleteFrom(table: SqlTable, tableAlias: String, completer: DeleteCompleter): DeleteStatementProvider =
     deleteFrom(table, tableAlias, completer).render(RenderingStrategies.MYBATIS3)
 
-fun <T> insert(row: T, completer: KotlinInsertCompleter<T>): InsertStatementProvider<T> =
+fun <T : Any> insert(row: T, completer: KotlinInsertCompleter<T>): InsertStatementProvider<T> =
     insert(row, completer).render(RenderingStrategies.MYBATIS3)
 
-fun <T> insertBatch(rows: Collection<T>, completer: KotlinBatchInsertCompleter<T>): BatchInsert<T> =
+fun <T : Any> insertBatch(rows: Collection<T>, completer: KotlinBatchInsertCompleter<T>): BatchInsert<T> =
     insertBatch(rows, completer).render(RenderingStrategies.MYBATIS3)
 
 fun insertInto(table: SqlTable, completer: GeneralInsertCompleter): GeneralInsertStatementProvider =
     insertInto(table, completer).render(RenderingStrategies.MYBATIS3)
 
-fun <T> insertMultiple(
+fun <T : Any> insertMultiple(
     rows: Collection<T>,
     completer: KotlinMultiRowInsertCompleter<T>
 ): MultiRowInsertStatementProvider<T> =
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/NamedParameterJdbcTemplateExtensions.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/NamedParameterJdbcTemplateExtensions.kt
index 20d1b4663..6bf0ebe2b 100644
--- a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/NamedParameterJdbcTemplateExtensions.kt
+++ b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/NamedParameterJdbcTemplateExtensions.kt
@@ -89,10 +89,10 @@ fun <T : Any> NamedParameterJdbcTemplate.insertBatch(records: List<T>): BatchIns
     BatchInsertHelper(records, this)
 
 // single row insert
-fun <T : Any> NamedParameterJdbcTemplate.insert(insertStatement: InsertStatementProvider<T>): Int =
+fun <T> NamedParameterJdbcTemplate.insert(insertStatement: InsertStatementProvider<T>): Int =
     update(insertStatement.insertStatement, BeanPropertySqlParameterSource(insertStatement.row))
 
-fun <T : Any> NamedParameterJdbcTemplate.insert(
+fun <T> NamedParameterJdbcTemplate.insert(
     insertStatement: InsertStatementProvider<T>,
     keyHolder: KeyHolder
 ): Int =
@@ -120,8 +120,8 @@ fun NamedParameterJdbcTemplate.insertInto(table: SqlTable, completer: GeneralIns
 
 // multiple row insert
 fun <T : Any> NamedParameterJdbcTemplate.insertMultiple(
-    vararg records: T
-    , completer: KotlinMultiRowInsertCompleter<T>
+    vararg records: T,
+    completer: KotlinMultiRowInsertCompleter<T>
 ): Int =
     insertMultiple(records.asList(), completer)
 
@@ -205,7 +205,7 @@ fun <T> NamedParameterJdbcTemplate.selectList(
 fun <T : Any> NamedParameterJdbcTemplate.selectList(
     selectStatement: SelectStatementProvider,
     type: KClass<T>
-): List<T?> =
+): List<T> =
     queryForList(selectStatement.selectStatement, selectStatement.parameters, type.java)
 
 fun NamedParameterJdbcTemplate.selectOne(
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/ProviderBuilderFunctions.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/ProviderBuilderFunctions.kt
index 7fcb6bd39..fcb70e746 100644
--- a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/ProviderBuilderFunctions.kt
+++ b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/ProviderBuilderFunctions.kt
@@ -68,16 +68,16 @@ fun deleteFrom(table: SqlTable, completer: DeleteCompleter): DeleteStatementProv
 fun deleteFrom(table: SqlTable, tableAlias: String, completer: DeleteCompleter): DeleteStatementProvider =
     deleteFrom(table, tableAlias, completer).render(RenderingStrategies.SPRING_NAMED_PARAMETER)
 
-fun <T> insert(row: T, completer: KotlinInsertCompleter<T>): InsertStatementProvider<T> =
+fun <T : Any> insert(row: T, completer: KotlinInsertCompleter<T>): InsertStatementProvider<T> =
     insert(row, completer).render(RenderingStrategies.SPRING_NAMED_PARAMETER)
 
-fun <T> insertBatch(rows: Collection<T>, completer: KotlinBatchInsertCompleter<T>): BatchInsert<T> =
+fun <T : Any> insertBatch(rows: Collection<T>, completer: KotlinBatchInsertCompleter<T>): BatchInsert<T> =
     insertBatch(rows, completer).render(RenderingStrategies.SPRING_NAMED_PARAMETER)
 
 fun insertInto(table: SqlTable, completer: GeneralInsertCompleter): GeneralInsertStatementProvider =
     insertInto(table, completer).render(RenderingStrategies.SPRING_NAMED_PARAMETER)
 
-fun <T> insertMultiple(
+fun <T : Any> insertMultiple(
     rows: Collection<T>,
     completer: KotlinMultiRowInsertCompleter<T>
 ): MultiRowInsertStatementProvider<T> =
diff --git a/src/test/kotlin/nullability/test/BetweenTest.kt b/src/test/kotlin/nullability/test/BetweenTest.kt
new file mode 100644
index 000000000..31da32afa
--- /dev/null
+++ b/src/test/kotlin/nullability/test/BetweenTest.kt
@@ -0,0 +1,150 @@
+/*
+ *    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 nullability.test
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class BetweenTest {
+    @Test
+    fun `Test That First Null Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isBetween null and 4 }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(9, 30)))
+    }
+
+    @Test
+    fun `Test That Second Null Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isBetween 4 and null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(9, 36)))
+    }
+
+    @Test
+    fun `Test That Both Null Causes Two Compile Errors`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isBetween null and null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(
+            ErrorLocation(9, 30),
+            ErrorLocation(9, 39)
+        ))
+    }
+
+    @Test
+    fun `Test That First Null In Elements Method Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isBetween
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isBetween<Int>(null).and(4)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 36)))
+    }
+
+    @Test
+    fun `Test That Second Null In Elements Method Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isBetween
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isBetween(4).and(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 38)))
+    }
+
+    @Test
+    fun `Test That Both Null In Elements Method Causes Two Compile Errors`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isBetween
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isBetween<Int>(null).and(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(
+            ErrorLocation(10, 36),
+            ErrorLocation(10, 46)
+        ))
+    }
+}
diff --git a/src/test/kotlin/nullability/test/BetweenWhenPresentTest.kt b/src/test/kotlin/nullability/test/BetweenWhenPresentTest.kt
new file mode 100644
index 000000000..f0ec0076b
--- /dev/null
+++ b/src/test/kotlin/nullability/test/BetweenWhenPresentTest.kt
@@ -0,0 +1,144 @@
+/*
+ *    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 nullability.test
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class BetweenWhenPresentTest {
+    @Test
+    fun `Test That First Null Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isBetweenWhenPresent null and 4 }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Second Null Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isBetweenWhenPresent 4 and null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Both Null Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isBetweenWhenPresent null and null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That First Null In Elements Method Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isBetweenWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isBetweenWhenPresent<Int>(null).and(4)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Second Null In Elements Method Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isBetweenWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isBetweenWhenPresent(4).and(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Both Null In Elements Method Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isBetweenWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isBetweenWhenPresent<Int>(null).and(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+}
diff --git a/src/test/kotlin/nullability/test/ComparisonTest.kt b/src/test/kotlin/nullability/test/ComparisonTest.kt
new file mode 100644
index 000000000..3ca3cd088
--- /dev/null
+++ b/src/test/kotlin/nullability/test/ComparisonTest.kt
@@ -0,0 +1,513 @@
+/*
+ *    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 nullability.test
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class ComparisonTest {
+    @Test
+    fun `Test That Null In EqualTo Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isEqualTo null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(9, 30)))
+    }
+
+    @Test
+    fun `Test That Null In EqualToWhenPresent is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isEqualToWhenPresent null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null In EqualTo Elements Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isEqualTo
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isEqualTo(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 31)))
+    }
+
+    @Test
+    fun `Test That Null In EqualToWhenPresent Elements is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isEqualToWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isEqualToWhenPresent(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null In NotEqualTo Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isNotEqualTo null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(9, 33)))
+    }
+
+    @Test
+    fun `Test That Null In NotEqualToWhenPresent is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isNotEqualToWhenPresent null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null In NotEqualTo Elements Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotEqualTo
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isNotEqualTo(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 34)))
+    }
+
+    @Test
+    fun `Test That Null In NotEqualToWhenPresent Elements is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotEqualToWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isNotEqualToWhenPresent(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null In GreaterThan Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isGreaterThan null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(9, 34)))
+    }
+
+    @Test
+    fun `Test That Null In GreaterThanWhenPresent is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isGreaterThanWhenPresent null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null In GreaterThan Elements Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isGreaterThan
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isGreaterThan(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 35)))
+    }
+
+    @Test
+    fun `Test That Null In GreaterThanWhenPresent Elements is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isGreaterThanWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isGreaterThanWhenPresent(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null In GreaterThanOrEqualTo Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isGreaterThanOrEqualTo null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(9, 43)))
+    }
+
+    @Test
+    fun `Test That Null In GreaterThanOrEqualToWhenPresent is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isGreaterThanOrEqualToWhenPresent null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null In GreaterThanOrEqualTo Elements Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isGreaterThanOrEqualTo
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isGreaterThanOrEqualTo(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 44)))
+    }
+
+    @Test
+    fun `Test That Null In GreaterThanOrEqualToWhenPresent Elements is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isGreaterThanOrEqualToWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isGreaterThanOrEqualToWhenPresent(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null In LessThan Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isLessThan null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(9, 31)))
+    }
+
+    @Test
+    fun `Test That Null In LessThanWhenPresent is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isLessThanWhenPresent null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null In LessThan Elements Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isLessThan
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isLessThan(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 32)))
+    }
+
+    @Test
+    fun `Test That Null In LessThanWhenPresent Elements is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isLessThanWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isLessThanWhenPresent(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null In LessThanOrEqualTo Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isLessThanOrEqualTo null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(9, 40)))
+    }
+
+    @Test
+    fun `Test That Null In LessThanOrEqualToWhenPresent is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isLessThanOrEqualToWhenPresent null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null In LessThanOrEqualTo Elements Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isLessThanOrEqualTo
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isLessThanOrEqualTo(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 41)))
+    }
+
+    @Test
+    fun `Test That Null In LessThanOrEqualToWhenPresent Elements is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isLessThanOrEqualToWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isLessThanOrEqualToWhenPresent(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+}
diff --git a/src/test/kotlin/nullability/test/CompilerUtilities.kt b/src/test/kotlin/nullability/test/CompilerUtilities.kt
new file mode 100644
index 000000000..0e2266191
--- /dev/null
+++ b/src/test/kotlin/nullability/test/CompilerUtilities.kt
@@ -0,0 +1,72 @@
+/*
+ *    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 nullability.test
+
+import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
+import org.jetbrains.kotlin.cli.common.messages.MessageCollector
+import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
+import org.jetbrains.kotlin.config.Services
+import java.io.File
+
+/**
+ * Compiles the source lines and returns any error reports generated by the compiler.
+ */
+fun compile(source: String): CompilerErrorMessageCollector {
+    val file: File = File.createTempFile("KotlinTest", ".kt")
+    file.deleteOnExit()
+    // normalize line endings and write to temp file
+    file.writeText(source.trimIndent().lines().joinToString(separator = System.lineSeparator()))
+
+    val compilerArgs = K2JVMCompilerArguments().apply {
+        freeArgs = listOf(file.path)
+        destination = System.getProperty("java.io.tmpdir")
+        classpath = System.getProperty("java.class.path")
+        noStdlib = true
+    }
+
+    return CompilerErrorMessageCollector().apply {
+        K2JVMCompiler().exec(this, Services.EMPTY, compilerArgs)
+    }
+}
+
+class CompilerErrorMessageCollector: MessageCollector {
+    val reports = mutableListOf<CompilerErrorReport>()
+     override fun clear() = reports.clear()
+
+    override fun hasErrors() = reports.any { it.severity.isError }
+
+    override fun report(
+        severity: CompilerMessageSeverity,
+        message: String,
+        location: CompilerMessageSourceLocation?
+    ) {
+        reports.add(CompilerErrorReport(severity, message, location))
+    }
+
+    fun errorLocations() =
+        reports.filter { it.severity.isError }
+            .mapNotNull { it.location }
+            .map { ErrorLocation(it.line, it.column) }
+}
+
+data class CompilerErrorReport(
+    val severity: CompilerMessageSeverity,
+    val message: String,
+    val location: CompilerMessageSourceLocation?
+)
+data class ErrorLocation(val line: Int, val column: Int)
diff --git a/src/test/kotlin/nullability/test/EqualNotEqualTest.kt b/src/test/kotlin/nullability/test/EqualNotEqualTest.kt
new file mode 100644
index 000000000..27dadff36
--- /dev/null
+++ b/src/test/kotlin/nullability/test/EqualNotEqualTest.kt
@@ -0,0 +1,187 @@
+/*
+ *    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 nullability.test
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class EqualNotEqualTest {
+    @Test
+    fun `Test That Null Equal Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { firstName isEqualTo null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(9, 37)))
+    }
+
+    @Test
+    fun `Test That Null Equal When Present is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { firstName isEqualToWhenPresent null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null Not Equal Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                val ids = listOf(4, null)
+                countFrom(person) {
+                    where { firstName isNotEqualTo null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 40)))
+    }
+
+    @Test
+    fun `Test That Null Not Equal When Present is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { firstName isNotEqualToWhenPresent null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null Elements Equal Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isEqualTo
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { firstName (isEqualTo(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 38)))
+    }
+
+    @Test
+    fun `Test That Null Elements Equal When Present is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isEqualToWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { firstName (isEqualToWhenPresent(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null Elements Not Equal Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotEqualTo
+
+            fun testFunction() {
+                val ids = listOf(4, null)
+                countFrom(person) {
+                    where { firstName (isNotEqualTo(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(11, 41)))
+    }
+
+    @Test
+    fun `Test That Null Elements Not Equal When Present is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotEqualToWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { firstName (isNotEqualToWhenPresent(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+}
diff --git a/src/test/kotlin/nullability/test/InTest.kt b/src/test/kotlin/nullability/test/InTest.kt
new file mode 100644
index 000000000..7010b53e7
--- /dev/null
+++ b/src/test/kotlin/nullability/test/InTest.kt
@@ -0,0 +1,105 @@
+/*
+ *    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 nullability.test
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class InTest {
+    @Test
+    fun `Test That Null In VarAgs Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id.isIn(4, null) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(9, 28)))
+    }
+
+    @Test
+    fun `Test That Null in List Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                val ids = listOf(4, null)
+                countFrom(person) {
+                    where { id isIn ids }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 25)))
+    }
+
+    @Test
+    fun `Test That Null In VarArgs Elements Method Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isIn
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isIn(4, null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 29)))
+    }
+
+    @Test
+    fun `Test That Null In List Elements Method Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isIn
+
+            fun testFunction() {
+                val ids = listOf(4, null)
+                countFrom(person) {
+                    where { id (isIn(ids)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(11, 26)))
+    }
+}
diff --git a/src/test/kotlin/nullability/test/InWhenPresentTest.kt b/src/test/kotlin/nullability/test/InWhenPresentTest.kt
new file mode 100644
index 000000000..307e5255b
--- /dev/null
+++ b/src/test/kotlin/nullability/test/InWhenPresentTest.kt
@@ -0,0 +1,187 @@
+/*
+ *    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 nullability.test
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class InWhenPresentTest {
+    @Test
+    fun `Test That Null In VarAgs Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id.isInWhenPresent(4, null) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null in List Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                val ids = listOf(4, null)
+                countFrom(person) {
+                    where { id isInWhenPresent ids }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Empty VarAgs Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id.isInWhenPresent() }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null List Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id.isInWhenPresent(null as List<Int>) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null In VarArgs Elements Method Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isInWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isInWhenPresent(4, null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null In List Elements Method Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isInWhenPresent
+
+            fun testFunction() {
+                val ids = listOf(4, null)
+                countFrom(person) {
+                    where { id (isInWhenPresent(ids)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Empty VarAgs In Elements Method Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isInWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isInWhenPresent()) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null List In Elements Method Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isInWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isInWhenPresent(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+}
diff --git a/src/test/kotlin/nullability/test/LikeNotLikeTest.kt b/src/test/kotlin/nullability/test/LikeNotLikeTest.kt
new file mode 100644
index 000000000..2b9de75b9
--- /dev/null
+++ b/src/test/kotlin/nullability/test/LikeNotLikeTest.kt
@@ -0,0 +1,187 @@
+/*
+ *    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 nullability.test
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class LikeNotLikeTest {
+    @Test
+    fun `Test That Null Like Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { firstName isLike null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(9, 34)))
+    }
+
+    @Test
+    fun `Test That Null Like When Present is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { firstName isLikeWhenPresent null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null Not Like Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                val ids = listOf(4, null)
+                countFrom(person) {
+                    where { firstName isNotLike null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 37)))
+    }
+
+    @Test
+    fun `Test That Null Not Like When Present is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { firstName isNotLikeWhenPresent null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null Elements Like Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isLike
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { firstName (isLike(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 35)))
+    }
+
+    @Test
+    fun `Test That Null Elements Like When Present is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isLikeWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { firstName (isLikeWhenPresent(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null Elements Not Like Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotLike
+
+            fun testFunction() {
+                val ids = listOf(4, null)
+                countFrom(person) {
+                    where { firstName (isNotLike(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(11, 38)))
+    }
+
+    @Test
+    fun `Test That Null Elements Not Like When Present is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.firstName
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotLikeWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { firstName (isNotLikeWhenPresent(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+}
diff --git a/src/test/kotlin/nullability/test/NotBetweenTest.kt b/src/test/kotlin/nullability/test/NotBetweenTest.kt
new file mode 100644
index 000000000..8bc76fcea
--- /dev/null
+++ b/src/test/kotlin/nullability/test/NotBetweenTest.kt
@@ -0,0 +1,150 @@
+/*
+ *    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 nullability.test
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class NotBetweenTest {
+    @Test
+    fun `Test That First Null Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isNotBetween null and 4 }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(9, 33)))
+    }
+
+    @Test
+    fun `Test That Second Null Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isNotBetween 4 and null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(9, 39)))
+    }
+
+    @Test
+    fun `Test That Both Null Causes Compile Errors`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isNotBetween null and null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(
+            ErrorLocation(9, 33),
+            ErrorLocation(9, 42)
+        ))
+    }
+
+    @Test
+    fun `Test That First Null In Elements Method Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotBetween
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isNotBetween<Int>(null).and(4)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 39)))
+    }
+
+    @Test
+    fun `Test That Second Null In Elements Method Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotBetween
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isNotBetween(4).and(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 41)))
+    }
+
+    @Test
+    fun `Test That Both Null In Elements Method Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotBetween
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isNotBetween<Int>(null).and(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(
+            ErrorLocation(10, 39),
+            ErrorLocation(10, 49)
+        ))
+    }
+}
diff --git a/src/test/kotlin/nullability/test/NotBetweenWhenPresentTest.kt b/src/test/kotlin/nullability/test/NotBetweenWhenPresentTest.kt
new file mode 100644
index 000000000..3faa85a6b
--- /dev/null
+++ b/src/test/kotlin/nullability/test/NotBetweenWhenPresentTest.kt
@@ -0,0 +1,144 @@
+/*
+ *    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 nullability.test
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class NotBetweenWhenPresentTest {
+    @Test
+    fun `Test That First Null Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isNotBetweenWhenPresent null and 4 }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Second Null Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isNotBetweenWhenPresent 4 and null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Both Null Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id isNotBetweenWhenPresent null and null }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That First Null In Elements Method Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotBetweenWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isNotBetweenWhenPresent<Int>(null).and(4)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Second Null In Elements Method Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotBetweenWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isNotBetweenWhenPresent(4).and(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Both Null In Elements Method Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotBetweenWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isNotBetweenWhenPresent<Int>(null).and(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+}
diff --git a/src/test/kotlin/nullability/test/NotInTest.kt b/src/test/kotlin/nullability/test/NotInTest.kt
new file mode 100644
index 000000000..f8e7d7ff3
--- /dev/null
+++ b/src/test/kotlin/nullability/test/NotInTest.kt
@@ -0,0 +1,105 @@
+/*
+ *    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 nullability.test
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class NotInTest {
+    @Test
+    fun `Test That Null In VarAgs Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id.isNotIn(4, null) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(9, 31)))
+    }
+
+    @Test
+    fun `Test That Null in List Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                val ids = listOf(4, null)
+                countFrom(person) {
+                    where { id isNotIn ids }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 28)))
+    }
+
+    @Test
+    fun `Test That Null In VarArgs Elements Method Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotIn
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isNotIn(4, null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(10, 32)))
+    }
+
+    @Test
+    fun `Test That Null In List Elements Method Causes Compile Error`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotIn
+
+            fun testFunction() {
+                val ids = listOf(4, null)
+                countFrom(person) {
+                    where { id (isNotIn(ids)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.errorLocations()).isEqualTo(listOf(ErrorLocation(11, 29)))
+    }
+}
diff --git a/src/test/kotlin/nullability/test/NotInWhenPresentTest.kt b/src/test/kotlin/nullability/test/NotInWhenPresentTest.kt
new file mode 100644
index 000000000..99e57f43c
--- /dev/null
+++ b/src/test/kotlin/nullability/test/NotInWhenPresentTest.kt
@@ -0,0 +1,187 @@
+/*
+ *    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 nullability.test
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class NotInWhenPresentTest {
+    @Test
+    fun `Test That Null In VarAgs Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id.isNotInWhenPresent(4, null) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null in List Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                val ids = listOf(4, null)
+                countFrom(person) {
+                    where { id isNotInWhenPresent ids }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Empty VarAgs Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id.isNotInWhenPresent() }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null List Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id.isNotInWhenPresent(null as List<Int>) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null In VarArgs Elements Method Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotInWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isNotInWhenPresent(4, null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null In List Elements Method Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotInWhenPresent
+
+            fun testFunction() {
+                val ids = listOf(4, null)
+                countFrom(person) {
+                    where { id (isNotInWhenPresent(ids)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Empty VarAgs In Elements Method Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotInWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isNotInWhenPresent()) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+
+    @Test
+    fun `Test That Null List In Elements Method Is OK`() {
+        val source = """
+            package temp.kotlin.test
+            
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.id
+            import examples.kotlin.mybatis3.canonical.PersonDynamicSqlSupport.person
+            import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+            import org.mybatis.dynamic.sql.util.kotlin.elements.isNotInWhenPresent
+
+            fun testFunction() {
+                countFrom(person) {
+                    where { id (isNotInWhenPresent(null)) }
+                }
+            }
+        """
+
+        val compilerMessageCollector = compile(source)
+        assertThat(compilerMessageCollector.hasErrors()).isFalse
+    }
+}