Merge branch 'master' into improve-conditions

jeffgbutler · jeffgbutler · commit f1ccf4804d24 · 2025-03-13T17:47:01.000-04:00
# Conflicts:
#	src/main/java/org/mybatis/dynamic/sql/where/condition/IsInCaseInsensitive.java
#	src/main/java/org/mybatis/dynamic/sql/where/condition/IsInCaseInsensitiveWhenPresent.java
#	src/main/java/org/mybatis/dynamic/sql/where/condition/IsLikeCaseInsensitive.java
#	src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInCaseInsensitive.java
#	src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInCaseInsensitiveWhenPresent.java
#	src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotLikeCaseInsensitive.java
diff --git a/src/main/java/org/mybatis/dynamic/sql/util/StringUtilities.java b/src/main/java/org/mybatis/dynamic/sql/util/StringUtilities.java
@@ -58,6 +58,5 @@ static String toCamelCase(String inputString) {
     static String formatConstantForSQL(String in) {
         String escaped = in.replace("'", "''"); //$NON-NLS-1$ //$NON-NLS-2$
         return "'" + escaped + "'"; //$NON-NLS-1$ //$NON-NLS-2$
-
     }
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/util/Utilities.java b/src/main/java/org/mybatis/dynamic/sql/util/Utilities.java
@@ -15,23 +15,10 @@
  */
 package org.mybatis.dynamic.sql.util;
 
-import java.util.Collection;
-import java.util.Objects;
-import java.util.stream.Stream;
-
-import org.jspecify.annotations.NonNull;
 import org.jspecify.annotations.Nullable;
 
 public interface Utilities {
     static long safelyUnbox(@Nullable Long l) {
         return l == null ? 0 : l;
     }
-
-    static <T> Stream<@NonNull T> filterNullValues(Stream<@Nullable T> values) {
-        return values.filter(Objects::nonNull);
-    }
-
-    static <T> Collection<@NonNull T> removeNullElements(Collection<@Nullable T> values) {
-        return filterNullValues(values.stream()).toList();
-    }
 }
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
@@ -66,8 +66,7 @@ public static IsInCaseInsensitive<String> of(String... values) {
     }
 
     public static IsInCaseInsensitive<String> of(Collection<String> values) {
-        // Keep the null safe upper case utility for backwards compatibility
-        //noinspection DataFlowIssue
-        return new IsInCaseInsensitive<>(values).map(StringUtilities::safelyUpperCase);
+        // Keep the null safe upper case utility for backwards compatibility in case someone passes in a null
+        return new IsInCaseInsensitive<>(values.stream().map(StringUtilities::safelyUpperCase).toList());
     }
 }
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
@@ -19,12 +19,11 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.function.Function;
+import java.util.Objects;
 import java.util.function.Predicate;
 
 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<T> extends AbstractListValueCondition<T>
         implements CaseInsensitiveRenderableCondition<T> {
@@ -37,8 +36,8 @@ public static <T> IsInCaseInsensitiveWhenPresent<T> empty() {
         return t;
     }
 
-    protected IsInCaseInsensitiveWhenPresent(Collection<@Nullable T> values) {
-        super(Utilities.removeNullElements(values));
+    protected IsInCaseInsensitiveWhenPresent(Collection<String> values) {
+        super(values);
     }
 
     @Override
@@ -62,8 +61,7 @@ public static IsInCaseInsensitiveWhenPresent<String> of(@Nullable String... valu
     }
 
     public static IsInCaseInsensitiveWhenPresent<String> of(Collection<@Nullable String> values) {
-        // Keep the null safe upper case utility for backwards compatibility
-        //noinspection DataFlowIssue
-        return new IsInCaseInsensitiveWhenPresent<>(values).map(StringUtilities::safelyUpperCase);
+        return new IsInCaseInsensitiveWhenPresent<>(
+                values.stream().filter(Objects::nonNull).map(String::toUpperCase).toList());
     }
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsLikeCaseInsensitive.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsLikeCaseInsensitive.java
@@ -62,8 +62,7 @@ public <R> IsLikeCaseInsensitive<R> map(Function<? super T, ? extends R> mapper)
     }
 
     public static IsLikeCaseInsensitive<String> of(String value) {
-        // Keep the null safe upper case utility for backwards compatibility
-        //noinspection DataFlowIssue
-        return new IsLikeCaseInsensitive<>(value).map(StringUtilities::safelyUpperCase);
+        // Keep the null safe upper case utility for backwards compatibility in case someone passes in a null
+        return new IsLikeCaseInsensitive<>(StringUtilities.safelyUpperCase(value));
     }
 }
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
@@ -66,8 +66,7 @@ public static IsNotInCaseInsensitive<String> of(String... values) {
     }
 
     public static IsNotInCaseInsensitive<String> of(Collection<String> values) {
-        // Keep the null safe upper case utility for backwards compatibility
-        //noinspection DataFlowIssue
-        return new IsNotInCaseInsensitive<>(values).map(StringUtilities::safelyUpperCase);
+        // Keep the null safe upper case utility for backwards compatibility in case someone passes in a null
+        return new IsNotInCaseInsensitive<>(values.stream().map(StringUtilities::safelyUpperCase).toList());
     }
 }
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
@@ -19,12 +19,11 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.function.Function;
+import java.util.Objects;
 import java.util.function.Predicate;
 
 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<T> extends AbstractListValueCondition<T>
         implements CaseInsensitiveRenderableCondition<T> {
@@ -37,8 +36,8 @@ public static <T> IsNotInCaseInsensitiveWhenPresent<T> empty() {
         return t;
     }
 
-    protected IsNotInCaseInsensitiveWhenPresent(Collection<@Nullable T> values) {
-        super(Utilities.removeNullElements(values));
+    protected IsNotInCaseInsensitiveWhenPresent(Collection<String> values) {
+        super(values);
     }
 
     @Override
@@ -62,8 +61,7 @@ public static IsNotInCaseInsensitiveWhenPresent<String> of(@Nullable String... v
     }
 
     public static IsNotInCaseInsensitiveWhenPresent<String> of(Collection<@Nullable String> values) {
-        // Keep the null safe upper case utility for backwards compatibility
-        //noinspection DataFlowIssue
-        return new IsNotInCaseInsensitiveWhenPresent<>(values).map(StringUtilities::safelyUpperCase);
+        return new IsNotInCaseInsensitiveWhenPresent<>(
+                values.stream().filter(Objects::nonNull).map(String::toUpperCase).toList());
     }
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotLikeCaseInsensitive.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotLikeCaseInsensitive.java
@@ -71,8 +71,7 @@ public <R> IsNotLikeCaseInsensitive<R> map(Function<? super T, ? extends R> mapp
     }
 
     public static IsNotLikeCaseInsensitive<String> of(String value) {
-        // Keep the null safe upper case utility for backwards compatibility
-        //noinspection DataFlowIssue
-        return new IsNotLikeCaseInsensitive<>(value).map(StringUtilities::safelyUpperCase);
+        // Keep the null safe upper case utility for backwards compatibility in case someone passes in a null
+        return new IsNotLikeCaseInsensitive<>(StringUtilities.safelyUpperCase(value));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,5 @@ static String toCamelCase(String inputString) {`
`58`	`58`	`static String formatConstantForSQL(String in) {`
`59`	`59`	`String escaped = in.replace("'", "''"); //$NON-NLS-1$ //$NON-NLS-2$`
`60`	`60`	`return "'" + escaped + "'"; //$NON-NLS-1$ //$NON-NLS-2$`
`61`		`-`
`62`	`61`	`}`
`63`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -66,8 +66,7 @@ public static IsInCaseInsensitive<String> of(String... values) {`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`public static IsInCaseInsensitive<String> of(Collection<String> values) {`
`69`		`- // Keep the null safe upper case utility for backwards compatibility`
`70`		`- //noinspection DataFlowIssue`
`71`		`- return new IsInCaseInsensitive<>(values).map(StringUtilities::safelyUpperCase);`
	`69`	`+ // Keep the null safe upper case utility for backwards compatibility in case someone passes in a null`
	`70`	`+ return new IsInCaseInsensitive<>(values.stream().map(StringUtilities::safelyUpperCase).toList());`
`72`	`71`	`}`
`73`	`72`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,12 +19,11 @@`
`19`	`19`	`import java.util.Collection;`
`20`	`20`	`import java.util.Collections;`
`21`	`21`	`import java.util.function.Function;`
	`22`	`+import java.util.Objects;`
`22`	`23`	`import java.util.function.Predicate;`
`23`	`24`
`24`	`25`	`import org.jspecify.annotations.Nullable;`
`25`	`26`	`import org.mybatis.dynamic.sql.AbstractListValueCondition;`
`26`		`-import org.mybatis.dynamic.sql.util.StringUtilities;`
`27`		`-import org.mybatis.dynamic.sql.util.Utilities;`
`28`	`27`
`29`	`28`	`public class IsInCaseInsensitiveWhenPresent<T> extends AbstractListValueCondition<T>`
`30`	`29`	`implements CaseInsensitiveRenderableCondition<T> {`
`@@ -37,8 +36,8 @@ public static <T> IsInCaseInsensitiveWhenPresent<T> empty() {`
`37`	`36`	`return t;`
`38`	`37`	`}`
`39`	`38`
`40`		`- protected IsInCaseInsensitiveWhenPresent(Collection<@Nullable T> values) {`
`41`		`- super(Utilities.removeNullElements(values));`
	`39`	`+ protected IsInCaseInsensitiveWhenPresent(Collection<String> values) {`
	`40`	`+ super(values);`
`42`	`41`	`}`
`43`	`42`
`44`	`43`	`@Override`
`@@ -62,8 +61,7 @@ public static IsInCaseInsensitiveWhenPresent<String> of(@Nullable String... valu`
`62`	`61`	`}`
`63`	`62`
`64`	`63`	`public static IsInCaseInsensitiveWhenPresent<String> of(Collection<@Nullable String> values) {`
`65`		`- // Keep the null safe upper case utility for backwards compatibility`
`66`		`- //noinspection DataFlowIssue`
`67`		`- return new IsInCaseInsensitiveWhenPresent<>(values).map(StringUtilities::safelyUpperCase);`
	`64`	`+ return new IsInCaseInsensitiveWhenPresent<>(`
	`65`	`+ values.stream().filter(Objects::nonNull).map(String::toUpperCase).toList());`
`68`	`66`	`}`
`69`	`67`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,8 +62,7 @@ public <R> IsLikeCaseInsensitive<R> map(Function<? super T, ? extends R> mapper)`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`public static IsLikeCaseInsensitive<String> of(String value) {`
`65`		`- // Keep the null safe upper case utility for backwards compatibility`
`66`		`- //noinspection DataFlowIssue`
`67`		`- return new IsLikeCaseInsensitive<>(value).map(StringUtilities::safelyUpperCase);`
	`65`	`+ // Keep the null safe upper case utility for backwards compatibility in case someone passes in a null`
	`66`	`+ return new IsLikeCaseInsensitive<>(StringUtilities.safelyUpperCase(value));`
`68`	`67`	`}`
`69`	`68`	`}`
Original file line number	Diff line number	Diff line change
`@@ -66,8 +66,7 @@ public static IsNotInCaseInsensitive<String> of(String... values) {`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`public static IsNotInCaseInsensitive<String> of(Collection<String> values) {`
`69`		`- // Keep the null safe upper case utility for backwards compatibility`
`70`		`- //noinspection DataFlowIssue`
`71`		`- return new IsNotInCaseInsensitive<>(values).map(StringUtilities::safelyUpperCase);`
	`69`	`+ // Keep the null safe upper case utility for backwards compatibility in case someone passes in a null`
	`70`	`+ return new IsNotInCaseInsensitive<>(values.stream().map(StringUtilities::safelyUpperCase).toList());`
`72`	`71`	`}`
`73`	`72`	`}`
Original file line number	Diff line number	Diff line change
`@@ -71,8 +71,7 @@ public <R> IsNotLikeCaseInsensitive<R> map(Function<? super T, ? extends R> mapp`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`public static IsNotLikeCaseInsensitive<String> of(String value) {`
`74`		`- // Keep the null safe upper case utility for backwards compatibility`
`75`		`- //noinspection DataFlowIssue`
`76`		`- return new IsNotLikeCaseInsensitive<>(value).map(StringUtilities::safelyUpperCase);`
	`74`	`+ // Keep the null safe upper case utility for backwards compatibility in case someone passes in a null`
	`75`	`+ return new IsNotLikeCaseInsensitive<>(StringUtilities.safelyUpperCase(value));`
`77`	`76`	`}`
`78`	`77`	`}`