Merge pull request #331 from jeffgbutler/filter-and-map

Refactor the Built-In Conditions

Author: jeffgbutler

CHANGELOG.md

@@ -13,10 +13,53 @@ The major themes of this release include the following:
 1. Add support for subqueries in select statements - both in a from clause and a join clause.
 1. Add support for the "exists" and "not exists" operator. This will work in "where" clauses anywhere
    they are supported.
+1. Refactor and improve the built-in conditions for consistency (see below)   
 1. Continue to refine the Kotlin DSL. Most changes to the Kotlin DSL are internal and should be source code
    compatible with existing code. There is one breaking change detailed below.
 1. Remove deprecated code from prior releases.
 
+### Built-In Condition Refactoring
+All built-in conditions have been rafactored. The changes should have no impact for the vast majority of users.
+However, there are some changes in behavior and one breaking change.
+
+1. Internally, the conditions no longer hold value Suppliers, they now hold the values themselves. The SqlBuilder
+   methods that accept Suppliers will call the `Supplier.get()` method when the condition is constructed. This should
+   have no impact unless you were somehow relying on the delay in obtaining a value until the condition was rendered.
+1. The existing "then" and "when" methods have been deprecated and replaced with "map" and "filter" respectively.
+   The new method names are more familiar and more representative of what these methods actually do. In effect,
+   these methods mimic the function of the "map" and "filter" methods on "java.util.Optional" and they are used
+   for a similar purpose.
+1. The new "filter" method works a bit differently than the "when" method it replaces. The "when" method could not
+   be chained - if it was called multiple times, only the last call would take effect. The new "filter" methods works
+   as it should and every call will take effect.
+1. All the "WhenPresent" conditions have been removed as separate classes. The methods that produced these conditions
+   in the SqlBuilder remain, and they will now produce a condition with a "NotNull" filter applied. So at the API level,
+   things will function exactly as before, but the intermediate classes will be different.
+1. One breaking change is that the builder for List value conditions has been removed without replacement. If you
+   were using this builder to supply a "value stream transformer", then the replacement is to build a new List value
+   condition and then call the "map" and "filter" methods as needed. For example, prior code looked like this
+
+   ```java
+    public static IsIn<String> isIn(String...values) {
+        return new IsIn.Builder<String>()
+                .withValues(Arrays.asList(values))
+                .withValueStreamTransformer(s -> s.filter(Objects::nonNull)
+                        .map(String::trim)
+                        .filter(st -> !st.isEmpty()))
+                .build();
+    }
+   ```
+   New code should look like this:
+   ```java
+    public static IsIn<String> isIn(String...values) {
+        return SqlBuilder.isIn(values)
+                .filter(Objects::nonNull)
+                .map(String::trim)
+                .filter(st -> !st.isEmpty());
+    }
+   ```
+   We think this is a marked improvement!
+
 ### Breaking Change for Kotlin
 
 In this release the Kotlin support for `select` and `count` statements has been refactored. This will not impact code
