Merge branch 'master' into implement-empty-callback

# Conflicts:
#	src/main/java/org/mybatis/dynamic/sql/AbstractListValueCondition.java
#	src/main/java/org/mybatis/dynamic/sql/where/condition/IsIn.java
#	src/main/java/org/mybatis/dynamic/sql/where/condition/IsInCaseInsensitive.java
#	src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInCaseInsensitive.java

Author: jeffgbutler

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

@@ -15,52 +15,48 @@
  */
 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.UnaryOperator;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-public abstract class AbstractListValueCondition<T, S extends AbstractListValueCondition<T, S>> implements VisitableCondition<T> {
+public abstract class AbstractListValueCondition<T> implements VisitableCondition<T> {
     protected final Collection<T> values;
     protected final UnaryOperator<Stream<T>> valueStreamTransformer;
-    protected final Callback callback;
+    protected boolean renderWhenEmpty = false;
 
     protected AbstractListValueCondition(Collection<T> values) {
-        this(values, UnaryOperator.identity(), () -> {});
+        this(values, UnaryOperator.identity());
     }
 
     protected AbstractListValueCondition(Collection<T> values, UnaryOperator<Stream<T>> valueStreamTransformer) {
-        this(values, valueStreamTransformer, () -> {});
-    }
-
-    protected AbstractListValueCondition(Collection<T> values, UnaryOperator<Stream<T>> valueStreamTransformer,
-            Callback callback) {
-        this.values = new ArrayList<>(Objects.requireNonNull(values));
         this.valueStreamTransformer = Objects.requireNonNull(valueStreamTransformer);
-        this.callback = Objects.requireNonNull(callback);
+        this.values = valueStreamTransformer.apply(Objects.requireNonNull(values).stream())
+            .collect(Collectors.toList());
     }
 
     public final <R> Stream<R> mapValues(Function<T, R> mapper) {
-        return valueStreamTransformer.apply(values.stream()).map(mapper);
+        return values.stream().map(mapper);
     }
 
     @Override
     public boolean shouldRender() {
-        if (values.isEmpty()) {
-            callback.call();
-            return false;
-        } else {
-            return true;
-        }
+        return !values.isEmpty() || renderWhenEmpty;
     }
 
+    /**
+     * Use with caution - this could cause the library to render invalid SQL like "where column in ()".
+     */
+    protected void forceRenderingWhenEmpty() {
+        renderWhenEmpty = true;
+    }
+    
     @Override
     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);
 }

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

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2019 the original author or authors.
+ *    Copyright 2016-2020 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.
@@ -23,21 +23,15 @@
 import java.util.stream.Stream;
 
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
-import org.mybatis.dynamic.sql.Callback;
 
