New Hierarchy for Functions

Author: jeffgbutler

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

@@ -40,9 +40,11 @@
 import org.mybatis.dynamic.sql.select.aggregate.Min;
 import org.mybatis.dynamic.sql.select.aggregate.Sum;
 import org.mybatis.dynamic.sql.select.function.Add;
+import org.mybatis.dynamic.sql.select.function.Concatenate;
 import org.mybatis.dynamic.sql.select.function.Divide;
 import org.mybatis.dynamic.sql.select.function.Lower;
 import org.mybatis.dynamic.sql.select.function.Multiply;
+import org.mybatis.dynamic.sql.select.function.OperatorFunction;
 import org.mybatis.dynamic.sql.select.function.Substring;
 import org.mybatis.dynamic.sql.select.function.Subtract;
 import org.mybatis.dynamic.sql.select.function.Upper;
@@ -285,6 +287,16 @@ static <T extends Number> Subtract<T> subtract(BindableColumn<T> firstColumn, Ba
         return Subtract.of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));
     }
 
+    static <T> Concatenate<T> concatenate(BindableColumn<T> firstColumn, BasicColumn secondColumn,
+            BasicColumn... subsequentColumns) {
+        return Concatenate.concatenate(firstColumn, secondColumn, subsequentColumns);
+    }
+    
+    static <T> OperatorFunction<T> operatorFunction(String operator, BindableColumn<T> firstColumn, BasicColumn secondColumn,
+            BasicColumn... subsequentColumns) {
+        return OperatorFunction.of(operator, firstColumn, secondColumn, subsequentColumns);
+    }
+    
     static Lower lower(BindableColumn<String> column) {
         return Lower.of(column);
     }

src/main/java/org/mybatis/dynamic/sql/select/function/AbstractFunction.java

@@ -16,17 +16,38 @@
 package org.mybatis.dynamic.sql.select.function;
 
 import java.sql.JDBCType;
+import java.util.Objects;
 import java.util.Optional;
 
 import org.mybatis.dynamic.sql.BindableColumn;
 
