Make constants more flexible so they can appear

With the refactoring of the functions, we now allow constants to appear
anywhere in a column list. Previously they could not appear as the first
column.

Author: jeffgbutler

CHANGELOG.md

@@ -6,6 +6,12 @@ This log will detail notable changes to MyBatis Dynamic SQL. Full details are av
 
 GitHub milestone: [https://github.com/mybatis/mybatis-dynamic-sql/issues?q=milestone%3A1.1.5+](https://github.com/mybatis/mybatis-dynamic-sql/issues?q=milestone%3A1.1.5+)
 
+### General Announcements
+
+This release includes a significant refactoring of the classes in the "org.mybatis.dynamic.sql.select.function" package. The new classes are more consistent and flexible and should be compatible with existing code at the source level (meaning that code should be recompiled for the new version of the library).
+
+If you have written your own set of functions to extend the library, you will notice that the base classes 'AbstractFunction" and "AbstractMultipleColumnArithmeticFunction" are now deprecated. Their replacement classes are "AbstractUniTypeFunction" and "OperatorFunction" respectively.
+
 ### Added
 
 - Added a general insert statement that does not require a separate record class to hold values for the insert. ([#201](https://github.com/mybatis/mybatis-dynamic-sql/issues/201))

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

@@ -38,9 +38,13 @@ public interface BindableColumn<T> extends BasicColumn {
     @Override
     BindableColumn<T> as(String alias);
 
-    Optional<JDBCType> jdbcType();
+    default Optional<JDBCType> jdbcType() {
+        return Optional.empty();
+    }
 
-    Optional<String> typeHandler();
+    default Optional<String> typeHandler() {
+        return Optional.empty();
+    }
 
     default Optional<RenderingStrategy> renderingStrategy() {
         return Optional.empty();

src/main/java/org/mybatis/dynamic/sql/Constant.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,7 +20,7 @@
 
 import org.mybatis.dynamic.sql.render.TableAliasCalculator;
 
-public class Constant implements BasicColumn {
+public class Constant<T> implements BindableColumn<T> {
 
     private String alias;
     private String value;
@@ -40,13 +40,13 @@ public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) {
     }
 
     @Override
-    public Constant as(String alias) {
-        Constant copy = new Constant(value);
+    public Constant<T> as(String alias) {
+        Constant<T> copy = new Constant<>(value);
         copy.alias = alias;
         return copy;
     }
 
-    public static Constant of(String value) {
-        return new Constant(value);
+    public static <T> Constant<T> of(String value) {
+        return new Constant<>(value);
     }
 }

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

@@ -258,7 +258,7 @@ static Sum sum(BasicColumn column) {
     }
 
     // constants
-    static Constant constant(String constant) {
+    static <T> Constant<T> constant(String constant) {
         return Constant.of(constant);
     }
 
@@ -292,7 +292,7 @@ static <T> Concatenate<T> concatenate(BindableColumn<T> firstColumn, BasicColumn
         return Concatenate.concatenate(firstColumn, secondColumn, subsequentColumns);
     }
 
-    static <T> OperatorFunction<T> operatorFunction(String operator, BindableColumn<T> firstColumn, BasicColumn secondColumn,
+    static <T> OperatorFunction<T> applyOperator(String operator, BindableColumn<T> firstColumn, BasicColumn secondColumn,
             BasicColumn... subsequentColumns) {
         return OperatorFunction.of(operator, firstColumn, secondColumn, subsequentColumns);
     }

src/main/java/org/mybatis/dynamic/sql/StringConstant.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,7 +20,7 @@
 
 import org.mybatis.dynamic.sql.render.TableAliasCalculator;
 
-public class StringConstant implements BasicColumn {
+public class StringConstant implements BindableColumn<String> {
 
     private String alias;
     private String value;

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

@@ -767,6 +767,36 @@ void testStringConstant() {
         }
     }
 
+    @Test
+    void testDeprecatedAdd() {
+        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
+            AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
+            
+            SelectStatementProvider selectStatement = select(id, animalName, DeprecatedAdd.of(bodyWeight, brainWeight).as("calculated_weight"))
+                    .from(animalData, "a")
+                    .where(DeprecatedAdd.of(bodyWeight, brainWeight), isGreaterThan(10000.0))
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+
+            String expected = "select a.id, a.animal_name, (a.body_weight + a.brain_weight) as calculated_weight "
+                    + "from AnimalData a "
+                    + "where (a.body_weight + a.brain_weight) > #{parameters.p1,jdbcType=DOUBLE}";
+            
+            List<Map<String, Object>> animals = mapper.generalSelect(selectStatement);
+            
+            assertAll(
+                    () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
+                    () -> assertThat(animals).hasSize(3),
+                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "African elephant"),
+                    () -> assertThat(animals.get(0)).containsEntry("CALCULATED_WEIGHT", 12366.0),
+                    () -> assertThat(animals.get(1)).containsEntry("ANIMAL_NAME", "Dipliodocus"),
+                    () -> assertThat(animals.get(1)).containsEntry("CALCULATED_WEIGHT", 11750.0),
+                    () -> assertThat(animals.get(2)).containsEntry("ANIMAL_NAME", "Brachiosaurus"),
+                    () -> assertThat(animals.get(2)).containsEntry("CALCULATED_WEIGHT", 87154.5)
+            );
+        }
+    }
+    
     @Test
     void testAdd() {
         try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
@@ -827,6 +857,36 @@ void testAddConstant() {
         }
     }
 
+    @Test
+    void testAddConstantWithConstantFirst() {
+        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
+            AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
+            
+            SelectStatementProvider selectStatement = select(id, animalName, add(constant("22"), bodyWeight, constant("33")).as("calculated_weight"))
+                    .from(animalData, "a")
+                    .where(add(bodyWeight, brainWeight), isGreaterThan(10000.0))
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+
+            String expected = "select a.id, a.animal_name, (22 + a.body_weight + 33) as calculated_weight "
+                    + "from AnimalData a "
+                    + "where (a.body_weight + a.brain_weight) > #{parameters.p1,jdbcType=DOUBLE}";
+            
+            List<Map<String, Object>> animals = mapper.generalSelect(selectStatement);
+
+            assertAll(
+                    () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
+                    () -> assertThat(animals).hasSize(3),
+                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "African elephant"),
+                    () -> assertThat(animals.get(0)).containsEntry("CALCULATED_WEIGHT", 5767.0),
+                    () -> assertThat(animals.get(1)).containsEntry("ANIMAL_NAME", "Dipliodocus"),
+                    () -> assertThat(animals.get(1)).containsEntry("CALCULATED_WEIGHT", 105.0),
+                    () -> assertThat(animals.get(2)).containsEntry("ANIMAL_NAME", "Brachiosaurus"),
+                    () -> assertThat(animals.get(2)).containsEntry("CALCULATED_WEIGHT", 209.5)
+            );
+        }
+    }
+    
     @Test
     void testConcatenate() {
         try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
@@ -854,6 +914,33 @@ void testConcatenate() {
         }
     }
 
+    @Test
+    void testConcatenateConstantFirst() {
+        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
+            AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
+            
+            SelectStatementProvider selectStatement = select(id, concatenate(stringConstant("Name: "), animalName).as("display_name"))
+                    .from(animalData, "a")
+                    .where(add(bodyWeight, brainWeight), isGreaterThan(10000.0))
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+
+            String expected = "select a.id, ('Name: ' || a.animal_name) as display_name "
+                    + "from AnimalData a "
+                    + "where (a.body_weight + a.brain_weight) > #{parameters.p1,jdbcType=DOUBLE}";
+            
+            List<Map<String, Object>> animals = mapper.generalSelect(selectStatement);
+            
+            assertAll(
+                    () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
+                    () -> assertThat(animals).hasSize(3),
+                    () -> assertThat(animals.get(0)).containsEntry("DISPLAY_NAME", "Name: African elephant"),
+                    () -> assertThat(animals.get(1)).containsEntry("DISPLAY_NAME", "Name: Dipliodocus"),
+                    () -> assertThat(animals.get(2)).containsEntry("DISPLAY_NAME", "Name: Brachiosaurus")
+            );
+        }
+    }
+    
     @Test
     void testDivide() {
         try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
@@ -1034,6 +1121,36 @@ void testSubtractConstant() {
         }
     }
 
+    @Test
+    void testGeneralOperator() {
+        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
+            AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
+            
+            SelectStatementProvider selectStatement = select(id, animalName, applyOperator("-", bodyWeight, brainWeight).as("calculated_weight"))
+                    .from(animalData, "a")
+                    .where(add(bodyWeight, brainWeight), isGreaterThan(10000.0))
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+
+            String expected = "select a.id, a.animal_name, (a.body_weight - a.brain_weight) as calculated_weight "
+                    + "from AnimalData a "
+                    + "where (a.body_weight + a.brain_weight) > #{parameters.p1,jdbcType=DOUBLE}";
+            
+            List<Map<String, Object>> animals = mapper.generalSelect(selectStatement);
+
+            assertAll(
+                    () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
+                    () -> assertThat(animals).hasSize(3),
+                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "African elephant"),
+                    () -> assertThat(animals.get(0)).containsEntry("CALCULATED_WEIGHT", -942.0),
+                    () -> assertThat(animals.get(1)).containsEntry("ANIMAL_NAME", "Dipliodocus"),
+                    () -> assertThat(animals.get(1)).containsEntry("CALCULATED_WEIGHT", -11650.0),
+                    () -> assertThat(animals.get(2)).containsEntry("ANIMAL_NAME", "Brachiosaurus"),
+                    () -> assertThat(animals.get(2)).containsEntry("CALCULATED_WEIGHT", -86845.5)
+            );
+        }
+    }
+    
     @Test
     void testComplexExpression() {
         try (SqlSession sqlSession = sqlSessionFactory.openSession()) {

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

@@ -0,0 +1,46 @@
+/**
+ *    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 examples.animal.data;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.mybatis.dynamic.sql.BasicColumn;
+import org.mybatis.dynamic.sql.BindableColumn;
+import org.mybatis.dynamic.sql.select.function.AbstractMultipleColumnArithmeticFunction;
+
+public class DeprecatedAdd<T extends Number> extends AbstractMultipleColumnArithmeticFunction<T, DeprecatedAdd<T>> {
+
+    private DeprecatedAdd(BindableColumn<T> firstColumn, BasicColumn secondColumn,
+            List<BasicColumn> subsequentColumns) {
+        super(firstColumn, secondColumn, subsequentColumns);
+    }
+
+    @Override
+    protected DeprecatedAdd<T> copy() {
+        return new DeprecatedAdd<>(column, secondColumn, subsequentColumns);
+    }
+
+    @Override
+    protected String operator() {
+        return "+"; //$NON-NLS-1$
+    }
+
+    public static <T extends Number> DeprecatedAdd<T> of(BindableColumn<T> firstColumn, BasicColumn secondColumn,
+            BasicColumn... subsequentColumns) {
+        return new DeprecatedAdd<>(firstColumn, secondColumn, Arrays.asList(subsequentColumns));
+    }
+}

src/test/java/org/mybatis/dynamic/sql/BindableColumnTest.java

@@ -0,0 +1,31 @@
+/**
+ *    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;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class BindableColumnTest {
+    
+    @Test
+    void testDefaultFunctions() {
+        StringConstant constant = StringConstant.of("Fred");
+        
+        assertThat(constant.jdbcType()).isEmpty();
+        assertThat(constant.typeHandler()).isEmpty();
+    }
+}