Remove configuration for empty list rendering

With this change, the "in" conditions will always render. The "in when present" conditions will only render if the input collection is non-null and contains at least one non-null value.

Author: jeffgbutler

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

@@ -23,8 +23,6 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import org.mybatis.dynamic.sql.render.RenderingContext;
-
 public abstract class AbstractListValueCondition<T> implements VisitableCondition<T> {
     protected final Collection<T> values;
 
@@ -41,15 +39,6 @@ public boolean isEmpty() {
         return values.isEmpty();
     }
 
-    @Override
-    public boolean shouldRender(RenderingContext renderingContext) {
-        if (isEmpty()) {
-            return renderingContext.isEmptyListConditionRenderingAllowed();
-        } else {
-            return true;
-        }
-    }
-
     @Override
     public <R> R accept(ConditionVisitor<T, R> visitor) {
         return visitor.visit(this);
@@ -85,14 +74,12 @@ protected <R, S extends AbstractListValueCondition<R>> S mapSupport(Function<? s
     }
 
     /**
-     * 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.
+     * If not empty, apply the predicate to each value in the list and return a new condition with the filtered values.
+     *     Else returns an empty condition (this).
      *
-     * @param predicate
-     *            predicate applied to the values, if renderable
+     * @param predicate predicate applied to the values, if not empty
      *
-     * @return a new condition with filtered values if renderable, otherwise a condition that will not render.
+     * @return a new condition with filtered values if renderable, otherwise an empty condition
      */
     public abstract AbstractListValueCondition<T> filter(Predicate<? super T> predicate);
 

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

@@ -769,7 +769,7 @@ static <T> IsInWithSubselect<T> isIn(Buildable<SelectModel> selectModelBuilder)
 
     @SafeVarargs
     static <T> IsInWhenPresent<T> isInWhenPresent(T... values) {
-        return IsInWhenPresent.of(values);
+        return values == null ? IsInWhenPresent.empty() : IsInWhenPresent.of(values);
     }
 
     static <T> IsInWhenPresent<T> isInWhenPresent(Collection<T> values) {
@@ -791,7 +791,7 @@ static <T> IsNotInWithSubselect<T> isNotIn(Buildable<SelectModel> selectModelBui
 
     @SafeVarargs
     static <T> IsNotInWhenPresent<T> isNotInWhenPresent(T... values) {
-        return IsNotInWhenPresent.of(values);
+        return values == null ? IsNotInWhenPresent.empty() : IsNotInWhenPresent.of(values);
     }
 
     static <T> IsNotInWhenPresent<T> isNotInWhenPresent(Collection<T> values) {
@@ -914,7 +914,7 @@ static IsInCaseInsensitive isInCaseInsensitive(Collection<String> values) {
     }
 
     static IsInCaseInsensitiveWhenPresent isInCaseInsensitiveWhenPresent(String... values) {
-        return IsInCaseInsensitiveWhenPresent.of(values);
+        return values == null ? IsInCaseInsensitiveWhenPresent.empty() : IsInCaseInsensitiveWhenPresent.of(values);
     }
 
     static IsInCaseInsensitiveWhenPresent isInCaseInsensitiveWhenPresent(Collection<String> values) {
@@ -930,7 +930,8 @@ static IsNotInCaseInsensitive isNotInCaseInsensitive(Collection<String> values)
     }
 
     static IsNotInCaseInsensitiveWhenPresent isNotInCaseInsensitiveWhenPresent(String... values) {
-        return IsNotInCaseInsensitiveWhenPresent.of(values);
+        return values == null ? IsNotInCaseInsensitiveWhenPresent.empty() :
+                IsNotInCaseInsensitiveWhenPresent.of(values);
     }
 
     static IsNotInCaseInsensitiveWhenPresent isNotInCaseInsensitiveWhenPresent(Collection<String> values) {

src/main/java/org/mybatis/dynamic/sql/configuration/GlobalConfiguration.java

@@ -26,7 +26,6 @@ public class GlobalConfiguration {
     public static final String CONFIGURATION_FILE_PROPERTY = "mybatis-dynamic-sql.configurationFile"; //$NON-NLS-1$
     private static final String DEFAULT_PROPERTY_FILE = "mybatis-dynamic-sql.properties"; //$NON-NLS-1$
     private boolean isNonRenderingWhereClauseAllowed = false;
-    private boolean isEmptyListConditionRenderingAllowed = true;
     private final Properties properties = new Properties();
 
     public GlobalConfiguration() {
@@ -66,16 +65,9 @@ void loadProperties(InputStream inputStream, String propertyFile) {
     private void initializeKnownProperties() {
         String value = properties.getProperty("nonRenderingWhereClauseAllowed", "false"); //$NON-NLS-1$ //$NON-NLS-2$
         isNonRenderingWhereClauseAllowed = Boolean.parseBoolean(value);
-
-        value = properties.getProperty("emptyListConditionRenderingAllowed", "true"); //$NON-NLS-1$ //$NON-NLS-2$
-        isEmptyListConditionRenderingAllowed = Boolean.parseBoolean(value);
     }
 
     public boolean isIsNonRenderingWhereClauseAllowed() {
         return isNonRenderingWhereClauseAllowed;
     }
-
-    public boolean isEmptyListConditionRenderingAllowed() {
-        return isEmptyListConditionRenderingAllowed;
-    }
 }

src/main/java/org/mybatis/dynamic/sql/configuration/StatementConfiguration.java

@@ -25,13 +25,6 @@
  * Configurable behaviors are detailed below:
  *
  * <dl>
- *     <dt>emptyListConditionRenderingAllowed</dt>
- *     <dd>If false (default), the framework will not render list conditions that are empty in a where clause.
- *         This is beneficial in that it will not allow the library to generate invalid SQL, but it has a
- *         potentially dangerous side effect where a statement could be generated that impacts more rows
- *         then expected. If true, an empty list will be rendered as "in ()", "not in ()", etc. which will likely
- *         cause an SQLException at runtime.
- *     </dd>
  *     <dt>nonRenderingWhereClauseAllowed</dt>
  *     <dd>If false (default), the framework will throw a {@link NonRenderingWhereClauseException}
  *         if a where clause is specified in the statement, but it fails to render because all
@@ -51,9 +44,6 @@ public class StatementConfiguration {
     private boolean isNonRenderingWhereClauseAllowed =
             GlobalContext.getConfiguration().isIsNonRenderingWhereClauseAllowed();
 
-    private boolean isEmptyListConditionRenderingAllowed =
-            GlobalContext.getConfiguration().isEmptyListConditionRenderingAllowed();
-
     public boolean isNonRenderingWhereClauseAllowed() {
         return isNonRenderingWhereClauseAllowed;
     }
@@ -62,13 +52,4 @@ public StatementConfiguration setNonRenderingWhereClauseAllowed(boolean nonRende
         isNonRenderingWhereClauseAllowed = nonRenderingWhereClauseAllowed;
         return this;
     }
-
-    public boolean isEmptyListConditionRenderingAllowed() {
-        return isEmptyListConditionRenderingAllowed;
-    }
-
-    public StatementConfiguration setEmptyListConditionRenderingAllowed(boolean emptyListConditionRenderingAllowed) {
-        isEmptyListConditionRenderingAllowed = emptyListConditionRenderingAllowed;
-        return this;
-    }
 }

src/main/java/org/mybatis/dynamic/sql/render/RenderingContext.java

@@ -101,10 +101,6 @@ public boolean isNonRenderingClauseAllowed() {
         return statementConfiguration.isNonRenderingWhereClauseAllowed();
     }
 
-    public boolean isEmptyListConditionRenderingAllowed() {
-        return statementConfiguration.isEmptyListConditionRenderingAllowed();
-    }
-
     /**
      * Create a new rendering context based on this, with the table alias calculator modified to include the
      * specified child table alias calculator. This is used by the query expression renderer when the alias calculator

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

@@ -22,6 +22,7 @@
 import java.util.function.Predicate;
 
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
+import org.mybatis.dynamic.sql.render.RenderingContext;
 
 public class IsIn<T> extends AbstractListValueCondition<T> {
     private static final IsIn<?> EMPTY = new IsIn<>(Collections.emptyList());
@@ -36,6 +37,11 @@ protected IsIn(Collection<T> values) {
         super(values);
     }
 
+    @Override
+    public boolean shouldRender(RenderingContext renderingContext) {
+        return true;
+    }
+
     @Override
     public String operator() {
         return "in"; //$NON-NLS-1$
@@ -47,13 +53,12 @@ public IsIn<T> filter(Predicate<? super T> predicate) {
     }
 
     /**
-     * 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).
+     * If not empty, apply the mapping to each value in the list return a new condition with the mapped values.
+     *     Else return an empty condition (this).
      *
-     * @param mapper a mapping function to apply to the values, if renderable
+     * @param mapper a mapping function to apply to the values, if not empty
      * @param <R> type of the new condition
-     * @return a new condition with mapped values if renderable, otherwise a condition
-     *     that will not render.
+     * @return a new condition with mapped values if renderable, otherwise an empty condition
      */
     public <R> IsIn<R> map(Function<? super T, ? extends R> mapper) {
         Function<Collection<R>, IsIn<R>> constructor = IsIn::new;

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

@@ -22,6 +22,7 @@
 import java.util.function.UnaryOperator;
 
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
+import org.mybatis.dynamic.sql.render.RenderingContext;
 import org.mybatis.dynamic.sql.util.StringUtilities;
 
 public class IsInCaseInsensitive extends AbstractListValueCondition<String>
@@ -36,6 +37,11 @@ protected IsInCaseInsensitive(Collection<String> values) {
         super(values);
     }
 
+    @Override
+    public boolean shouldRender(RenderingContext renderingContext) {
+        return true;
+    }
+
     @Override
     public String operator() {
         return "in"; //$NON-NLS-1$
@@ -47,12 +53,11 @@ public IsInCaseInsensitive filter(Predicate<? super String> predicate) {
     }
 
     /**
-     * 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).
+     * If not empty, apply the mapping to each value in the list return a new condition with the mapped values.
+     *     Else return an empty condition (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.
+     * @param mapper a mapping function to apply to the values, if not empty
+     * @return a new condition with mapped values if renderable, otherwise an empty condition
      */
     public IsInCaseInsensitive map(UnaryOperator<String> mapper) {
         return mapSupport(mapper, IsInCaseInsensitive::new, IsInCaseInsensitive::empty);

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

@@ -24,7 +24,6 @@
 import java.util.stream.Collectors;
 
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
-import org.mybatis.dynamic.sql.render.RenderingContext;
 import org.mybatis.dynamic.sql.util.StringUtilities;
 
 public class IsInCaseInsensitiveWhenPresent extends AbstractListValueCondition<String>
@@ -39,11 +38,6 @@ protected IsInCaseInsensitiveWhenPresent(Collection<String> values) {
         super(values.stream().filter(Objects::nonNull).collect(Collectors.toList()));
     }
 
-    @Override
-    public boolean shouldRender(RenderingContext renderingContext) {
-        return !isEmpty();
-    }
-
     @Override
     public String operator() {
         return "in"; //$NON-NLS-1$
@@ -55,12 +49,11 @@ public IsInCaseInsensitiveWhenPresent filter(Predicate<? super String> predicate
     }
 
     /**
-     * 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).
+     * If not empty, apply the mapping to each value in the list return a new condition with the mapped values.
+     *     Else return an empty condition (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.
+     * @param mapper a mapping function to apply to the values, if not empty
+     * @return a new condition with mapped values if renderable, otherwise an empty condition
      */
     public IsInCaseInsensitiveWhenPresent map(UnaryOperator<String> mapper) {
         return mapSupport(mapper, IsInCaseInsensitiveWhenPresent::new, IsInCaseInsensitiveWhenPresent::empty);

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

@@ -24,7 +24,6 @@
 import java.util.stream.Collectors;
 
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
-import org.mybatis.dynamic.sql.render.RenderingContext;
 
 public class IsInWhenPresent<T> extends AbstractListValueCondition<T> {
     private static final IsInWhenPresent<?> EMPTY = new IsInWhenPresent<>(Collections.emptyList());
@@ -39,11 +38,6 @@ protected IsInWhenPresent(Collection<T> values) {
         super(values.stream().filter(Objects::nonNull).collect(Collectors.toList()));
     }
 
-    @Override
-    public boolean shouldRender(RenderingContext renderingContext) {
-        return !isEmpty();
-    }
-
     @Override
     public String operator() {
         return "in"; //$NON-NLS-1$
@@ -55,13 +49,12 @@ public IsInWhenPresent<T> filter(Predicate<? super T> predicate) {
     }
 
     /**
-     * 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).
+     * If not empty, apply the mapping to each value in the list return a new condition with the mapped values.
+     *     Else return an empty condition (this).
      *
-     * @param mapper a mapping function to apply to the values, if renderable
+     * @param mapper a mapping function to apply to the values, if not empty
      * @param <R> type of the new condition
-     * @return a new condition with mapped values if renderable, otherwise a condition
-     *     that will not render.
+     * @return a new condition with mapped values if renderable, otherwise an empty condition
      */
     public <R> IsInWhenPresent<R> map(Function<? super T, ? extends R> mapper) {
         Function<Collection<R>, IsInWhenPresent<R>> constructor = IsInWhenPresent::new;

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

@@ -22,6 +22,7 @@
 import java.util.function.Predicate;
 
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
+import org.mybatis.dynamic.sql.render.RenderingContext;
 
 public class IsNotIn<T> extends AbstractListValueCondition<T> {
     private static final IsNotIn<?> EMPTY = new IsNotIn<>(Collections.emptyList());
@@ -36,6 +37,11 @@ protected IsNotIn(Collection<T> values) {
         super(values);
     }
 
+    @Override
+    public boolean shouldRender(RenderingContext renderingContext) {
+        return true;
+    }
+
     @Override
     public String operator() {
         return "not in"; //$NON-NLS-1$
@@ -47,13 +53,12 @@ public IsNotIn<T> filter(Predicate<? super T> predicate) {
     }
 
     /**
-     * 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).
+     * If not empty, apply the mapping to each value in the list return a new condition with the mapped values.
+     *     Else return an empty condition (this).
      *
-     * @param mapper a mapping function to apply to the values, if renderable
+     * @param mapper a mapping function to apply to the values, if not empty
      * @param <R> type of the new condition
-     * @return a new condition with mapped values if renderable, otherwise a condition
-     *     that will not render.
+     * @return a new condition with mapped values if renderable, otherwise an empty condition
      */
     public <R> IsNotIn<R> map(Function<? super T, ? extends R> mapper) {
         Function<Collection<R>, IsNotIn<R>> constructor = IsNotIn::new;