Implement filter/map for List value conditions

Author: jeffgbutler

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

@@ -1,5 +1,5 @@
 /*
- *    Copyright 2016-2020 the original author or authors.
+ *    Copyright 2016-2021 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.
@@ -15,25 +15,26 @@
  */
 package org.mybatis.dynamic.sql;
 
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Objects;
 import java.util.function.Function;
+import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 public abstract class AbstractListValueCondition<T, S extends AbstractListValueCondition<T, S>>
         implements VisitableCondition<T> {
     protected final Collection<T> values;
-    protected final UnaryOperator<Stream<T>> valueStreamTransformer;
     protected final Callback emptyCallback;
 
-    protected AbstractListValueCondition(AbstractListConditionBuilder<T, ?> builder) {
-        this.valueStreamTransformer = Objects.requireNonNull(builder.valueStreamTransformer);
-        this.values = valueStreamTransformer.apply(builder.values.stream())
-            .collect(Collectors.toList());
-        this.emptyCallback = Objects.requireNonNull(builder.emptyCallback);
+    protected AbstractListValueCondition(Collection<T> values) {
+        this(values, () -> { });
+    }
+
+    protected AbstractListValueCondition(Collection<T> values, Callback emptyCallback) {
+        this.values = Objects.requireNonNull(values);
+        this.emptyCallback = Objects.requireNonNull(emptyCallback);
     }
 
     public final <R> Stream<R> mapValues(Function<T, R> mapper) {
@@ -55,30 +56,17 @@ public <R> R accept(ConditionVisitor<T, R> visitor) {
         return visitor.visit(this);
     }
 
-    public abstract S withListEmptyCallback(Callback callback);
-
-    public abstract String renderCondition(String columnName, Stream<String> placeholders);
-
-    public abstract static class AbstractListConditionBuilder<T, S extends AbstractListConditionBuilder<T, S>> {
-        protected Collection<T> values = new ArrayList<>();
-        protected UnaryOperator<Stream<T>> valueStreamTransformer = UnaryOperator.identity();
-        protected Callback emptyCallback = () -> { };
-
-        public S withValues(Collection<T> values) {
-            this.values.addAll(values);
-            return getThis();
-        }
+    protected Collection<T> applyMapper(UnaryOperator<T> mapper) {
+        Objects.requireNonNull(mapper);
+        return values.stream().map(mapper).collect(Collectors.toList());
+    }
 
-        public S withValueStreamTransformer(UnaryOperator<Stream<T>> valueStreamTransformer) {
-            this.valueStreamTransformer = valueStreamTransformer;
-            return getThis();
-        }
+    protected Collection<T> applyFilter(Predicate<T> predicate) {
+        Objects.requireNonNull(predicate);
+        return values.stream().filter(predicate).collect(Collectors.toList());
+    }
 
-        public S withEmptyCallback(Callback emptyCallback) {
-            this.emptyCallback = emptyCallback;
-            return getThis();
-        }
+    public abstract S withListEmptyCallback(Callback callback);
 
-        protected abstract S getThis();
-    }
+    public abstract String renderCondition(String columnName, Stream<String> placeholders);
 }

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

@@ -70,8 +70,6 @@
 import org.mybatis.dynamic.sql.where.condition.IsGreaterThanWithSubselect;
 import org.mybatis.dynamic.sql.where.condition.IsIn;
 import org.mybatis.dynamic.sql.where.condition.IsInCaseInsensitive;
-import org.mybatis.dynamic.sql.where.condition.IsInCaseInsensitiveWhenPresent;
-import org.mybatis.dynamic.sql.where.condition.IsInWhenPresent;
 import org.mybatis.dynamic.sql.where.condition.IsInWithSubselect;
 import org.mybatis.dynamic.sql.where.condition.IsLessThan;
 import org.mybatis.dynamic.sql.where.condition.IsLessThanColumn;
@@ -88,8 +86,6 @@
 import org.mybatis.dynamic.sql.where.condition.IsNotEqualToWithSubselect;
 import org.mybatis.dynamic.sql.where.condition.IsNotIn;
 import org.mybatis.dynamic.sql.where.condition.IsNotInCaseInsensitive;
-import org.mybatis.dynamic.sql.where.condition.IsNotInCaseInsensitiveWhenPresent;
-import org.mybatis.dynamic.sql.where.condition.IsNotInWhenPresent;
 import org.mybatis.dynamic.sql.where.condition.IsNotInWithSubselect;
 import org.mybatis.dynamic.sql.where.condition.IsNotLike;
 import org.mybatis.dynamic.sql.where.condition.IsNotLikeCaseInsensitive;
@@ -578,12 +574,12 @@ static <T> IsInWithSubselect<T> isIn(Buildable<SelectModel> selectModelBuilder)
     }
 
     @SafeVarargs
-    static <T> IsInWhenPresent<T> isInWhenPresent(T...values) {
-        return IsInWhenPresent.of(values);
+    static <T> IsIn<T> isInWhenPresent(T...values) {
+        return IsIn.of(values).filter(Objects::nonNull);
     }
 
-    static <T> IsInWhenPresent<T> isInWhenPresent(Collection<T> values) {
-        return IsInWhenPresent.of(values);
+    static <T> IsIn<T> isInWhenPresent(Collection<T> values) {
+        return IsIn.of(values).filter(Objects::nonNull);
     }
 
     @SafeVarargs
@@ -600,12 +596,12 @@ static <T> IsNotInWithSubselect<T> isNotIn(Buildable<SelectModel> selectModelBui
     }
 
     @SafeVarargs
-    static <T> IsNotInWhenPresent<T> isNotInWhenPresent(T...values) {
-        return IsNotInWhenPresent.of(values);
+    static <T> IsNotIn<T> isNotInWhenPresent(T...values) {
+        return IsNotIn.of(values).filter(Objects::nonNull);
     }
 
-    static <T> IsNotInWhenPresent<T> isNotInWhenPresent(Collection<T> values) {
-        return IsNotInWhenPresent.of(values);
+    static <T> IsNotIn<T> isNotInWhenPresent(Collection<T> values) {
+        return IsNotIn.of(values).filter(Objects::nonNull);
     }
 
     static <T> IsBetween.Builder<T> isBetween(T value1) {
@@ -723,12 +719,12 @@ static IsInCaseInsensitive isInCaseInsensitive(Collection<String> values) {
         return IsInCaseInsensitive.of(values);
     }
 
-    static IsInCaseInsensitiveWhenPresent isInCaseInsensitiveWhenPresent(String...values) {
-        return IsInCaseInsensitiveWhenPresent.of(values);
+    static IsInCaseInsensitive isInCaseInsensitiveWhenPresent(String...values) {
+        return IsInCaseInsensitive.of(values).filter(Objects::nonNull);
     }
 
-    static IsInCaseInsensitiveWhenPresent isInCaseInsensitiveWhenPresent(Collection<String> values) {
-        return IsInCaseInsensitiveWhenPresent.of(values);
+    static IsInCaseInsensitive isInCaseInsensitiveWhenPresent(Collection<String> values) {
+        return IsInCaseInsensitive.of(values).filter(Objects::nonNull);
     }
 
     static IsNotInCaseInsensitive isNotInCaseInsensitive(String...values) {
@@ -739,12 +735,12 @@ static IsNotInCaseInsensitive isNotInCaseInsensitive(Collection<String> values)
         return IsNotInCaseInsensitive.of(values);
     }
 
-    static IsNotInCaseInsensitiveWhenPresent isNotInCaseInsensitiveWhenPresent(String...values) {
-        return IsNotInCaseInsensitiveWhenPresent.of(values);
+    static IsNotInCaseInsensitive isNotInCaseInsensitiveWhenPresent(String...values) {
+        return IsNotInCaseInsensitive.of(values).filter(Objects::nonNull);
     }
 
-    static IsNotInCaseInsensitiveWhenPresent isNotInCaseInsensitiveWhenPresent(Collection<String> values) {
-        return IsNotInCaseInsensitiveWhenPresent.of(values);
+    static IsNotInCaseInsensitive isNotInCaseInsensitiveWhenPresent(Collection<String> values) {
+        return IsNotInCaseInsensitive.of(values).filter(Objects::nonNull);
     }
 
     // order by support

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

@@ -1,5 +1,5 @@
 /*
- *    Copyright 2016-2020 the original author or authors.
+ *    Copyright 2016-2021 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.
@@ -19,6 +19,8 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.List;
+import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -28,8 +30,12 @@
 
 public class IsIn<T> extends AbstractListValueCondition<T, IsIn<T>> {
 
-    protected IsIn(Builder<T> builder) {
-        super(builder);
+    protected IsIn(Collection<T> values) {
+        super(values);
+    }
+
+    protected IsIn(Collection<T> values, Callback emptyCallback) {
+        super(values, emptyCallback);
     }
 
     @Override
@@ -40,11 +46,7 @@ public String renderCondition(String columnName, Stream<String> placeholders) {
 
     @Override
     public IsIn<T> withListEmptyCallback(Callback callback) {
-        return new Builder<T>()
-                .withValues(values)
-                .withValueStreamTransformer(valueStreamTransformer)
-                .withEmptyCallback(callback)
-                .build();
+        return new IsIn<>(values, callback);
     }
 
     /**
@@ -53,16 +55,49 @@ public IsIn<T> withListEmptyCallback(Callback callback) {
      * If you filter values out of the stream, then final condition will not reference those values. If you filter all
      * values out of the stream, then the condition will not render.
      *
+     * @deprecated replaced by {@link IsIn#map(UnaryOperator)} and {@link IsIn#filter(Predicate)}
      * @param valueStreamTransformer a UnaryOperator that will transform the value stream before
      *     the values are placed in the parameter map
      * @return new condition with the specified transformer
      */
+    @Deprecated
     public IsIn<T> then(UnaryOperator<Stream<T>> valueStreamTransformer) {
-        return new Builder<T>()
-                .withValues(values)
-                .withValueStreamTransformer(valueStreamTransformer)
-                .withEmptyCallback(emptyCallback)
-                .build();
+        List<T> mapped = valueStreamTransformer.apply(values.stream())
+                .collect(Collectors.toList());
+        return new IsIn<>(mapped, emptyCallback);
+    }
+
+    /**
+     * If renderable, apply the predicate to each value in the list and return a new condition with the filtered values.
+     *     Else returns a condition that will not render (this). If all values are filtered out of the value
+     *     list, then the condition will not render.
+     *
+     * @param predicate predicate applied to the values, if renderable
+     * @return a new condition with filtered values if renderable, otherwise a condition
+     *     that will not render.
+     */
+    public IsIn<T> filter(Predicate<T> predicate) {
+        if (shouldRender()) {
+            return new IsIn<>(applyFilter(predicate), emptyCallback);
+        } else {
+            return this;
+        }
+    }
+
+    /**
+     * If renderable, apply the mapping to each value in the list return a new condition with the mapped values.
+     *     Else return a condition that will not render (this).
+     *
+     * @param mapper a mapping function to apply to the values, if renderable
+     * @return a new condition with mapped values if renderable, otherwise a condition
+     *     that will not render.
+     */
+    public IsIn<T> map(UnaryOperator<T> mapper) {
+        if (shouldRender()) {
+            return new IsIn<>(applyMapper(mapper), emptyCallback);
+        } else {
+            return this;
+        }
     }
 
     @SafeVarargs
@@ -71,17 +106,6 @@ public static <T> IsIn<T> of(T... values) {
     }
 
     public static <T> IsIn<T> of(Collection<T> values) {
-        return new Builder<T>().withValues(values).build();
-    }
-
-    public static class Builder<T> extends AbstractListConditionBuilder<T, Builder<T>> {
-        @Override
-        protected Builder<T> getThis() {
-            return this;
-        }
-
-        public IsIn<T> build() {
-            return new IsIn<>(this);
-        }
+        return new IsIn<>(values);
     }
 }

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

@@ -1,5 +1,5 @@
 /*
- *    Copyright 2016-2020 the original author or authors.
+ *    Copyright 2016-2021 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.Arrays;
 import java.util.Collection;
+import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -26,8 +28,12 @@
 
 public class IsInCaseInsensitive extends AbstractListValueCondition<String, IsInCaseInsensitive> {
 
-    protected  IsInCaseInsensitive(Builder builder) {
-        super(builder);
+    protected  IsInCaseInsensitive(Collection<String> values) {
+        super(values);
+    }
+
+    protected  IsInCaseInsensitive(Collection<String> values, Callback emptyCallback) {
+        super(values, emptyCallback);
     }
 
     @Override
@@ -38,32 +44,47 @@ public String renderCondition(String columnName, Stream<String> placeholders) {
 
     @Override
     public IsInCaseInsensitive withListEmptyCallback(Callback callback) {
-        return new Builder()
-                .withValues(values)
-                .withValueStreamTransformer(valueStreamTransformer)
-                .withEmptyCallback(callback)
-                .build();
-    }
-
-    public static IsInCaseInsensitive of(String... values) {
-        return of(Arrays.asList(values));
+        return new IsInCaseInsensitive(values, callback);
     }
 
-    public static IsInCaseInsensitive of(Collection<String> values) {
-        return new Builder()
-                .withValues(values)
-                .withValueStreamTransformer(s -> s.map(StringUtilities::safelyUpperCase))
-                .build();
+    /**
+     * If renderable apply the predicate to each value in the list and return a new condition with the filtered values.
+     *     Else returns a condition that will not render (this). If all values are filtered out of the value
+     *     list, then the condition will not render.
+     *
+     * @param predicate predicate applied to the values, if renderable
+     * @return a new condition with filtered values if renderable, otherwise a condition
+     *     that will not render.
+     */
+    public IsInCaseInsensitive filter(Predicate<String> predicate) {
+        if (shouldRender()) {
+            return new IsInCaseInsensitive(applyFilter(predicate), emptyCallback);
+        } else {
+            return this;
+        }
     }
 
-    public static class Builder extends AbstractListConditionBuilder<String, Builder> {
-        @Override
-        protected Builder getThis() {
+    /**
+     * If renderable, apply the mapping to each value in the list return a new condition with the mapped values.
+     *     Else return a condition that will not render (this).
+     *
+     * @param mapper a mapping function to apply to the values, if renderable
+     * @return a new condition with mapped values if renderable, otherwise a condition
+     *     that will not render.
+     */
+    public IsInCaseInsensitive map(UnaryOperator<String> mapper) {
+        if (shouldRender()) {
+            return new IsInCaseInsensitive(applyMapper(mapper), emptyCallback);
+        } else {
             return this;
         }
+    }
 
-        protected IsInCaseInsensitive build() {
-            return new IsInCaseInsensitive(this);
-        }
+    public static IsInCaseInsensitive of(String... values) {
+        return of(Arrays.asList(values));
+    }
+
+    public static IsInCaseInsensitive of(Collection<String> values) {
+        return new IsInCaseInsensitive(values).map(StringUtilities::safelyUpperCase);
     }
 }