List value conditions do not expect null values

Author: jeffgbutler

src/main/java/org/mybatis/dynamic/sql/AbstractListValueCondition.java

@@ -23,16 +23,14 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import org.jspecify.annotations.Nullable;
-
 public abstract class AbstractListValueCondition<T> implements VisitableCondition<T> {
-    protected final Collection<@Nullable T> values;
+    protected final Collection<T> values;
 
-    protected AbstractListValueCondition(Collection<@Nullable T> values) {
+    protected AbstractListValueCondition(Collection<T> values) {
         this.values = Objects.requireNonNull(values);
     }
 
-    public final Stream<@Nullable T> values() {
+    public final Stream<T> values() {
         return values.stream();
     }
 
@@ -46,18 +44,18 @@ public <R> R accept(ConditionVisitor<T, R> visitor) {
         return visitor.visit(this);
     }
 
-    private <R> Collection<R> applyMapper(Function<? super @Nullable T, ? extends @Nullable R> mapper) {
+    private <R> Collection<R> applyMapper(Function<? super T, ? extends R> mapper) {
         Objects.requireNonNull(mapper);
         return values.stream().map(mapper).collect(Collectors.toList());
     }
 
-    private Collection<T> applyFilter(Predicate<? super @Nullable T> predicate) {
+    private Collection<T> applyFilter(Predicate<? super T> predicate) {
         Objects.requireNonNull(predicate);
         return values.stream().filter(predicate).toList();
     }
 
-    protected <S extends AbstractListValueCondition<T>> S filterSupport(Predicate<? super @Nullable T> predicate,
-            Function<Collection<@Nullable T>, S> constructor, S self, Supplier<S> emptySupplier) {
+    protected <S extends AbstractListValueCondition<T>> S filterSupport(Predicate<? super T> predicate,
+            Function<Collection<T>, S> constructor, S self, Supplier<S> emptySupplier) {
         if (isEmpty()) {
             return self;
         } else {
@@ -66,9 +64,8 @@ protected <S extends AbstractListValueCondition<T>> S filterSupport(Predicate<?
         }
     }
 
-    protected <R, S extends AbstractListValueCondition<R>> S mapSupport(
-            Function<? super @Nullable T, ? extends @Nullable R> mapper,
-            Function<Collection<@Nullable R>, S> constructor, Supplier<S> emptySupplier) {
+    protected <R, S extends AbstractListValueCondition<R>> S mapSupport(Function<? super T, ? extends R> mapper,
+            Function<Collection<R>, S> constructor, Supplier<S> emptySupplier) {
         if (isEmpty()) {
             return emptySupplier.get();
         } else {
@@ -84,7 +81,7 @@ protected <R, S extends AbstractListValueCondition<R>> S mapSupport(
      *
      * @return a new condition with filtered values if renderable, otherwise an empty condition
      */
-    public abstract AbstractListValueCondition<T> filter(Predicate<? super @Nullable T> predicate);
+    public abstract AbstractListValueCondition<T> filter(Predicate<? super T> predicate);
 
     public abstract String operator();
 }

src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java

@@ -914,11 +914,11 @@ static IsNotLikeCaseInsensitive isNotLikeCaseInsensitiveWhenPresent(Supplier<@Nu
         return isNotLikeCaseInsensitiveWhenPresent(valueSupplier.get());
     }
 
-    static IsInCaseInsensitive isInCaseInsensitive(@Nullable String... values) {
+    static IsInCaseInsensitive isInCaseInsensitive(String... values) {
         return IsInCaseInsensitive.of(values);
     }
 
-    static IsInCaseInsensitive isInCaseInsensitive(Collection<@Nullable String> values) {
+    static IsInCaseInsensitive isInCaseInsensitive(Collection<String> values) {
         return IsInCaseInsensitive.of(values);
     }
 
@@ -931,11 +931,11 @@ static IsInCaseInsensitiveWhenPresent isInCaseInsensitiveWhenPresent(
         return values == null ? IsInCaseInsensitiveWhenPresent.empty() : IsInCaseInsensitiveWhenPresent.of(values);
     }
 
-    static IsNotInCaseInsensitive isNotInCaseInsensitive(@Nullable String... values) {
+    static IsNotInCaseInsensitive isNotInCaseInsensitive(String... values) {
         return IsNotInCaseInsensitive.of(values);
     }
 
-    static IsNotInCaseInsensitive isNotInCaseInsensitive(Collection<@Nullable String> values) {
+    static IsNotInCaseInsensitive isNotInCaseInsensitive(Collection<String> values) {
         return IsNotInCaseInsensitive.of(values);
     }
 

src/main/java/org/mybatis/dynamic/sql/where/condition/IsInCaseInsensitive.java

@@ -21,10 +21,8 @@
 import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 
-import org.jspecify.annotations.Nullable;
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
 import org.mybatis.dynamic.sql.render.RenderingContext;
-import org.mybatis.dynamic.sql.util.StringUtilities;
 import org.mybatis.dynamic.sql.util.Validator;
 
 public class IsInCaseInsensitive extends AbstractListValueCondition<String>
@@ -35,7 +33,7 @@ public static IsInCaseInsensitive empty() {
         return EMPTY;
     }
 
-    protected IsInCaseInsensitive(Collection<@Nullable String> values) {
+    protected IsInCaseInsensitive(Collection<String> values) {
         super(values);
     }
 
@@ -62,15 +60,15 @@ public IsInCaseInsensitive filter(Predicate<? super String> predicate) {
      * @param mapper a mapping function to apply to the values, if not empty
      * @return a new condition with mapped values if renderable, otherwise an empty condition
      */
-    public IsInCaseInsensitive map(UnaryOperator<@Nullable String> mapper) {
+    public IsInCaseInsensitive map(UnaryOperator<String> mapper) {
         return mapSupport(mapper, IsInCaseInsensitive::new, IsInCaseInsensitive::empty);
     }
 
-    public static IsInCaseInsensitive of(@Nullable String... values) {
+    public static IsInCaseInsensitive of(String... values) {
         return of(Arrays.asList(values));
     }
 
-    public static IsInCaseInsensitive of(Collection<@Nullable String> values) {
-        return new IsInCaseInsensitive(values).map(StringUtilities::safelyUpperCase);
+    public static IsInCaseInsensitive of(Collection<String> values) {
+        return new IsInCaseInsensitive(values).map(String::toUpperCase);
     }
 }

src/main/java/org/mybatis/dynamic/sql/where/condition/IsInCaseInsensitiveWhenPresent.java

@@ -23,7 +23,6 @@
 
 import org.jspecify.annotations.Nullable;
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
-import org.mybatis.dynamic.sql.util.StringUtilities;
 import org.mybatis.dynamic.sql.util.Utilities;
 
 public class IsInCaseInsensitiveWhenPresent extends AbstractListValueCondition<String>
@@ -57,7 +56,7 @@ public IsInCaseInsensitiveWhenPresent filter(Predicate<? super String> predicate
      * @param mapper a mapping function to apply to the values, if not empty
      * @return a new condition with mapped values if renderable, otherwise an empty condition
      */
-    public IsInCaseInsensitiveWhenPresent map(UnaryOperator<@Nullable String> mapper) {
+    public IsInCaseInsensitiveWhenPresent map(UnaryOperator<String> mapper) {
         return mapSupport(mapper, IsInCaseInsensitiveWhenPresent::new, IsInCaseInsensitiveWhenPresent::empty);
     }
 
@@ -66,6 +65,6 @@ public static IsInCaseInsensitiveWhenPresent of(@Nullable String... values) {
     }
 
     public static IsInCaseInsensitiveWhenPresent of(Collection<@Nullable String> values) {
-        return new IsInCaseInsensitiveWhenPresent(values).map(StringUtilities::safelyUpperCase);
+        return new IsInCaseInsensitiveWhenPresent(values).map(String::toUpperCase);
     }
 }

src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInCaseInsensitive.java

@@ -21,10 +21,8 @@
 import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 
-import org.jspecify.annotations.Nullable;
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
 import org.mybatis.dynamic.sql.render.RenderingContext;
-import org.mybatis.dynamic.sql.util.StringUtilities;
 import org.mybatis.dynamic.sql.util.Validator;
 
 public class IsNotInCaseInsensitive extends AbstractListValueCondition<String>
@@ -35,7 +33,7 @@ public static IsNotInCaseInsensitive empty() {
         return EMPTY;
     }
 
-    protected IsNotInCaseInsensitive(Collection<@Nullable String> values) {
+    protected IsNotInCaseInsensitive(Collection<String> values) {
         super(values);
     }
 
@@ -62,15 +60,15 @@ public IsNotInCaseInsensitive filter(Predicate<? super String> predicate) {
      * @param mapper a mapping function to apply to the values, if not empty
      * @return a new condition with mapped values if renderable, otherwise an empty condition
      */
-    public IsNotInCaseInsensitive map(UnaryOperator<@Nullable String> mapper) {
+    public IsNotInCaseInsensitive map(UnaryOperator<String> mapper) {
         return mapSupport(mapper, IsNotInCaseInsensitive::new, IsNotInCaseInsensitive::empty);
     }
 
-    public static IsNotInCaseInsensitive of(@Nullable String... values) {
+    public static IsNotInCaseInsensitive of(String... values) {
         return of(Arrays.asList(values));
     }
 
-    public static IsNotInCaseInsensitive of(Collection<@Nullable String> values) {
-        return new IsNotInCaseInsensitive(values).map(StringUtilities::safelyUpperCase);
+    public static IsNotInCaseInsensitive of(Collection<String> values) {
+        return new IsNotInCaseInsensitive(values).map(String::toUpperCase);
     }
 }

src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInCaseInsensitiveWhenPresent.java

@@ -23,7 +23,6 @@
 
 import org.jspecify.annotations.Nullable;
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
-import org.mybatis.dynamic.sql.util.StringUtilities;
 import org.mybatis.dynamic.sql.util.Utilities;
 
 public class IsNotInCaseInsensitiveWhenPresent extends AbstractListValueCondition<String>
@@ -57,7 +56,7 @@ public IsNotInCaseInsensitiveWhenPresent filter(Predicate<? super String> predic
      * @param mapper a mapping function to apply to the values, if not empty
      * @return a new condition with mapped values if renderable, otherwise an empty condition
      */
-    public IsNotInCaseInsensitiveWhenPresent map(UnaryOperator<@Nullable String> mapper) {
+    public IsNotInCaseInsensitiveWhenPresent map(UnaryOperator<String> mapper) {
         return mapSupport(mapper, IsNotInCaseInsensitiveWhenPresent::new, IsNotInCaseInsensitiveWhenPresent::empty);
     }
 
@@ -66,6 +65,6 @@ public static IsNotInCaseInsensitiveWhenPresent of(@Nullable String... values) {
     }
 
     public static IsNotInCaseInsensitiveWhenPresent of(Collection<@Nullable String> values) {
-        return new IsNotInCaseInsensitiveWhenPresent(values).map(StringUtilities::safelyUpperCase);
+        return new IsNotInCaseInsensitiveWhenPresent(values).map(String::toUpperCase);
     }
 }

src/main/java/org/mybatis/dynamic/sql/where/render/DefaultConditionVisitor.java

@@ -110,11 +110,11 @@ public FragmentAndParameters visit(AbstractColumnComparisonCondition<T> conditio
                 .mapFragment(f -> condition.operator() + spaceBefore(f));
     }
 
-    private @Nullable Object convertValue(@Nullable T value) {
+    private @Nullable Object convertValue(T value) {
         return column.convertParameterType(value);
     }
 
-    private FragmentAndParameters toFragmentAndParameters(@Nullable T value) {
+    private FragmentAndParameters toFragmentAndParameters(T value) {
         RenderedParameterInfo parameterInfo = renderingContext.calculateParameterInfo(column);
         return FragmentAndParameters.withFragment(parameterInfo.renderedPlaceHolder())
                 .withParameter(parameterInfo.parameterMapKey(), convertValue(value))

src/test/java/examples/animal/data/AnimalDataTest.java

@@ -744,7 +744,7 @@ void testInCaseSensitiveCondition() {
 
             SelectStatementProvider selectStatement = select(id, animalName, bodyWeight, brainWeight)
                     .from(animalData)
-                    .where(animalName, isInCaseInsensitive("yellow-bellied marmot", "verbet", null))
+                    .where(animalName, isInCaseInsensitive("yellow-bellied marmot", "verbet"))
                     .build()
                     .render(RenderingStrategies.MYBATIS3);
 
@@ -785,22 +785,6 @@ void testNotInCaseSensitiveCondition() {
         }
     }
 
-    @Test
-    void testNotInCaseSensitiveConditionWithNull() {
-        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
-            AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
-
-            SelectStatementProvider selectStatement = select(id, animalName, bodyWeight, brainWeight)
-                    .from(animalData)
-                    .where(animalName, isNotInCaseInsensitive((String)null))
-                    .build()
-                    .render(RenderingStrategies.MYBATIS3);
-
-            List<AnimalData> animals = mapper.selectMany(selectStatement);
-            assertThat(animals).isEmpty();
-        }
-    }
-
     @Test
     void testNotInConditionWithEventuallyEmptyList() {
         try (SqlSession sqlSession = sqlSessionFactory.openSession()) {