Progress on implementing empty callback

jeffgbutler · jeffgbutler · commit 129552dfb054 · 2020-08-27T09:08:10.000-04:00
diff --git a/src/main/java/org/mybatis/dynamic/sql/AbstractListValueCondition.java b/src/main/java/org/mybatis/dynamic/sql/AbstractListValueCondition.java
@@ -22,18 +22,24 @@
 import java.util.function.UnaryOperator;
 import java.util.stream.Stream;
 
-public abstract class AbstractListValueCondition<T> implements VisitableCondition<T> {
+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 boolean renderWhenEmpty = false;
+    protected final Callback callback;
 
     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);
     }
     
     public final <R> Stream<R> mapValues(Function<T, R> mapper) {
@@ -42,20 +48,19 @@ public final <R> Stream<R> mapValues(Function<T, R> mapper) {
     
     @Override
     public boolean shouldRender() {
-        return !values.isEmpty() || renderWhenEmpty;
+        if (values.isEmpty()) {
+            callback.call();
+            return false;
+        } else {
+            return true;
+        }
     }
 
-    /**
-     * 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);
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/Callback.java b/src/main/java/org/mybatis/dynamic/sql/Callback.java
@@ -0,0 +1,19 @@
+package org.mybatis.dynamic.sql;
+
+import java.util.function.Function;
+
+@FunctionalInterface
+public interface Callback {
+    void call();
+
+    static Callback runtimeExceptionThrowingCallback(String message) {
+        return exceptionThrowingCallback(message, RuntimeException::new);
+    }
+
+    static Callback exceptionThrowingCallback(String message,
+            Function<String, ? extends RuntimeException> exceptionBuilder) {
+        return () -> {
+            throw exceptionBuilder.apply(message);
+        };
+    }
+}
diff --git a/src/main/java/org/mybatis/dynamic/sql/ConditionVisitor.java b/src/main/java/org/mybatis/dynamic/sql/ConditionVisitor.java
@@ -16,7 +16,7 @@
 package org.mybatis.dynamic.sql;
 
 public interface ConditionVisitor<T, R> {
-    R visit(AbstractListValueCondition<T> condition);
+    R visit(AbstractListValueCondition<T, ?> condition);
 
     R visit(AbstractNoValueCondition<T> condition);
 
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsIn.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsIn.java
@@ -23,17 +23,23 @@
 import java.util.stream.Stream;
 
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
+import org.mybatis.dynamic.sql.Callback;
 
-public class IsIn<T> extends AbstractListValueCondition<T> {
-
-    protected IsIn(Collection<T> values, UnaryOperator<Stream<T>> valueStreamTransformer) {
-        super(values, valueStreamTransformer);
-    }
+public class IsIn<T> extends AbstractListValueCondition<T, IsIn<T>> {
 
     protected IsIn(Collection<T> values) {
         super(values);
     }
 
+    protected IsIn(Collection<T> values, UnaryOperator<Stream<T>> valueStreamTransformer, Callback callback) {
+        super(values, valueStreamTransformer, callback);
+    }
+
+    @Override
+    public IsIn<T> withListEmptyCallback(Callback callback) {
+        return new IsIn<>(values, valueStreamTransformer, callback);
+    }
+
     @Override
     public String renderCondition(String columnName, Stream<String> placeholders) {
         return spaceAfter(columnName)
@@ -51,7 +57,7 @@ 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);
+        return new IsIn<>(values, valueStreamTransformer, callback);
     }
 
     public static <T> IsIn<T> of(Collection<T> values) {
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsInCaseInsensitive.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsInCaseInsensitive.java
@@ -21,14 +21,25 @@
 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> {
+public class IsInCaseInsensitive extends AbstractListValueCondition<String, IsInCaseInsensitive> {
 
     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);
+    }
+
+    @Override
+    public IsInCaseInsensitive withListEmptyCallback(Callback callback) {
+        return new IsInCaseInsensitive(values, valueStreamTransformer, callback);
+    }
+
     @Override
     public String renderCondition(String columnName, Stream<String> placeholders) {
         return "upper(" + columnName + ") " + //$NON-NLS-1$ //$NON-NLS-2$
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsInCaseInsensitiveWhenPresent.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsInCaseInsensitiveWhenPresent.java
@@ -15,6 +15,7 @@
  */
 package org.mybatis.dynamic.sql.where.condition;
 
+import org.mybatis.dynamic.sql.Callback;
 import org.mybatis.dynamic.sql.util.StringUtilities;
 
 import java.util.Collection;
@@ -24,12 +25,21 @@
 
 public class IsInCaseInsensitiveWhenPresent extends IsInCaseInsensitive {
 
-    protected IsInCaseInsensitiveWhenPresent(Collection<String> values, UnaryOperator<Stream<String>> valueStreamTransformer) {
-        super(values, valueStreamTransformer);
+    protected IsInCaseInsensitiveWhenPresent(Collection<String> values) {
+        super(values, s -> s.filter(Objects::nonNull).map(StringUtilities::safelyUpperCase));
+    }
+
+    protected IsInCaseInsensitiveWhenPresent(Collection<String> values, UnaryOperator<Stream<String>> valueStreamTransformer,
+                                             Callback callback) {
+        super(values, valueStreamTransformer, callback);
+    }
+
+    @Override
+    public IsInCaseInsensitiveWhenPresent withListEmptyCallback(Callback callback) {
+        return new IsInCaseInsensitiveWhenPresent(values, valueStreamTransformer, callback);
     }
 
     public static IsInCaseInsensitiveWhenPresent of(Collection<String> values) {
-        return new IsInCaseInsensitiveWhenPresent(values,
-                s -> s.filter(Objects::nonNull).map(StringUtilities::safelyUpperCase));
+        return new IsInCaseInsensitiveWhenPresent(values);
     }
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/render/WhereConditionVisitor.java b/src/main/java/org/mybatis/dynamic/sql/where/render/WhereConditionVisitor.java
@@ -50,7 +50,7 @@ private WhereConditionVisitor(Builder<T> builder) {
     }
 
     @Override
-    public FragmentAndParameters visit(AbstractListValueCondition<T> condition) {
+    public FragmentAndParameters visit(AbstractListValueCondition<T, ?> condition) {
         FragmentCollector fc = condition.mapValues(this::toFragmentAndParameters)
                 .collect(FragmentCollector.collect());
         
diff --git a/src/test/java/examples/animal/data/AnimalDataTest.java b/src/test/java/examples/animal/data/AnimalDataTest.java
@@ -33,7 +33,6 @@
 import java.util.Map;
 
 import org.apache.ibatis.datasource.unpooled.UnpooledDataSource;
-import org.apache.ibatis.exceptions.PersistenceException;
 import org.apache.ibatis.jdbc.ScriptRunner;
 import org.apache.ibatis.mapping.Environment;
 import org.apache.ibatis.session.Configuration;
@@ -45,6 +44,7 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mybatis.dynamic.sql.BasicColumn;
+import org.mybatis.dynamic.sql.Callback;
 import org.mybatis.dynamic.sql.SqlTable;
 import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
 import org.mybatis.dynamic.sql.insert.render.BatchInsert;
@@ -571,30 +571,21 @@ void testInCondition() {
 
     @Test
     void testInConditionWithEmptyList() {
-        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
-            AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
-            
-            SelectStatementProvider selectStatement = select(id, animalName, bodyWeight, brainWeight)
-                    .from(animalData)
-                    .where(id, IsInRequired.isIn(Collections.emptyList()))
-                    .build()
-                    .render(RenderingStrategies.MYBATIS3);
-
-            assertThatExceptionOfType(PersistenceException.class).isThrownBy(() -> mapper.selectMany(selectStatement));
-        }
+        assertThatExceptionOfType(RuntimeException.class).describedAs("Fred").isThrownBy(() ->
+                select(id, animalName, bodyWeight, brainWeight)
+                        .from(animalData)
+                        .where(id, isInRequired(Collections.emptyList()))
+                        .build()
+                        .render(RenderingStrategies.MYBATIS3)
+        );
     }
 
-    public static class IsInRequired<T> extends IsIn<T> {
-        protected IsInRequired(Collection<T> values) {
-            super(values);
-            forceRenderingWhenEmpty();
-        }
-        
-        public static <T> IsInRequired<T> isIn(Collection<T> values) {
-            return new IsInRequired<>(values);
-        }
+    public static <T> IsIn<T> isInRequired(Collection<T> values) {
+        throw new RuntimeException("fred");
+        // TODO...
+//        return IsIn.of(values).withListEmptyCallback(Callback.runtimeExceptionThrowingCallback("Fred"));
     }
-    
+
     @Test
     void testInCaseSensitiveCondition() {
         try (SqlSession sqlSession = sqlSessionFactory.openSession()) {

Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ private WhereConditionVisitor(Builder<T> builder) {`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`@Override`
`53`		`- public FragmentAndParameters visit(AbstractListValueCondition<T> condition) {`
	`53`	`+ public FragmentAndParameters visit(AbstractListValueCondition<T, ?> condition) {`
`54`	`54`	`FragmentCollector fc = condition.mapValues(this::toFragmentAndParameters)`
`55`	`55`	`.collect(FragmentCollector.collect());`
`56`	`56`