-public class IsIn<T> extends AbstractListValueCondition<T, IsIn<T>> {
+public class IsIn<T> extends AbstractListValueCondition<T> {
 
-    protected IsIn(Collection<T> values) {
-        super(values);
-    }
-
-    protected IsIn(Collection<T> values, UnaryOperator<Stream<T>> valueStreamTransformer, Callback callback) {
-        super(values, valueStreamTransformer, callback);
+    protected IsIn(Collection<T> values, UnaryOperator<Stream<T>> valueStreamTransformer) {
+        super(values, valueStreamTransformer);
     }
 
-    @Override
-    public IsIn<T> withListEmptyCallback(Callback callback) {
-        return new IsIn<>(values, valueStreamTransformer, callback);
+    protected IsIn(Collection<T> values) {
+        super(values);
     }
 
     @Override
@@ -57,7 +51,9 @@ public String renderCondition(String columnName, Stream<String> placeholders) {
      * @return new condition with the specified transformer
      */
     public IsIn<T> then(UnaryOperator<Stream<T>> valueStreamTransformer) {
-        return new IsIn<>(values, valueStreamTransformer, callback);
+        IsIn<T> answer = new IsIn<>(values, valueStreamTransformer);
+        answer.renderWhenEmpty = renderWhenEmpty;
+        return answer;
     }
 
     public static <T> IsIn<T> of(Collection<T> values) {

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

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2019 the original author or authors.
+ *    Copyright 2016-2020 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.
@@ -21,23 +21,16 @@
 import java.util.stream.Stream;
 
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
-import org.mybatis.dynamic.sql.Callback;
 import org.mybatis.dynamic.sql.util.StringUtilities;
 
-public class IsInCaseInsensitive extends AbstractListValueCondition<String, IsInCaseInsensitive> {
+public class IsInCaseInsensitive extends AbstractListValueCondition<String> {
 
-    protected IsInCaseInsensitive(Collection<String> values, UnaryOperator<Stream<String>> valueStreamTransformer) {
-        super(values, valueStreamTransformer);
-    }
-
-    protected IsInCaseInsensitive(Collection<String> values, UnaryOperator<Stream<String>> valueStreamTransformer,
-                                  Callback callback) {
-        super(values, valueStreamTransformer, callback);
+    protected IsInCaseInsensitive(Collection<String> values) {
+        super(values, s -> s.map(StringUtilities::safelyUpperCase));
     }
 
-    @Override
-    public IsInCaseInsensitive withListEmptyCallback(Callback callback) {
-        return new IsInCaseInsensitive(values, valueStreamTransformer, callback);
+    protected IsInCaseInsensitive(Collection<String> values, UnaryOperator<Stream<String>> valueStreamTransformer) {
+        super(values, StringUtilities.upperCaseAfter(valueStreamTransformer));
     }
 
     @Override
@@ -46,7 +39,23 @@ public String renderCondition(String columnName, Stream<String> placeholders) {
                 placeholders.collect(Collectors.joining(",", "in (", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     }
 
+    /**
+     * This method allows you to modify the condition's values before they are placed into the parameter map.
+     * For example, you could filter nulls, or trim strings, etc. This process will run before final rendering of SQL.
+     * 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.
+     * 
+     * @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
+     */
+    public IsInCaseInsensitive then(UnaryOperator<Stream<String>> valueStreamTransformer) {
+        IsInCaseInsensitive answer = new IsInCaseInsensitive(values, valueStreamTransformer);
+        answer.renderWhenEmpty = renderWhenEmpty;
+        return answer;
+    }
+
     public static IsInCaseInsensitive of(Collection<String> values) {
-        return new IsInCaseInsensitive(values, s -> s.map(StringUtilities::safelyUpperCase));
+        return new IsInCaseInsensitive(values);
     }
 }

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

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2019 the original author or authors.
+ *    Copyright 2016-2020 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.
@@ -52,7 +52,9 @@ public String renderCondition(String columnName, Stream<String> placeholders) {
      * @return new condition with the specified transformer
      */
     public IsNotIn<T> then(UnaryOperator<Stream<T>> valueStreamTransformer) {
-        return new IsNotIn<>(values, valueStreamTransformer);
+        IsNotIn<T> answer = new IsNotIn<>(values, valueStreamTransformer);
+        answer.renderWhenEmpty = renderWhenEmpty;
+        return answer;
     }
 
     public static <T> IsNotIn<T> of(Collection<T> values) {

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

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2019 the original author or authors.
+ *    Copyright 2016-2020 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.
@@ -25,8 +25,12 @@
 
 public class IsNotInCaseInsensitive extends AbstractListValueCondition<String> {
 
+    protected IsNotInCaseInsensitive(Collection<String> values) {
+        super(values, s -> s.map(StringUtilities::safelyUpperCase));
+    }
+
     protected IsNotInCaseInsensitive(Collection<String> values, UnaryOperator<Stream<String>> valueStreamTransformer) {
-        super(values, valueStreamTransformer);
+        super(values, StringUtilities.upperCaseAfter(valueStreamTransformer));
     }
 
     @Override
@@ -36,7 +40,23 @@ public String renderCondition(String columnName, Stream<String> placeholders) {
                         Collectors.joining(",", "not in (", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     }
 
+    /**
+     * This method allows you to modify the condition's values before they are placed into the parameter map.
+     * For example, you could filter nulls, or trim strings, etc. This process will run before final rendering of SQL.
+     * 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.
+     * 
+     * @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
+     */
+    public IsNotInCaseInsensitive then(UnaryOperator<Stream<String>> valueStreamTransformer) {
+        IsNotInCaseInsensitive answer = new IsNotInCaseInsensitive(values, valueStreamTransformer);
+        answer.renderWhenEmpty = renderWhenEmpty;
+        return answer;
+    }
+
     public static IsNotInCaseInsensitive of(Collection<String> values) {
-        return new IsNotInCaseInsensitive(values, s -> s.map(StringUtilities::safelyUpperCase));
+        return new IsNotInCaseInsensitive(values);
     }
 }

src/test/java/examples/animal/data/AnimalDataTest.java

@@ -27,10 +27,12 @@
 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 
 import org.apache.ibatis.datasource.unpooled.UnpooledDataSource;
 import org.apache.ibatis.jdbc.ScriptRunner;
@@ -57,6 +59,7 @@
 import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
 import org.mybatis.dynamic.sql.util.mybatis3.MyBatis3Utils;
 import org.mybatis.dynamic.sql.where.condition.IsIn;
+import org.mybatis.dynamic.sql.where.condition.IsNotIn;
 import org.mybatis.dynamic.sql.where.render.WhereClauseProvider;
 
 class AnimalDataTest {
@@ -569,6 +572,47 @@ void testInCondition() {
         }
     }
 
+    @Test
+    void testInConditionWithEventuallyEmptyList() {
+        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
+            AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
+
+            SelectStatementProvider selectStatement = select(id, animalName, bodyWeight, brainWeight)
+                    .from(animalData)
+                    .where(id, isIn(null, 22, null).then(s -> s.filter(Objects::nonNull).filter(i -> i != 22)))
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+
+            assertThat(selectStatement.getSelectStatement())
+                    .isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData");
+            List<AnimalData> animals = mapper.selectMany(selectStatement);
+            assertThat(animals).hasSize(65);
+        }
+    }
+
+    @Test
+    void testInConditionWithEventuallyEmptyListForceRendering() {
+        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
+            AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
+
+            List<Integer> inValues = new ArrayList<>();
+            inValues.add(null);
+            inValues.add(22);
+            inValues.add(null);
+
+            SelectStatementProvider selectStatement = select(id, animalName, bodyWeight, brainWeight)
+                    .from(animalData)
+                    .where(id, IsInRequired.isIn(inValues).then(s -> s.filter(Objects::nonNull).filter(i -> i != 22)))
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+
+            assertThat(selectStatement.getSelectStatement())
+                    .isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id in ()");
+
+            assertThatExceptionOfType(PersistenceException.class).isThrownBy(() -> mapper.selectMany(selectStatement));
+        }
+    }
+
     @Test
     void testInConditionWithEmptyList() {
         assertThatExceptionOfType(RuntimeException.class).describedAs("Fred").isThrownBy(() ->
@@ -650,6 +694,54 @@ void testNotInCaseSensitiveConditionWithNull() {
         }
     }
 
+    @Test
+    void testNotInConditionWithEventuallyEmptyList() {
+        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
+            AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
+
+            SelectStatementProvider selectStatement = select(id, animalName, bodyWeight, brainWeight)
+                    .from(animalData)
+                    .where(id, isNotIn(null, 22, null).then(s -> s.filter(Objects::nonNull).filter(i -> i != 22)))
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+
+            assertThat(selectStatement.getSelectStatement())
+                    .isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData");
+            List<AnimalData> animals = mapper.selectMany(selectStatement);
+            assertThat(animals).hasSize(65);
+        }
+    }
+
+    @Test
+    void testNotInConditionWithEventuallyEmptyListForceRendering() {
+        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
+            AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
+
+            SelectStatementProvider selectStatement = select(id, animalName, bodyWeight, brainWeight)
+                    .from(animalData)
+                    .where(id, IsNotInRequired.isNotIn(null, 22, null)
+                            .then(s -> s.filter(Objects::nonNull).filter(i -> i != 22)))
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+
+            assertThat(selectStatement.getSelectStatement())
+                    .isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id not in ()");
+
+            assertThatExceptionOfType(PersistenceException.class).isThrownBy(() -> mapper.selectMany(selectStatement));
+        }
+    }
+
+    public static class IsNotInRequired<T> extends IsNotIn<T> {
+        protected IsNotInRequired(Collection<T> values) {
+            super(values);
+            forceRenderingWhenEmpty();
+        }
+
+        @SafeVarargs
+        public static <T> IsNotInRequired<T> isNotIn(T...values) {
+            return new IsNotInRequired<>(Arrays.asList(values));
+        }
+    }
     @Test
     void testLikeCondition() {
         try (SqlSession sqlSession = sqlSessionFactory.openSession()) {