Refactoring Slice - Empty Conditions

This change separates the concept of an empty condition from that of a
renderable condition. This will enable a future change where conditions
could decide to allow rendering even if they are considered empty (such
as rendering empty lists). This change should be transparent to users
unless they have implemented custom conditions.

Author: jeffgbutler

CHANGELOG.md

@@ -39,6 +39,9 @@ types - which is a rare usage. Please let us know if this causes an undo hardshi
    your code accordingly. ([#662](https://github.com/mybatis/mybatis-dynamic-sql/pull/662))
 2. Added the ability to code a bound value in rendered SQL. This is similar to a constant, but the value is added to
    the parameter map and a bind parameter marker is rendered. ([#738](https://github.com/mybatis/mybatis-dynamic-sql/pull/738))
+3. Refactored the conditions to separate the concept of an empty condition from that of a renderable condition. This
+   will enable a future change where conditions could decide to allow rendering even if they are considered empty (such
+   as rendering empty lists). This change should be transparent to users unless they have implemented custom conditions.
 
 ## Release 1.5.0 - April 21, 2023
 

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

@@ -35,8 +35,8 @@ public final <R> Stream<R> mapValues(Function<T, R> mapper) {
     }
 
     @Override
-    public boolean shouldRender() {
-        return !values.isEmpty();
+    public boolean isEmpty() {
+        return values.isEmpty();
     }
 
     @Override
@@ -56,20 +56,20 @@ private Collection<T> applyFilter(Predicate<? super T> predicate) {
 
     protected <S extends AbstractListValueCondition<T>> S filterSupport(Predicate<? super T> predicate,
             Function<Collection<T>, S> constructor, S self, Supplier<S> emptySupplier) {
-        if (shouldRender()) {
+        if (isEmpty()) {
+            return self;
+        } else {
             Collection<T> filtered = applyFilter(predicate);
             return filtered.isEmpty() ? emptySupplier.get() : constructor.apply(filtered);
-        } else {
-            return self;
         }
     }
 
     protected <R, S extends AbstractListValueCondition<R>> S mapSupport(Function<? super T, ? extends R> mapper,
             Function<Collection<R>, S> constructor, Supplier<S> emptySupplier) {
-        if (shouldRender()) {
-            return constructor.apply(applyMapper(mapper));
-        } else {
+        if (isEmpty()) {
             return emptySupplier.get();
+        } else {
+            return constructor.apply(applyMapper(mapper));
         }
     }
 

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

@@ -27,10 +27,10 @@ public <R> R accept(ConditionVisitor<T, R> visitor) {
 
     protected <S extends AbstractNoValueCondition<?>> S filterSupport(BooleanSupplier booleanSupplier,
             Supplier<S> emptySupplier, S self) {
-        if (shouldRender()) {
-            return booleanSupplier.getAsBoolean() ? self : emptySupplier.get();
-        } else {
+        if (isEmpty()) {
             return self;
+        } else {
+            return booleanSupplier.getAsBoolean() ? self : emptySupplier.get();
         }
     }
 

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

@@ -37,19 +37,19 @@ public <R> R accept(ConditionVisitor<T, R> visitor) {
 
     protected <S extends AbstractSingleValueCondition<T>> S filterSupport(Predicate<? super T> predicate,
             Supplier<S> emptySupplier, S self) {
-        if (shouldRender()) {
-            return predicate.test(value) ? self : emptySupplier.get();
-        } else {
+        if (isEmpty()) {
             return self;
+        } else {
+            return predicate.test(value) ? self : emptySupplier.get();
         }
     }
 
     protected <R, S extends AbstractSingleValueCondition<R>> S mapSupport(Function<? super T, ? extends R> mapper,
             Function<R, S> constructor, Supplier<S> emptySupplier) {
-        if (shouldRender()) {
-            return constructor.apply(mapper.apply(value));
-        } else {
+        if (isEmpty()) {
             return emptySupplier.get();
+        } else {
+            return constructor.apply(mapper.apply(value));
         }
     }
 

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

@@ -45,10 +45,10 @@ public <R> R accept(ConditionVisitor<T, R> visitor) {
 
     protected <S extends AbstractTwoValueCondition<T>> S filterSupport(BiPredicate<? super T, ? super T> predicate,
             Supplier<S> emptySupplier, S self) {
-        if (shouldRender()) {
-            return predicate.test(value1, value2) ? self : emptySupplier.get();
-        } else {
+        if (isEmpty()) {
             return self;
+        } else {
+            return predicate.test(value1, value2) ? self : emptySupplier.get();
         }
     }
 
@@ -59,10 +59,10 @@ protected <S extends AbstractTwoValueCondition<T>> S filterSupport(Predicate<? s
 
     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()) {
-            return constructor.apply(mapper1.apply(value1), mapper2.apply(value2));
-        } else {
+        if (isEmpty()) {
             return emptySupplier.get();
+        } else {
+            return constructor.apply(mapper1.apply(value1), mapper2.apply(value2));
         }
     }
 

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

@@ -15,22 +15,34 @@
  */
 package org.mybatis.dynamic.sql;
 
+import org.mybatis.dynamic.sql.render.RenderingContext;
+
 @FunctionalInterface
 public interface VisitableCondition<T> {
     <R> R accept(ConditionVisitor<T, R> visitor);
 
     /**
      * Subclasses can override this to inform the renderer if the condition should not be included
-     * in the rendered SQL.  For example, IsEqualWhenPresent will not render if the value is null.
+     * in the rendered SQL.  Typically, conditions will not render if they are empty.
      *
      * @return true if the condition should render.
      */
-    default boolean shouldRender() {
-        return true;
+    default boolean shouldRender(RenderingContext renderingContext) {
+        return !isEmpty();
+    }
+
+    /**
+     * Subclasses can override this to indicate whether the condition is considered empty. This is primarily used in
+     * map and filter operations - the map and filter functions will not be applied if the condition is empty.
+     *
+     * @return true if the condition is empty.
+     */
+    default boolean isEmpty() {
+        return false;
     }
 
     /**
-     * This method will be called during rendering when {@link VisitableCondition#shouldRender()}
+     * This method will be called during rendering when {@link VisitableCondition#shouldRender(RenderingContext)}
      * returns false.
      */
     default void renderingSkipped() {}

src/main/java/org/mybatis/dynamic/sql/select/aggregate/Sum.java

@@ -36,7 +36,7 @@ private Sum(BindableColumn<T> column) {
     private Sum(BindableColumn<T> column, VisitableCondition<T> condition) {
         super(column);
         renderer = rc -> {
-            Validator.assertTrue(condition.shouldRender(), "ERROR.37", "sum"); //$NON-NLS-1$ //$NON-NLS-2$
+            Validator.assertTrue(condition.shouldRender(rc), "ERROR.37", "sum"); //$NON-NLS-1$ //$NON-NLS-2$
 
             DefaultConditionVisitor<T> visitor = new DefaultConditionVisitor.Builder<T>()
                     .withColumn(column)

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

@@ -25,8 +25,8 @@
 public class IsBetween<T> extends AbstractTwoValueCondition<T> {
     private static final IsBetween<?> EMPTY = new IsBetween<Object>(null, null) {
         @Override
-        public boolean shouldRender() {
-            return false;
+        public boolean isEmpty() {
+            return true;
         }
     };
 

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

@@ -24,8 +24,8 @@ public class IsEqualTo<T> extends AbstractSingleValueCondition<T> {
 
     private static final IsEqualTo<?> EMPTY = new IsEqualTo<Object>(null) {
         @Override
-        public boolean shouldRender() {
-            return false;
+        public boolean isEmpty() {
+            return true;
         }
     };
 

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

@@ -23,8 +23,8 @@
 public class IsGreaterThan<T> extends AbstractSingleValueCondition<T> {
     private static final IsGreaterThan<?> EMPTY = new IsGreaterThan<Object>(null) {
         @Override
-        public boolean shouldRender() {
-            return false;
+        public boolean isEmpty() {
+            return true;
         }
     };