-public abstract class AbstractFunction<T, U extends AbstractFunction<T, U>>
-        extends AbstractTypeConvertingFunction<T, T, U> {
+/**
+ * @deprecated in favor of {@link AbstractUniTypeFunction}
+ * 
+ * @author Jeff Butler
+ */
+@Deprecated
+public abstract class AbstractFunction<T, U extends AbstractFunction<T, U>> implements BindableColumn<T> {
+    
+    protected BindableColumn<T> column;
+    protected String alias;
 
     protected AbstractFunction(BindableColumn<T> column) {
-        super(column);
+        this.column = Objects.requireNonNull(column);
     }
 
+    @Override
+    public Optional<String> alias() {
+        return Optional.ofNullable(alias);
+    }
+
+    @Override
+    public U as(String alias) {
+        U newThing = copy();
+        newThing.alias = alias;
+        return newThing;
+    }
+
     @Override
     public Optional<JDBCType> jdbcType() {
         return column.jdbcType();
@@ -36,4 +57,6 @@ public Optional<JDBCType> jdbcType() {
     public Optional<String> typeHandler() {
         return column.typeHandler();
     }
+    
+    protected abstract U copy();
 }

src/main/java/org/mybatis/dynamic/sql/select/function/AbstractMultipleColumnArithmeticFunction.java

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2018 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.
@@ -26,13 +26,19 @@
 import org.mybatis.dynamic.sql.BindableColumn;
 import org.mybatis.dynamic.sql.render.TableAliasCalculator;
 
+/**
+ * @deprecated in favor of {@link OperatorFunction}.
+ * 
+ * @author Jeff Butler
+ */
+@Deprecated
 public abstract class AbstractMultipleColumnArithmeticFunction<T extends Number,
         U extends AbstractMultipleColumnArithmeticFunction<T, U>>
-        extends AbstractFunction<T, AbstractMultipleColumnArithmeticFunction<T,U>> {
-    
+        extends AbstractFunction<T, AbstractMultipleColumnArithmeticFunction<T, U>> {
+
     protected BasicColumn secondColumn;
     protected List<BasicColumn> subsequentColumns = new ArrayList<>();
-    
+
     protected AbstractMultipleColumnArithmeticFunction(BindableColumn<T> firstColumn, BasicColumn secondColumn,
             List<BasicColumn> subsequentColumns) {
         super(firstColumn);
@@ -42,13 +48,13 @@ protected AbstractMultipleColumnArithmeticFunction(BindableColumn<T> firstColumn
 
     @Override
     public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) {
-        // note - the cast below is added for a type inference bug in the Java9 compiler.
+        // note - the cast below is added for a type inference bug in the Java9
+        // compiler.
         return Stream.of(Stream.of((BasicColumn) column), Stream.of(secondColumn), subsequentColumns.stream())
-                .flatMap(Function.identity())
-                .map(column -> column.renderWithTableAlias(tableAliasCalculator))
+                .flatMap(Function.identity()).map(column -> column.renderWithTableAlias(tableAliasCalculator))
                 .collect(Collectors.joining(padOperator(), "(", ")")); //$NON-NLS-1$ //$NON-NLS-2$
     }
-    
+
     private String padOperator() {
         return " " + operator() + " "; //$NON-NLS-1$ //$NON-NLS-2$
     }

src/main/java/org/mybatis/dynamic/sql/select/function/AbstractUniTypeFunction.java

@@ -0,0 +1,47 @@
+/**
+ *    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.
+ *    You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package org.mybatis.dynamic.sql.select.function;
+
+import java.sql.JDBCType;
+import java.util.Optional;
+
+import org.mybatis.dynamic.sql.BindableColumn;
+
+/**
+ * Represents a function that does not change the underlying data type.
+ * 
+ * @author Jeff Butler
+ *
+ * @param <T> The type of the underlying column 
+ * @param <U> the specific subtype that implements the function
+ */
+public abstract class AbstractUniTypeFunction<T, U extends AbstractUniTypeFunction<T, U>>
+        extends AbstractTypeConvertingFunction<T, T, U> {
+
+    protected AbstractUniTypeFunction(BindableColumn<T> column) {
+        super(column);
+    }
+    
+    @Override
+    public Optional<JDBCType> jdbcType() {
+        return column.jdbcType();
+    }
+
+    @Override
+    public Optional<String> typeHandler() {
+        return column.typeHandler();
+    }
+}

src/main/java/org/mybatis/dynamic/sql/select/function/Add.java

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2018 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.
@@ -20,23 +20,18 @@
 import org.mybatis.dynamic.sql.BasicColumn;
 import org.mybatis.dynamic.sql.BindableColumn;
 
-public class Add<T extends Number> extends AbstractMultipleColumnArithmeticFunction<T, Add<T>> {
+public class Add<T extends Number> extends OperatorFunction<T> {
 
     private Add(BindableColumn<T> firstColumn, BasicColumn secondColumn,
             List<BasicColumn> subsequentColumns) {
-        super(firstColumn, secondColumn, subsequentColumns);
+        super("+", firstColumn, secondColumn, subsequentColumns); //$NON-NLS-1$
     }
 
     @Override
     protected Add<T> copy() {
         return new Add<>(column, secondColumn, subsequentColumns);
     }
 
-    @Override
-    protected String operator() {
-        return "+"; //$NON-NLS-1$
-    }
-
     public static <T extends Number> Add<T> of(BindableColumn<T> firstColumn, BasicColumn secondColumn,
             List<BasicColumn> subsequentColumns) {
         return new Add<>(firstColumn, secondColumn, subsequentColumns);

src/main/java/org/mybatis/dynamic/sql/select/function/Concatenate.java

@@ -0,0 +1,40 @@
+/**
+ *    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.
+ *    You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package org.mybatis.dynamic.sql.select.function;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.mybatis.dynamic.sql.BasicColumn;
+import org.mybatis.dynamic.sql.BindableColumn;
+
+public class Concatenate<T> extends OperatorFunction<T> {
+
+    protected Concatenate(BindableColumn<T> firstColumn, BasicColumn secondColumn,
+            List<BasicColumn> subsequentColumns) {
+        super("||", firstColumn, secondColumn, subsequentColumns); //$NON-NLS-1$
+    }
+
+    @Override
+    protected Concatenate<T> copy() {
+        return new Concatenate<>(column, secondColumn, subsequentColumns);
+    }
+
+    public static <T> Concatenate<T> concatenate(BindableColumn<T> firstColumn, BasicColumn secondColumn,
+            BasicColumn... subsequentColumns) {
+        return new Concatenate<>(firstColumn, secondColumn, Arrays.asList(subsequentColumns));
+    }
+}

src/main/java/org/mybatis/dynamic/sql/select/function/Divide.java

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2018 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.
@@ -20,23 +20,18 @@
 import org.mybatis.dynamic.sql.BasicColumn;
 import org.mybatis.dynamic.sql.BindableColumn;
 
-public class Divide<T extends Number> extends AbstractMultipleColumnArithmeticFunction<T, Divide<T>> {
+public class Divide<T extends Number> extends OperatorFunction<T> {
 
     private Divide(BindableColumn<T> firstColumn, BasicColumn secondColumn,
             List<BasicColumn> subsequentColumns) {
-        super(firstColumn, secondColumn, subsequentColumns);
+        super("/", firstColumn, secondColumn, subsequentColumns); //$NON-NLS-1$
     }
 
     @Override
     protected Divide<T> copy() {
         return new Divide<>(column, secondColumn, subsequentColumns);
     }
 
-    @Override
-    protected String operator() {
-        return "/"; //$NON-NLS-1$
-    }
-
     public static <T extends Number> Divide<T> of(BindableColumn<T> firstColumn, BasicColumn secondColumn,
             List<BasicColumn> subsequentColumns) {
         return new Divide<>(firstColumn, secondColumn, subsequentColumns);

src/main/java/org/mybatis/dynamic/sql/select/function/Lower.java

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2018 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.
@@ -18,7 +18,7 @@
 import org.mybatis.dynamic.sql.BindableColumn;
 import org.mybatis.dynamic.sql.render.TableAliasCalculator;
 
-public class Lower extends AbstractFunction<String, Lower> {
+public class Lower extends AbstractUniTypeFunction<String, Lower> {
 
     private Lower(BindableColumn<String> column) {
         super(column);

src/main/java/org/mybatis/dynamic/sql/select/function/Multiply.java

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2018 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.
@@ -20,23 +20,18 @@
 import org.mybatis.dynamic.sql.BasicColumn;
 import org.mybatis.dynamic.sql.BindableColumn;
 
-public class Multiply<T extends Number> extends AbstractMultipleColumnArithmeticFunction<T, Multiply<T>> {
+public class Multiply<T extends Number> extends OperatorFunction<T> {
 
     private Multiply(BindableColumn<T> firstColumn, BasicColumn secondColumn,
             List<BasicColumn> subsequentColumns) {
-        super(firstColumn, secondColumn, subsequentColumns);
+        super("*", firstColumn, secondColumn, subsequentColumns); //$NON-NLS-1$
     }
 
     @Override
     protected Multiply<T> copy() {
         return new Multiply<>(column, secondColumn, subsequentColumns);
     }
 
-    @Override
-    protected String operator() {
-        return "*"; //$NON-NLS-1$
-    }
-
     public static <T extends Number> Multiply<T> of(BindableColumn<T> firstColumn, BasicColumn secondColumn,
             List<BasicColumn> subsequentColumns) {
         return new Multiply<>(firstColumn, secondColumn, subsequentColumns);

src/main/java/org/mybatis/dynamic/sql/select/function/OperatorFunction.java

@@ -0,0 +1,64 @@
+/**
+ *    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.
+ *    You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package org.mybatis.dynamic.sql.select.function;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.mybatis.dynamic.sql.BasicColumn;
+import org.mybatis.dynamic.sql.BindableColumn;
+import org.mybatis.dynamic.sql.render.TableAliasCalculator;
+
+public class OperatorFunction<T> extends AbstractUniTypeFunction<T, OperatorFunction<T>> {
+    
+    protected BasicColumn secondColumn;
+    protected List<BasicColumn> subsequentColumns = new ArrayList<>();
+    private String operator;
+    
+    protected OperatorFunction(String operator, BindableColumn<T> firstColumn, BasicColumn secondColumn,
+            List<BasicColumn> subsequentColumns) {
+        super(firstColumn);
+        this.secondColumn = Objects.requireNonNull(secondColumn);
+        this.subsequentColumns.addAll(subsequentColumns);
+        this.operator = Objects.requireNonNull(operator);
+    }
+
+    @Override
+    protected OperatorFunction<T> copy() {
+        return new OperatorFunction<>(operator, column, secondColumn, subsequentColumns);
+    }
+
+    @Override
+    public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) {
+        String paddedOperator = " " + operator + " "; //$NON-NLS-1$ //$NON-NLS-2$
+
+        // note - the cast below is added for a type inference bug in the Java9 compiler.
+        return Stream.of(Stream.of((BasicColumn) column), Stream.of(secondColumn), subsequentColumns.stream())
+                .flatMap(Function.identity())
+                .map(column -> column.renderWithTableAlias(tableAliasCalculator))
+                .collect(Collectors.joining(paddedOperator, "(", ")")); //$NON-NLS-1$ //$NON-NLS-2$
+    }
+
+    public static <T> OperatorFunction<T> of(String operator, BindableColumn<T> firstColumn, BasicColumn secondColumn,
+            BasicColumn... subsequentColumns) {
+        return new OperatorFunction<>(operator, firstColumn, secondColumn, Arrays.asList(subsequentColumns));
+    }
+}