Consistency of methods across functions and conditions

jeffgbutler · jeffgbutler · commit ff3138150aa4 · 2020-09-29T12:58:07.000-04:00
diff --git a/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java b/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java
@@ -359,22 +359,22 @@ static StringConstant stringConstant(String constant) {
     // functions
     static <T extends Number> Add<T> add(BindableColumn<T> firstColumn, BasicColumn secondColumn,
             BasicColumn... subsequentColumns) {
-        return Add.of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));
+        return Add.of(firstColumn, secondColumn, subsequentColumns);
     }
 
     static <T extends Number> Divide<T> divide(BindableColumn<T> firstColumn, BasicColumn secondColumn,
             BasicColumn... subsequentColumns) {
-        return Divide.of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));
+        return Divide.of(firstColumn, secondColumn, subsequentColumns);
     }
 
     static <T extends Number> Multiply<T> multiply(BindableColumn<T> firstColumn, BasicColumn secondColumn,
             BasicColumn... subsequentColumns) {
-        return Multiply.of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));
+        return Multiply.of(firstColumn, secondColumn, subsequentColumns);
     }
 
     static <T extends Number> Subtract<T> subtract(BindableColumn<T> firstColumn, BasicColumn secondColumn,
             BasicColumn... subsequentColumns) {
-        return Subtract.of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));
+        return Subtract.of(firstColumn, secondColumn, subsequentColumns);
     }
 
     static <T> Concatenate<T> concatenate(BindableColumn<T> firstColumn, BasicColumn secondColumn,
@@ -555,7 +555,7 @@ static <T> IsLessThanOrEqualToWhenPresent<T> isLessThanOrEqualToWhenPresent(Supp
 
     @SafeVarargs
     static <T> IsIn<T> isIn(T...values) {
-        return isIn(Arrays.asList(values));
+        return IsIn.of(values);
     }
 
     static <T> IsIn<T> isIn(Collection<T> values) {
@@ -568,7 +568,7 @@ static <T> IsInWithSubselect<T> isIn(Buildable<SelectModel> selectModelBuilder)
 
     @SafeVarargs
     static <T> IsInWhenPresent<T> isInWhenPresent(T...values) {
-        return isInWhenPresent(Arrays.asList(values));
+        return IsInWhenPresent.of(values);
     }
 
     static <T> IsInWhenPresent<T> isInWhenPresent(Collection<T> values) {
@@ -577,7 +577,7 @@ static <T> IsInWhenPresent<T> isInWhenPresent(Collection<T> values) {
 
     @SafeVarargs
     static <T> IsNotIn<T> isNotIn(T...values) {
-        return isNotIn(Arrays.asList(values));
+        return IsNotIn.of(values);
     }
 
     static <T> IsNotIn<T> isNotIn(Collection<T> values) {
@@ -590,7 +590,7 @@ static <T> IsNotInWithSubselect<T> isNotIn(Buildable<SelectModel> selectModelBui
 
     @SafeVarargs
     static <T> IsNotInWhenPresent<T> isNotInWhenPresent(T...values) {
-        return isNotInWhenPresent(Arrays.asList(values));
+        return IsNotInWhenPresent.of(values);
     }
 
     static <T> IsNotInWhenPresent<T> isNotInWhenPresent(Collection<T> values) {
@@ -705,31 +705,31 @@ static IsNotLikeCaseInsensitiveWhenPresent isNotLikeCaseInsensitiveWhenPresent(S
     }
 
     static IsInCaseInsensitive isInCaseInsensitive(String...values) {
-        return isInCaseInsensitive(Arrays.asList(values));
+        return IsInCaseInsensitive.of(values);
     }
 
     static IsInCaseInsensitive isInCaseInsensitive(Collection<String> values) {
         return IsInCaseInsensitive.of(values);
     }
 
     static IsInCaseInsensitiveWhenPresent isInCaseInsensitiveWhenPresent(String...values) {
-        return isInCaseInsensitiveWhenPresent(Arrays.asList(values));
+        return IsInCaseInsensitiveWhenPresent.of(values);
     }
 
     static IsInCaseInsensitiveWhenPresent isInCaseInsensitiveWhenPresent(Collection<String> values) {
         return IsInCaseInsensitiveWhenPresent.of(values);
     }
 
     static IsNotInCaseInsensitive isNotInCaseInsensitive(String...values) {
-        return isNotInCaseInsensitive(Arrays.asList(values));
+        return IsNotInCaseInsensitive.of(values);
     }
 
     static IsNotInCaseInsensitive isNotInCaseInsensitive(Collection<String> values) {
         return IsNotInCaseInsensitive.of(values);
     }
 
     static IsNotInCaseInsensitiveWhenPresent isNotInCaseInsensitiveWhenPresent(String...values) {
-        return isNotInCaseInsensitiveWhenPresent(Arrays.asList(values));
+        return IsNotInCaseInsensitiveWhenPresent.of(values);
     }
 
     static IsNotInCaseInsensitiveWhenPresent isNotInCaseInsensitiveWhenPresent(Collection<String> values) {
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/AbstractCount.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/AbstractCount.java
@@ -23,8 +23,6 @@
  * Count functions are implemented differently than the other aggregates. This is primarily to preserve
  * backwards compatibility. Count functions are configured as BindableColumns of type Long
  * as it is assumed that the count functions always return a number.
- *
- * @param <T> the subtype of this class
  */
 public abstract class AbstractCount implements BindableColumn<Long> {
     private final String alias;
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/function/Add.java b/src/main/java/org/mybatis/dynamic/sql/select/function/Add.java
@@ -15,6 +15,7 @@
  */
 package org.mybatis.dynamic.sql.select.function;
 
+import java.util.Arrays;
 import java.util.List;
 
 import org.mybatis.dynamic.sql.BasicColumn;
@@ -32,6 +33,11 @@ protected Add<T> copy() {
         return new Add<>(column, secondColumn, subsequentColumns);
     }
 
+    public static <T extends Number> Add<T> of(BindableColumn<T> firstColumn, BasicColumn secondColumn,
+                                               BasicColumn... subsequentColumns) {
+        return of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));
+    }
+
     public static <T extends Number> Add<T> of(BindableColumn<T> firstColumn, BasicColumn secondColumn,
             List<BasicColumn> subsequentColumns) {
         return new Add<>(firstColumn, secondColumn, subsequentColumns);
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/function/Divide.java b/src/main/java/org/mybatis/dynamic/sql/select/function/Divide.java
@@ -15,6 +15,7 @@
  */
 package org.mybatis.dynamic.sql.select.function;
 
+import java.util.Arrays;
 import java.util.List;
 
 import org.mybatis.dynamic.sql.BasicColumn;
@@ -32,6 +33,11 @@ protected Divide<T> copy() {
         return new Divide<>(column, secondColumn, subsequentColumns);
     }
 
+    public static <T extends Number> Divide<T> of(BindableColumn<T> firstColumn, BasicColumn secondColumn,
+                                                  BasicColumn... subsequentColumns) {
+        return of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));
+    }
+
     public static <T extends Number> Divide<T> of(BindableColumn<T> firstColumn, BasicColumn secondColumn,
             List<BasicColumn> subsequentColumns) {
         return new Divide<>(firstColumn, secondColumn, subsequentColumns);
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/function/Multiply.java b/src/main/java/org/mybatis/dynamic/sql/select/function/Multiply.java
@@ -15,6 +15,7 @@
  */
 package org.mybatis.dynamic.sql.select.function;
 
+import java.util.Arrays;
 import java.util.List;
 
 import org.mybatis.dynamic.sql.BasicColumn;
@@ -32,6 +33,11 @@ protected Multiply<T> copy() {
         return new Multiply<>(column, secondColumn, subsequentColumns);
     }
 
+    public static <T extends Number> Multiply<T> of(BindableColumn<T> firstColumn, BasicColumn secondColumn,
+                                                    BasicColumn... subsequentColumns) {
+        return of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));
+    }
+
     public static <T extends Number> Multiply<T> of(BindableColumn<T> firstColumn, BasicColumn secondColumn,
             List<BasicColumn> subsequentColumns) {
         return new Multiply<>(firstColumn, secondColumn, subsequentColumns);
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/function/OperatorFunction.java b/src/main/java/org/mybatis/dynamic/sql/select/function/OperatorFunction.java
@@ -59,6 +59,11 @@ public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) {
 
     public static <T> OperatorFunction<T> of(String operator, BindableColumn<T> firstColumn, BasicColumn secondColumn,
             BasicColumn... subsequentColumns) {
-        return new OperatorFunction<>(operator, firstColumn, secondColumn, Arrays.asList(subsequentColumns));
+        return of(operator, firstColumn, secondColumn, Arrays.asList(subsequentColumns));
+    }
+
+    public static <T> OperatorFunction<T> of(String operator, BindableColumn<T> firstColumn, BasicColumn secondColumn,
+                                             List<BasicColumn> subsequentColumns) {
+        return new OperatorFunction<>(operator, firstColumn, secondColumn, subsequentColumns);
     }
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/function/Subtract.java b/src/main/java/org/mybatis/dynamic/sql/select/function/Subtract.java
@@ -15,6 +15,7 @@
  */
 package org.mybatis.dynamic.sql.select.function;
 
+import java.util.Arrays;
 import java.util.List;
 
 import org.mybatis.dynamic.sql.BasicColumn;
@@ -33,7 +34,12 @@ protected Subtract<T> copy() {
     }
 
     public static <T extends Number> Subtract<T> of(BindableColumn<T> firstColumn, BasicColumn secondColumn,
-            List<BasicColumn> subsequentColumns) {
+            BasicColumn... subsequentColumns) {
+        return of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));
+    }
+
+    public static <T extends Number> Subtract<T> of(BindableColumn<T> firstColumn, BasicColumn secondColumn,
+                                                    List<BasicColumn> subsequentColumns) {
         return new Subtract<>(firstColumn, secondColumn, subsequentColumns);
     }
 }
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
@@ -17,6 +17,7 @@
 
 import static org.mybatis.dynamic.sql.util.StringUtilities.spaceAfter;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
@@ -64,6 +65,11 @@ public IsIn<T> then(UnaryOperator<Stream<T>> valueStreamTransformer) {
                 .build();
     }
 
+    @SafeVarargs
+    public static <T> IsIn<T> of(T... values) {
+        return of(Arrays.asList(values));
+    }
+
     public static <T> IsIn<T> of(Collection<T> values) {
         return new Builder<T>().withValues(values).build();
     }
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
@@ -15,6 +15,7 @@
  */
 package org.mybatis.dynamic.sql.where.condition;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -44,6 +45,10 @@ public IsInCaseInsensitive withListEmptyCallback(Callback callback) {
                 .build();
     }
 
+    public static IsInCaseInsensitive of(String... values) {
+        return of(Arrays.asList(values));
+    }
+
     public static IsInCaseInsensitive of(Collection<String> values) {
         return new Builder()
                 .withValues(values)
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 java.util.Arrays;
 import java.util.Collection;
 import java.util.Objects;
 import java.util.stream.Collectors;
@@ -45,6 +46,10 @@ public IsInCaseInsensitiveWhenPresent withListEmptyCallback(Callback callback) {
                 .build();
     }
 
+    public static IsInCaseInsensitiveWhenPresent of(String... values) {
+        return of(Arrays.asList(values));
+    }
+
     public static IsInCaseInsensitiveWhenPresent of(Collection<String> values) {
         return new Builder()
                 .withValues(values)
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsInWhenPresent.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsInWhenPresent.java
@@ -17,6 +17,7 @@
 
 import static org.mybatis.dynamic.sql.util.StringUtilities.spaceAfter;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Objects;
 import java.util.stream.Collectors;
@@ -46,6 +47,11 @@ public IsInWhenPresent<T> withListEmptyCallback(Callback callback) {
                 .build();
     }
 
+    @SafeVarargs
+    public static <T> IsInWhenPresent<T> of(T... values) {
+        return of(Arrays.asList(values));
+    }
+
     public static <T> IsInWhenPresent<T> of(Collection<T> values) {
         return new Builder<T>()
                 .withValues(values)
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotIn.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotIn.java
@@ -17,6 +17,7 @@
 
 import static org.mybatis.dynamic.sql.util.StringUtilities.spaceAfter;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
@@ -65,6 +66,11 @@ public IsNotIn<T> then(UnaryOperator<Stream<T>> valueStreamTransformer) {
                 .build();
     }
 
+    @SafeVarargs
+    public static <T> IsNotIn<T> of(T... values) {
+        return of(Arrays.asList(values));
+    }
+
     public static <T> IsNotIn<T> of(Collection<T> values) {
         return new Builder<T>()
                 .withValues(values)
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInCaseInsensitive.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInCaseInsensitive.java
@@ -15,6 +15,7 @@
  */
 package org.mybatis.dynamic.sql.where.condition;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -45,6 +46,10 @@ public IsNotInCaseInsensitive withListEmptyCallback(Callback callback) {
                 .build();
     }
 
+    public static IsNotInCaseInsensitive of(String... values) {
+        return of(Arrays.asList(values));
+    }
+
     public static IsNotInCaseInsensitive of(Collection<String> values) {
         return new Builder()
                 .withValues(values)
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInCaseInsensitiveWhenPresent.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInCaseInsensitiveWhenPresent.java
@@ -15,6 +15,7 @@
  */
 package org.mybatis.dynamic.sql.where.condition;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Objects;
 import java.util.stream.Collectors;
@@ -47,6 +48,10 @@ public IsNotInCaseInsensitiveWhenPresent withListEmptyCallback(Callback callback
                 .build();
     }
 
+    public static IsNotInCaseInsensitiveWhenPresent of(String... values) {
+        return of(Arrays.asList(values));
+    }
+
     public static IsNotInCaseInsensitiveWhenPresent of(Collection<String> values) {
         return new Builder()
                 .withValues(values)
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInWhenPresent.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInWhenPresent.java
@@ -17,6 +17,7 @@
 
 import static org.mybatis.dynamic.sql.util.StringUtilities.spaceAfter;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Objects;
 import java.util.stream.Collectors;
@@ -54,6 +55,11 @@ public static <T> IsNotInWhenPresent<T> of(Collection<T> values) {
                 .build();
     }
 
+    @SafeVarargs
+    public static <T> IsNotInWhenPresent<T> of(T... values) {
+        return of(Arrays.asList(values));
+    }
+
     public static class Builder<T> extends AbstractListConditionBuilder<T, Builder<T>> {
         @Override
         protected Builder<T> getThis() {
diff --git a/src/test/java/org/mybatis/dynamic/sql/select/SelectStatementTest.java b/src/test/java/org/mybatis/dynamic/sql/select/SelectStatementTest.java
@@ -263,6 +263,34 @@ void testGroupBySingleColumn() {
         );
     }
 
+    @Test
+    void testInEmptyList() {
+        List<String> emptyList = Collections.emptyList();
+        SelectModel selectModel = select(column1, column3)
+                .from(table, "a")
+                .where(column3, isIn(emptyList)
+                        .withListEmptyCallback(Callback.exceptionThrowingCallback("Fred")))
+                .build();
+
+        assertThatExceptionOfType(RuntimeException.class).describedAs("Fred").isThrownBy(() ->
+                selectModel.render(RenderingStrategies.MYBATIS3)
+        );
+    }
+
+    @Test
+    void testNotInEmptyList() {
+        List<String> emptyList = Collections.emptyList();
+        SelectModel selectModel = select(column1, column3)
+                .from(table, "a")
+                .where(column3, isNotIn(emptyList)
+                        .withListEmptyCallback(Callback.exceptionThrowingCallback("Fred")))
+                .build();
+
+        assertThatExceptionOfType(RuntimeException.class).describedAs("Fred").isThrownBy(() ->
+                selectModel.render(RenderingStrategies.MYBATIS3)
+        );
+    }
+
     @Test
     void testInWhenPresentEmptyList() {
         List<String> emptyList = Collections.emptyList();

Original file line number	Diff line number	Diff line change
`@@ -359,22 +359,22 @@ static StringConstant stringConstant(String constant) {`
`359`	`359`	`// functions`
`360`	`360`	`static <T extends Number> Add<T> add(BindableColumn<T> firstColumn, BasicColumn secondColumn,`
`361`	`361`	`BasicColumn... subsequentColumns) {`
`362`		`- return Add.of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));`
	`362`	`+ return Add.of(firstColumn, secondColumn, subsequentColumns);`
`363`	`363`	`}`
`364`	`364`
`365`	`365`	`static <T extends Number> Divide<T> divide(BindableColumn<T> firstColumn, BasicColumn secondColumn,`
`366`	`366`	`BasicColumn... subsequentColumns) {`
`367`		`- return Divide.of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));`
	`367`	`+ return Divide.of(firstColumn, secondColumn, subsequentColumns);`
`368`	`368`	`}`
`369`	`369`
`370`	`370`	`static <T extends Number> Multiply<T> multiply(BindableColumn<T> firstColumn, BasicColumn secondColumn,`
`371`	`371`	`BasicColumn... subsequentColumns) {`
`372`		`- return Multiply.of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));`
	`372`	`+ return Multiply.of(firstColumn, secondColumn, subsequentColumns);`
`373`	`373`	`}`
`374`	`374`
`375`	`375`	`static <T extends Number> Subtract<T> subtract(BindableColumn<T> firstColumn, BasicColumn secondColumn,`
`376`	`376`	`BasicColumn... subsequentColumns) {`
`377`		`- return Subtract.of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));`
	`377`	`+ return Subtract.of(firstColumn, secondColumn, subsequentColumns);`
`378`	`378`	`}`
`379`	`379`
`380`	`380`	`static <T> Concatenate<T> concatenate(BindableColumn<T> firstColumn, BasicColumn secondColumn,`
`@@ -555,7 +555,7 @@ static <T> IsLessThanOrEqualToWhenPresent<T> isLessThanOrEqualToWhenPresent(Supp`
`555`	`555`
`556`	`556`	`@SafeVarargs`
`557`	`557`	`static <T> IsIn<T> isIn(T...values) {`
`558`		`- return isIn(Arrays.asList(values));`
	`558`	`+ return IsIn.of(values);`
`559`	`559`	`}`
`560`	`560`
`561`	`561`	`static <T> IsIn<T> isIn(Collection<T> values) {`
`@@ -568,7 +568,7 @@ static <T> IsInWithSubselect<T> isIn(Buildable<SelectModel> selectModelBuilder)`
`568`	`568`
`569`	`569`	`@SafeVarargs`
`570`	`570`	`static <T> IsInWhenPresent<T> isInWhenPresent(T...values) {`
`571`		`- return isInWhenPresent(Arrays.asList(values));`
	`571`	`+ return IsInWhenPresent.of(values);`
`572`	`572`	`}`
`573`	`573`
`574`	`574`	`static <T> IsInWhenPresent<T> isInWhenPresent(Collection<T> values) {`
`@@ -577,7 +577,7 @@ static <T> IsInWhenPresent<T> isInWhenPresent(Collection<T> values) {`
`577`	`577`
`578`	`578`	`@SafeVarargs`
`579`	`579`	`static <T> IsNotIn<T> isNotIn(T...values) {`
`580`		`- return isNotIn(Arrays.asList(values));`
	`580`	`+ return IsNotIn.of(values);`
`581`	`581`	`}`
`582`	`582`
`583`	`583`	`static <T> IsNotIn<T> isNotIn(Collection<T> values) {`
`@@ -590,7 +590,7 @@ static <T> IsNotInWithSubselect<T> isNotIn(Buildable<SelectModel> selectModelBui`
`590`	`590`
`591`	`591`	`@SafeVarargs`
`592`	`592`	`static <T> IsNotInWhenPresent<T> isNotInWhenPresent(T...values) {`
`593`		`- return isNotInWhenPresent(Arrays.asList(values));`
	`593`	`+ return IsNotInWhenPresent.of(values);`
`594`	`594`	`}`
`595`	`595`
`596`	`596`	`static <T> IsNotInWhenPresent<T> isNotInWhenPresent(Collection<T> values) {`
`@@ -705,31 +705,31 @@ static IsNotLikeCaseInsensitiveWhenPresent isNotLikeCaseInsensitiveWhenPresent(S`
`705`	`705`	`}`
`706`	`706`
`707`	`707`	`static IsInCaseInsensitive isInCaseInsensitive(String...values) {`
`708`		`- return isInCaseInsensitive(Arrays.asList(values));`
	`708`	`+ return IsInCaseInsensitive.of(values);`
`709`	`709`	`}`
`710`	`710`
`711`	`711`	`static IsInCaseInsensitive isInCaseInsensitive(Collection<String> values) {`
`712`	`712`	`return IsInCaseInsensitive.of(values);`
`713`	`713`	`}`
`714`	`714`
`715`	`715`	`static IsInCaseInsensitiveWhenPresent isInCaseInsensitiveWhenPresent(String...values) {`
`716`		`- return isInCaseInsensitiveWhenPresent(Arrays.asList(values));`
	`716`	`+ return IsInCaseInsensitiveWhenPresent.of(values);`
`717`	`717`	`}`
`718`	`718`
`719`	`719`	`static IsInCaseInsensitiveWhenPresent isInCaseInsensitiveWhenPresent(Collection<String> values) {`
`720`	`720`	`return IsInCaseInsensitiveWhenPresent.of(values);`
`721`	`721`	`}`
`722`	`722`
`723`	`723`	`static IsNotInCaseInsensitive isNotInCaseInsensitive(String...values) {`
`724`		`- return isNotInCaseInsensitive(Arrays.asList(values));`
	`724`	`+ return IsNotInCaseInsensitive.of(values);`
`725`	`725`	`}`
`726`	`726`
`727`	`727`	`static IsNotInCaseInsensitive isNotInCaseInsensitive(Collection<String> values) {`
`728`	`728`	`return IsNotInCaseInsensitive.of(values);`
`729`	`729`	`}`
`730`	`730`
`731`	`731`	`static IsNotInCaseInsensitiveWhenPresent isNotInCaseInsensitiveWhenPresent(String...values) {`
`732`		`- return isNotInCaseInsensitiveWhenPresent(Arrays.asList(values));`
	`732`	`+ return IsNotInCaseInsensitiveWhenPresent.of(values);`
`733`	`733`	`}`
`734`	`734`
`735`	`735`	`static IsNotInCaseInsensitiveWhenPresent isNotInCaseInsensitiveWhenPresent(Collection<String> values) {`
Original file line number	Diff line number	Diff line change
`@@ -59,6 +59,11 @@ public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) {`
`59`	`59`
`60`	`60`	`public static <T> OperatorFunction<T> of(String operator, BindableColumn<T> firstColumn, BasicColumn secondColumn,`
`61`	`61`	`BasicColumn... subsequentColumns) {`
`62`		`- return new OperatorFunction<>(operator, firstColumn, secondColumn, Arrays.asList(subsequentColumns));`
	`62`	`+ return of(operator, firstColumn, secondColumn, Arrays.asList(subsequentColumns));`
	`63`	`+ }`
	`64`	`+`
	`65`	`+ public static <T> OperatorFunction<T> of(String operator, BindableColumn<T> firstColumn, BasicColumn secondColumn,`
	`66`	`+ List<BasicColumn> subsequentColumns) {`
	`67`	`+ return new OperatorFunction<>(operator, firstColumn, secondColumn, subsequentColumns);`
`63`	`68`	`}`
`64`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@`
`15`	`15`	`*/`
`16`	`16`	`package org.mybatis.dynamic.sql.select.function;`
`17`	`17`
	`18`	`+import java.util.Arrays;`
`18`	`19`	`import java.util.List;`
`19`	`20`
`20`	`21`	`import org.mybatis.dynamic.sql.BasicColumn;`
`@@ -33,7 +34,12 @@ protected Subtract<T> copy() {`
`33`	`34`	`}`
`34`	`35`
`35`	`36`	`public static <T extends Number> Subtract<T> of(BindableColumn<T> firstColumn, BasicColumn secondColumn,`
`36`		`- List<BasicColumn> subsequentColumns) {`
	`37`	`+ BasicColumn... subsequentColumns) {`
	`38`	`+ return of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));`
	`39`	`+ }`
	`40`	`+`
	`41`	`+ public static <T extends Number> Subtract<T> of(BindableColumn<T> firstColumn, BasicColumn secondColumn,`
	`42`	`+ List<BasicColumn> subsequentColumns) {`
`37`	`43`	`return new Subtract<>(firstColumn, secondColumn, subsequentColumns);`
`38`	`44`	`}`
`39`	`45`	`}`