Add Simpler Overloads for Map/Filter on Two Value Conditions

Author: jeffgbutler

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

@@ -18,6 +18,7 @@
 import java.util.function.BiFunction;
 import java.util.function.BiPredicate;
 import java.util.function.Function;
+import java.util.function.Predicate;
 import java.util.function.Supplier;
 
 public abstract class AbstractTwoValueCondition<T>
@@ -52,6 +53,11 @@ protected <S extends AbstractTwoValueCondition<T>> S filterSupport(BiPredicate<?
         }
     }
 
+    protected <S extends AbstractTwoValueCondition<T>> S filterSupport(Predicate<? super T> predicate,
+            Supplier<S> emptySupplier, S self) {
+        return filterSupport((v1, v2) -> predicate.test(v1) && predicate.test(v2), emptySupplier, self);
+    }
+
     protected <R, S extends AbstractTwoValueCondition<R>> S mapSupport(Function<? super T, ? extends R> mapper1,
             Function<? super T, ? extends R> mapper2, BiFunction<R, R, S> constructor, Supplier<S> emptySupplier) {
         if (shouldRender()) {
@@ -71,5 +77,16 @@ protected <R, S extends AbstractTwoValueCondition<R>> S mapSupport(Function<? su
      */
     public abstract AbstractTwoValueCondition<T> filter(BiPredicate<? super T, ? super T> predicate);
 
+    /**
+     * If renderable and both values match the predicate, returns this condition. Else returns a condition
+     *     that will not render. This function implements a short-circuiting test. If the
+     *     first value does not match the predicate, then the second value will not be tested.
+     *
+     * @param predicate predicate applied to both values, if renderable
+     * @return this condition if renderable and the values match the predicate, otherwise a condition
+     *     that will not render.
+     */
+    public abstract AbstractTwoValueCondition<T> filter(Predicate<? super T> predicate);
+
     public abstract String renderCondition(String columnName, String placeholder1, String placeholder2);
 }

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

@@ -15,12 +15,13 @@
  */
 package org.mybatis.dynamic.sql.where.condition;
 
+import java.util.Objects;
 import java.util.function.BiPredicate;
 import java.util.function.Function;
+import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 
 import org.mybatis.dynamic.sql.AbstractTwoValueCondition;
-import org.mybatis.dynamic.sql.util.Predicates;
 
 public class IsBetween<T> extends AbstractTwoValueCondition<T> {
     private static final IsBetween<?> EMPTY = new IsBetween<Object>(null, null) {
@@ -79,6 +80,11 @@ public IsBetween<T> filter(BiPredicate<? super T, ? super T> predicate) {
         return filterSupport(predicate, IsBetween::empty, this);
     }
 
+    @Override
+    public IsBetween<T> filter(Predicate<? super T> predicate) {
+        return filterSupport(predicate, IsBetween::empty, this);
+    }
+
     /**
      * If renderable, apply the mappings to the values and return a new condition with the new values. Else return a
      *     condition that will not render (this).
@@ -93,6 +99,19 @@ public <R> IsBetween<R> map(Function<? super T, ? extends R> mapper1, Function<?
         return mapSupport(mapper1, mapper2, IsBetween::new, IsBetween::empty);
     }
 
+    /**
+     * If renderable, apply the mapping to both values and return a new condition with the new values. Else return a
+     *     condition that will not render (this).
+     *
+     * @param mapper a mapping function to apply to both values, if renderable
+     * @param <R> type of the new condition
+     * @return a new condition with the result of applying the mappers to the values of this condition,
+     *     if renderable, otherwise a condition that will not render.
+     */
+    public <R> IsBetween<R> map(Function<? super T, ? extends R> mapper) {
+        return map(mapper, mapper);
+    }
+
     public static <T> Builder<T> isBetween(T value1) {
         return new Builder<>(value1);
     }
@@ -119,7 +138,7 @@ private WhenPresentBuilder(T value1) {
 
         @Override
         protected IsBetween<T> build() {
-            return new IsBetween<>(value1, value2).filter(Predicates.bothPresent());
+            return new IsBetween<>(value1, value2).filter(Objects::nonNull);
         }
     }
 }

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

@@ -15,12 +15,13 @@
  */
 package org.mybatis.dynamic.sql.where.condition;
 
+import java.util.Objects;
 import java.util.function.BiPredicate;
 import java.util.function.Function;
+import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 
 import org.mybatis.dynamic.sql.AbstractTwoValueCondition;
-import org.mybatis.dynamic.sql.util.Predicates;
 
 public class IsNotBetween<T> extends AbstractTwoValueCondition<T> {
     private static final IsNotBetween<?> EMPTY = new IsNotBetween<Object>(null, null) {
@@ -79,6 +80,11 @@ public IsNotBetween<T> filter(BiPredicate<? super T, ? super T> predicate) {
         return filterSupport(predicate, IsNotBetween::empty, this);
     }
 
+    @Override
+    public IsNotBetween<T> filter(Predicate<? super T> predicate) {
+        return filterSupport(predicate, IsNotBetween::empty, this);
+    }
+
     /**
      * If renderable, apply the mappings to the values and return a new condition with the new values. Else return a
      *     condition that will not render (this).
@@ -90,10 +96,23 @@ public IsNotBetween<T> filter(BiPredicate<? super T, ? super T> predicate) {
      *     if renderable, otherwise a condition that will not render.
      */
     public <R> IsNotBetween<R> map(Function<? super T, ? extends R> mapper1,
-                                   Function<? super T, ? extends R> mapper2) {
+            Function<? super T, ? extends R> mapper2) {
         return mapSupport(mapper1, mapper2, IsNotBetween::new, IsNotBetween::empty);
     }
 
+    /**
+     * If renderable, apply the mapping to both values and return a new condition with the new values. Else return a
+     *     condition that will not render (this).
+     *
+     * @param mapper a mapping function to apply to both values, if renderable
+     * @param <R> type of the new condition
+     * @return a new condition with the result of applying the mappers to the values of this condition,
+     *     if renderable, otherwise a condition that will not render.
+     */
+    public <R> IsNotBetween<R> map(Function<? super T, ? extends R> mapper) {
+        return map(mapper, mapper);
+    }
+
     public static <T> Builder<T> isNotBetween(T value1) {
         return new Builder<>(value1);
     }
@@ -122,7 +141,7 @@ private WhenPresentBuilder(T value1) {
 
         @Override
         protected IsNotBetween<T> build() {
-            return new IsNotBetween<>(value1, value2).filter(Predicates.bothPresent());
+            return new IsNotBetween<>(value1, value2).filter(Objects::nonNull);
         }
     }
 }

src/test/java/org/mybatis/dynamic/sql/where/condition/FilterAndMapTest.java

@@ -510,11 +510,60 @@ void testBetweenUnRenderableFilterShouldReturnSameObject() {
         assertThat(cond).isSameAs(filtered);
     }
 
+    @Test
+    void testBetweenUnRenderableFirstNullFilterShouldReturnSameObject() {
+        IsBetween<Integer> cond = SqlBuilder.isBetween((Integer) null).and(4).filter(Objects::nonNull);
+        assertThat(cond.shouldRender()).isFalse();
+        IsBetween<Integer> filtered = cond.filter(v -> true);
+        assertThat(cond).isSameAs(filtered);
+    }
+
+    @Test
+    void testBetweenUnRenderableSecondNullFilterShouldReturnSameObject() {
+        IsBetween<Integer> cond = SqlBuilder.isBetween(3).and((Integer) null).filter(Objects::nonNull);
+        assertThat(cond.shouldRender()).isFalse();
+        IsBetween<Integer> filtered = cond.filter(v -> true);
+        assertThat(cond).isSameAs(filtered);
+    }
+
+    @Test
+    void testBetweenMapWithSingleMapper() {
+        IsBetween<Integer> cond = SqlBuilder.isBetween("3").and("4").map(Integer::parseInt);
+        assertThat(cond.shouldRender()).isTrue();
+        assertThat(cond.value1()).isEqualTo(3);
+        assertThat(cond.value2()).isEqualTo(4);
+    }
+
     @Test
     void testNotBetweenUnRenderableFilterShouldReturnSameObject() {
         IsNotBetween<Integer> cond = SqlBuilder.isNotBetween(3).and(4).filter((i1, i2) -> false);
         assertThat(cond.shouldRender()).isFalse();
         IsNotBetween<Integer> filtered = cond.filter((v1, v2) -> true);
         assertThat(cond).isSameAs(filtered);
     }
+
+    @Test
+    void testNotBetweenUnRenderableFirstNullFilterShouldReturnSameObject() {
+        IsNotBetween<Integer> cond = SqlBuilder.isNotBetween((Integer) null).and(4).filter(Objects::nonNull);
+        assertThat(cond.shouldRender()).isFalse();
+        IsNotBetween<Integer> filtered = cond.filter(v -> true);
+        assertThat(cond).isSameAs(filtered);
+    }
+
+    @Test
+    void testNotBetweenUnRenderableSecondNullFilterShouldReturnSameObject() {
+        IsNotBetween<Integer> cond = SqlBuilder.isNotBetween(3).and((Integer) null).filter(Objects::nonNull);
+        assertThat(cond.shouldRender()).isFalse();
+        IsNotBetween<Integer> filtered = cond.filter(v -> true);
+        assertThat(cond).isSameAs(filtered);
+    }
+
+    @Test
+    void testNotBetweenMapWithSingleMapper() {
+        IsNotBetween<Integer> cond = SqlBuilder.isNotBetween("3").and("4").map(Integer::parseInt);
+        assertThat(cond.shouldRender()).isTrue();
+        assertThat(cond.value1()).isEqualTo(3);
+        assertThat(cond.value2()).isEqualTo(4);
+    }
+
 }