Merge pull request #266 from jeffgbutler/immutable-functions

jeffgbutler · web-flow · commit 7f5635f98536 · 2020-09-29T13:37:16.000-04:00
Refactoring - remove some useless abstractions, and add consistency
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,12 +23,14 @@
  * 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<T extends AbstractCount<T>> implements BindableColumn<Long> {
+public abstract class AbstractCount implements BindableColumn<Long> {
     private final String alias;
 
+    protected AbstractCount() {
+        this(null);
+    }
+
     protected AbstractCount(String alias) {
         this.alias = alias;
     }
@@ -37,11 +39,4 @@ protected AbstractCount(String alias) {
     public Optional<String> alias() {
         return Optional.ofNullable(alias);
     }
-
-    @Override
-    public T as(String alias) {
-        return copyWithAlias(alias);
-    }
-
-    protected abstract T copyWithAlias(String alias);
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Count.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Count.java
@@ -20,10 +20,14 @@
 import org.mybatis.dynamic.sql.BasicColumn;
 import org.mybatis.dynamic.sql.render.TableAliasCalculator;
 
-public class Count extends AbstractCount<Count> {
+public class Count extends AbstractCount {
 
     private final BasicColumn column;
 
+    private Count(BasicColumn column) {
+        this.column = Objects.requireNonNull(column);
+    }
+
     private Count(BasicColumn column, String alias) {
         super(alias);
         this.column = Objects.requireNonNull(column);
@@ -35,11 +39,11 @@ public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) {
     }
 
     @Override
-    protected Count copyWithAlias(String alias) {
+    public Count as(String alias) {
         return new Count(column, alias);
     }
 
     public static Count of(BasicColumn column) {
-        return new Count(column, null);
+        return new Count(column);
     }
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountAll.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountAll.java
@@ -17,10 +17,10 @@
 
 import org.mybatis.dynamic.sql.render.TableAliasCalculator;
 
-public class CountAll extends AbstractCount<CountAll> {
+public class CountAll extends AbstractCount {
 
     public CountAll() {
-        super(null);
+        super();
     }
 
     private CountAll(String alias) {
@@ -33,7 +33,7 @@ public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) {
     }
 
     @Override
-    protected CountAll copyWithAlias(String alias) {
+    public CountAll as(String alias) {
         return new CountAll(alias);
     }
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountDistinct.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountDistinct.java
@@ -20,10 +20,14 @@
 import org.mybatis.dynamic.sql.BasicColumn;
 import org.mybatis.dynamic.sql.render.TableAliasCalculator;
 
-public class CountDistinct extends AbstractCount<CountDistinct> {
+public class CountDistinct extends AbstractCount {
 
     private final BasicColumn column;
 
+    private CountDistinct(BasicColumn column) {
+        this.column = Objects.requireNonNull(column);
+    }
+
     private CountDistinct(BasicColumn column, String alias) {
         super(alias);
         this.column = Objects.requireNonNull(column);
@@ -35,11 +39,11 @@ public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) {
     }
 
     @Override
-    public CountDistinct copyWithAlias(String alias) {
+    public CountDistinct as(String alias) {
         return new CountDistinct(column, alias);
     }
 
     public static CountDistinct of(BasicColumn column) {
-        return new CountDistinct(column, null);
+        return new CountDistinct(column);
     }
 }
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
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
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
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
diff --git a/src/test/java/org/mybatis/dynamic/sql/select/SelectStatementTest.java b/src/test/java/org/mybatis/dynamic/sql/select/SelectStatementTest.java

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
`@@ -20,10 +20,14 @@`
`20`	`20`	`import org.mybatis.dynamic.sql.BasicColumn;`
`21`	`21`	`import org.mybatis.dynamic.sql.render.TableAliasCalculator;`
`22`	`22`
`23`		`-public class Count extends AbstractCount<Count> {`
	`23`	`+public class Count extends AbstractCount {`
`24`	`24`
`25`	`25`	`private final BasicColumn column;`
`26`	`26`
	`27`	`+ private Count(BasicColumn column) {`
	`28`	`+ this.column = Objects.requireNonNull(column);`
	`29`	`+ }`
	`30`	`+`
`27`	`31`	`private Count(BasicColumn column, String alias) {`
`28`	`32`	`super(alias);`
`29`	`33`	`this.column = Objects.requireNonNull(column);`
`@@ -35,11 +39,11 @@ public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) {`
`35`	`39`	`}`
`36`	`40`
`37`	`41`	`@Override`
`38`		`- protected Count copyWithAlias(String alias) {`
	`42`	`+ public Count as(String alias) {`
`39`	`43`	`return new Count(column, alias);`
`40`	`44`	`}`
`41`	`45`
`42`	`46`	`public static Count of(BasicColumn column) {`
`43`		`- return new Count(column, null);`
	`47`	`+ return new Count(column);`
`44`	`48`	`}`
`45`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,10 +17,10 @@`
`17`	`17`
`18`	`18`	`import org.mybatis.dynamic.sql.render.TableAliasCalculator;`
`19`	`19`
`20`		`-public class CountAll extends AbstractCount<CountAll> {`
	`20`	`+public class CountAll extends AbstractCount {`
`21`	`21`
`22`	`22`	`public CountAll() {`
`23`		`- super(null);`
	`23`	`+ super();`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`private CountAll(String alias) {`
`@@ -33,7 +33,7 @@ public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) {`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`@Override`
`36`		`- protected CountAll copyWithAlias(String alias) {`
	`36`	`+ public CountAll as(String alias) {`
`37`	`37`	`return new CountAll(alias);`
`38`	`38`	`}`
`39`	`39`	`}`
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`	`}`