List value conditions do not expect null values

jeffgbutler · jeffgbutler · commit e6eef016ef55 · 2025-01-03T14:20:13.000-05:00
diff --git a/src/main/java/org/mybatis/dynamic/sql/AbstractListValueCondition.java b/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();
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java b/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);
     }
 
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsInCaseInsensitive.java b/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);
     }
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsInCaseInsensitiveWhenPresent.java b/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);
     }
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInCaseInsensitive.java b/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);
     }
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInCaseInsensitiveWhenPresent.java b/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);
     }
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/render/DefaultConditionVisitor.java b/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))
diff --git a/src/test/java/examples/animal/data/AnimalDataTest.java b/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()) {

Original file line number	Diff line number	Diff line change
`@@ -914,11 +914,11 @@ static IsNotLikeCaseInsensitive isNotLikeCaseInsensitiveWhenPresent(Supplier<@Nu`
`914`	`914`	`return isNotLikeCaseInsensitiveWhenPresent(valueSupplier.get());`
`915`	`915`	`}`
`916`	`916`
`917`		`- static IsInCaseInsensitive isInCaseInsensitive(@Nullable String... values) {`
	`917`	`+ static IsInCaseInsensitive isInCaseInsensitive(String... values) {`
`918`	`918`	`return IsInCaseInsensitive.of(values);`
`919`	`919`	`}`
`920`	`920`
`921`		`- static IsInCaseInsensitive isInCaseInsensitive(Collection<@Nullable String> values) {`
	`921`	`+ static IsInCaseInsensitive isInCaseInsensitive(Collection<String> values) {`
`922`	`922`	`return IsInCaseInsensitive.of(values);`
`923`	`923`	`}`
`924`	`924`
`@@ -931,11 +931,11 @@ static IsInCaseInsensitiveWhenPresent isInCaseInsensitiveWhenPresent(`
`931`	`931`	`return values == null ? IsInCaseInsensitiveWhenPresent.empty() : IsInCaseInsensitiveWhenPresent.of(values);`
`932`	`932`	`}`
`933`	`933`
`934`		`- static IsNotInCaseInsensitive isNotInCaseInsensitive(@Nullable String... values) {`
	`934`	`+ static IsNotInCaseInsensitive isNotInCaseInsensitive(String... values) {`
`935`	`935`	`return IsNotInCaseInsensitive.of(values);`
`936`	`936`	`}`
`937`	`937`
`938`		`- static IsNotInCaseInsensitive isNotInCaseInsensitive(Collection<@Nullable String> values) {`
	`938`	`+ static IsNotInCaseInsensitive isNotInCaseInsensitive(Collection<String> values) {`
`939`	`939`	`return IsNotInCaseInsensitive.of(values);`
`940`	`940`	`}`
`941`	`941`
Original file line number	Diff line number	Diff line change
`@@ -21,10 +21,8 @@`
`21`	`21`	`import java.util.function.Predicate;`
`22`	`22`	`import java.util.function.UnaryOperator;`
`23`	`23`
`24`		`-import org.jspecify.annotations.Nullable;`
`25`	`24`	`import org.mybatis.dynamic.sql.AbstractListValueCondition;`
`26`	`25`	`import org.mybatis.dynamic.sql.render.RenderingContext;`
`27`		`-import org.mybatis.dynamic.sql.util.StringUtilities;`
`28`	`26`	`import org.mybatis.dynamic.sql.util.Validator;`
`29`	`27`
`30`	`28`	`public class IsInCaseInsensitive extends AbstractListValueCondition<String>`
`@@ -35,7 +33,7 @@ public static IsInCaseInsensitive empty() {`
`35`	`33`	`return EMPTY;`
`36`	`34`	`}`
`37`	`35`
`38`		`- protected IsInCaseInsensitive(Collection<@Nullable String> values) {`
	`36`	`+ protected IsInCaseInsensitive(Collection<String> values) {`
`39`	`37`	`super(values);`
`40`	`38`	`}`
`41`	`39`
`@@ -62,15 +60,15 @@ public IsInCaseInsensitive filter(Predicate<? super String> predicate) {`
`62`	`60`	`* @param mapper a mapping function to apply to the values, if not empty`
`63`	`61`	`* @return a new condition with mapped values if renderable, otherwise an empty condition`
`64`	`62`	`*/`
`65`		`- public IsInCaseInsensitive map(UnaryOperator<@Nullable String> mapper) {`
	`63`	`+ public IsInCaseInsensitive map(UnaryOperator<String> mapper) {`
`66`	`64`	`return mapSupport(mapper, IsInCaseInsensitive::new, IsInCaseInsensitive::empty);`
`67`	`65`	`}`
`68`	`66`
`69`		`- public static IsInCaseInsensitive of(@Nullable String... values) {`
	`67`	`+ public static IsInCaseInsensitive of(String... values) {`
`70`	`68`	`return of(Arrays.asList(values));`
`71`	`69`	`}`
`72`	`70`
`73`		`- public static IsInCaseInsensitive of(Collection<@Nullable String> values) {`
`74`		`- return new IsInCaseInsensitive(values).map(StringUtilities::safelyUpperCase);`
	`71`	`+ public static IsInCaseInsensitive of(Collection<String> values) {`
	`72`	`+ return new IsInCaseInsensitive(values).map(String::toUpperCase);`
`75`	`73`	`}`
`76`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,6 @@`
`23`	`23`
`24`	`24`	`import org.jspecify.annotations.Nullable;`
`25`	`25`	`import org.mybatis.dynamic.sql.AbstractListValueCondition;`
`26`		`-import org.mybatis.dynamic.sql.util.StringUtilities;`
`27`	`26`	`import org.mybatis.dynamic.sql.util.Utilities;`
`28`	`27`
`29`	`28`	`public class IsInCaseInsensitiveWhenPresent extends AbstractListValueCondition<String>`
`@@ -57,7 +56,7 @@ public IsInCaseInsensitiveWhenPresent filter(Predicate<? super String> predicate`
`57`	`56`	`* @param mapper a mapping function to apply to the values, if not empty`
`58`	`57`	`* @return a new condition with mapped values if renderable, otherwise an empty condition`
`59`	`58`	`*/`
`60`		`- public IsInCaseInsensitiveWhenPresent map(UnaryOperator<@Nullable String> mapper) {`
	`59`	`+ public IsInCaseInsensitiveWhenPresent map(UnaryOperator<String> mapper) {`
`61`	`60`	`return mapSupport(mapper, IsInCaseInsensitiveWhenPresent::new, IsInCaseInsensitiveWhenPresent::empty);`
`62`	`61`	`}`
`63`	`62`
`@@ -66,6 +65,6 @@ public static IsInCaseInsensitiveWhenPresent of(@Nullable String... values) {`
`66`	`65`	`}`
`67`	`66`
`68`	`67`	`public static IsInCaseInsensitiveWhenPresent of(Collection<@Nullable String> values) {`
`69`		`- return new IsInCaseInsensitiveWhenPresent(values).map(StringUtilities::safelyUpperCase);`
	`68`	`+ return new IsInCaseInsensitiveWhenPresent(values).map(String::toUpperCase);`
`70`	`69`	`}`
`71`	`70`	`}`
Original file line number	Diff line number	Diff line change
`@@ -110,11 +110,11 @@ public FragmentAndParameters visit(AbstractColumnComparisonCondition<T> conditio`
`110`	`110`	`.mapFragment(f -> condition.operator() + spaceBefore(f));`
`111`	`111`	`}`
`112`	`112`
`113`		`- private @Nullable Object convertValue(@Nullable T value) {`
	`113`	`+ private @Nullable Object convertValue(T value) {`
`114`	`114`	`return column.convertParameterType(value);`
`115`	`115`	`}`
`116`	`116`
`117`		`- private FragmentAndParameters toFragmentAndParameters(@Nullable T value) {`
	`117`	`+ private FragmentAndParameters toFragmentAndParameters(T value) {`
`118`	`118`	`RenderedParameterInfo parameterInfo = renderingContext.calculateParameterInfo(column);`
`119`	`119`	`return FragmentAndParameters.withFragment(parameterInfo.renderedPlaceHolder())`
`120`	`120`	`.withParameter(parameterInfo.parameterMapKey(), convertValue(value))`