@@ -50,7 +93,7 @@ Kotlin DSL.
 - Added Kotlin DSL updates to support sub-queries in select statements, where clauses, and insert statements ([#282](https://github.com/mybatis/mybatis-dynamic-sql/pull/282))
 - Added subquery support for "join" clauses in a select statement ([#293](https://github.com/mybatis/mybatis-dynamic-sql/pull/293))
 - Added support for the "exists" and "not exists" operator in where clauses ([#296](https://github.com/mybatis/mybatis-dynamic-sql/pull/296))
-
+- Refactored the built-in conditions ([#331](https://github.com/mybatis/mybatis-dynamic-sql/pull/331))
 
 ## Release 1.2.1 - September 29, 2020
 

README.md

@@ -23,11 +23,11 @@ For example, a typical search can be coded with a query like this (the following
         select(Customer.id, Customer.firstName, Customer.lastName) {
             from(Customer)
             where(Customer.active, isEqualTo(true))
-            and(Customer.id, isEqualToWhenPresent(id).then{ it?.padStart(5, '0') })
+            and(Customer.id, isEqualToWhenPresent(id).map{ it?.padStart(5, '0') })
             and(Customer.firstName, isLikeCaseInsensitiveWhenPresent(firstName)
-                .then{ "%" + it.trim() + "%" })
+                .map{ "%" + it.trim() + "%" })
             and(Customer.lastName, isLikeCaseInsensitiveWhenPresent(lastName)
-                .then{ "%" + it.trim() + "%" })
+                .map{ "%" + it.trim() + "%" })
             orderBy(Customer.lastName, Customer.firstName)
             limit(500)
         }

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/AbstractNoValueCondition.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,26 +15,8 @@
  */
 package org.mybatis.dynamic.sql;
 
-import java.util.Objects;
-import java.util.function.BooleanSupplier;
-
 public abstract class AbstractNoValueCondition<T> implements VisitableCondition<T> {
 
-    private final BooleanSupplier booleanSupplier;
-
-    protected AbstractNoValueCondition() {
-        booleanSupplier = () -> true;
-    }
-
-    protected AbstractNoValueCondition(BooleanSupplier booleanSupplier) {
-        this.booleanSupplier = Objects.requireNonNull(booleanSupplier);
-    }
-
-    @Override
-    public boolean shouldRender() {
-        return booleanSupplier.getAsBoolean();
-    }
-
     @Override
     public <R> R accept(ConditionVisitor<T, R> visitor) {
         return visitor.visit(this);

src/main/java/org/mybatis/dynamic/sql/AbstractSingleValueCondition.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,31 +15,15 @@
  */
 package org.mybatis.dynamic.sql;
 
-import java.util.Objects;
-import java.util.function.Predicate;
-import java.util.function.Supplier;
-
 public abstract class AbstractSingleValueCondition<T> implements VisitableCondition<T> {
-    protected final Supplier<T> valueSupplier;
-    private final Predicate<T> predicate;
-
-    protected AbstractSingleValueCondition(Supplier<T> valueSupplier) {
-        this.valueSupplier = Objects.requireNonNull(valueSupplier);
-        predicate = v -> true;
-    }
+    protected final T value;
 
-    protected AbstractSingleValueCondition(Supplier<T> valueSupplier, Predicate<T> predicate) {
-        this.valueSupplier = Objects.requireNonNull(valueSupplier);
-        this.predicate = Objects.requireNonNull(predicate);
+    protected AbstractSingleValueCondition(T value) {
+        this.value = value;
     }
 
     public T value() {
-        return valueSupplier.get();
-    }
-
-    @Override
-    public boolean shouldRender() {
-        return predicate.test(value());
+        return value;
     }
 
     @Override

src/main/java/org/mybatis/dynamic/sql/AbstractTwoValueCondition.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,39 +15,21 @@
  */
 package org.mybatis.dynamic.sql;
 
-import java.util.Objects;
-import java.util.function.BiPredicate;
-import java.util.function.Supplier;
-
 public abstract class AbstractTwoValueCondition<T> implements VisitableCondition<T> {
-    protected final Supplier<T> valueSupplier1;
-    protected final Supplier<T> valueSupplier2;
-    private final BiPredicate<T, T> predicate;
-
-    protected AbstractTwoValueCondition(Supplier<T> valueSupplier1, Supplier<T> valueSupplier2) {
-        this.valueSupplier1 = Objects.requireNonNull(valueSupplier1);
-        this.valueSupplier2 = Objects.requireNonNull(valueSupplier2);
-        predicate = (v1, v2) -> true;
-    }
+    protected final T value1;
+    protected final T value2;
 
-    protected AbstractTwoValueCondition(Supplier<T> valueSupplier1, Supplier<T> valueSupplier2,
-            BiPredicate<T, T> predicate) {
-        this.valueSupplier1 = Objects.requireNonNull(valueSupplier1);
-        this.valueSupplier2 = Objects.requireNonNull(valueSupplier2);
-        this.predicate = Objects.requireNonNull(predicate);
+    protected AbstractTwoValueCondition(T value1, T value2) {
+        this.value1 = value1;
+        this.value2 = value2;
     }
 
     public T value1() {
-        return valueSupplier1.get();
+        return value1;
     }
 
     public T value2() {
-        return valueSupplier2.get();
-    }
-
-    @Override
-    public boolean shouldRender() {
-        return predicate.test(value1(), value2());
+        return value2;
     }
 
     @Override