Merge pull request #573 from jeffgbutler/concat-function

Add concat(x, y, z) Function for Wider Database Compatibility

Author: jeffgbutler

CHANGELOG.md

@@ -51,8 +51,8 @@ The pull request for this change is ([#550](https://github.com/mybatis/mybatis-d
    algorithm. Also deprecated the constructors on SqlTable that accept Suppliers for table name - this creates an
    effectively mutable object and goes against the principles of immutability that we strive for in the library.
    ([#572](https://github.com/mybatis/mybatis-dynamic-sql/pull/572))
-      
-
+5. Add `SqlBuilder.concat` and the equivalent in Kotlin. This is a concatenate function that works on more databases.
+   ([#573](https://github.com/mybatis/mybatis-dynamic-sql/pull/573))
 
 ## Release 1.4.1 - October 7, 2022
 

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

@@ -42,6 +42,7 @@
 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.Concat;
 import org.mybatis.dynamic.sql.select.function.Concatenate;
 import org.mybatis.dynamic.sql.select.function.Divide;
 import org.mybatis.dynamic.sql.select.function.Lower;
@@ -488,11 +489,34 @@ static <T> Subtract<T> subtract(BindableColumn<T> firstColumn, BasicColumn secon
         return Subtract.of(firstColumn, secondColumn, subsequentColumns);
     }
 
+    /**
+     * Concatenate function that renders as "(x || y || z)". This will not work on some
+     * databases like MySql. In that case, use {@link SqlBuilder#concat(BindableColumn, BasicColumn...)}
+     *
+     * @param firstColumn first column
+     * @param secondColumn second column
+     * @param subsequentColumns subsequent columns
+     * @return a Concatenate instance
+     * @param <T> type of column
+     */
     static <T> Concatenate<T> concatenate(BindableColumn<T> firstColumn, BasicColumn secondColumn,
             BasicColumn... subsequentColumns) {
         return Concatenate.concatenate(firstColumn, secondColumn, subsequentColumns);
     }
 
+    /**
+     * Concatenate function that renders as "concat(x, y, z)". This version works on more databases
+     * than {@link SqlBuilder#concatenate(BindableColumn, BasicColumn, BasicColumn...)}
+     *
+     * @param firstColumn first column
+     * @param subsequentColumns subsequent columns
+     * @return a Concat instance
+     * @param <T> type of column
+     */
+    static <T> Concat<T> concat(BindableColumn<T> firstColumn, BasicColumn... subsequentColumns) {
+        return Concat.concat(firstColumn, subsequentColumns);
+    }
+
     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/select/function/Concat.java

@@ -0,0 +1,54 @@
+/*
+ *    Copyright 2016-2023 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
+ *
+ *       https://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.stream.Collectors;
+
+import org.mybatis.dynamic.sql.BasicColumn;
+import org.mybatis.dynamic.sql.BindableColumn;
+import org.mybatis.dynamic.sql.render.TableAliasCalculator;
+
+public class Concat<T> extends AbstractUniTypeFunction<T, Concat<T>> {
+    private final List<BasicColumn> allColumns = new ArrayList<>();
+
+    protected Concat(BindableColumn<T> firstColumn, List<BasicColumn> subsequentColumns) {
+        super(firstColumn);
+        allColumns.add(firstColumn);
+        this.allColumns.addAll(subsequentColumns);
+    }
+
+    @Override
+    public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) {
+        return allColumns.stream().map(c -> c.renderWithTableAlias(tableAliasCalculator))
+                .collect(Collectors.joining(", ", "concat(", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+    }
+
+    @Override
+    protected Concat<T> copy() {
+        return new Concat<>(column, allColumns.subList(1, allColumns.size()));
+    }
+
+    public static <T> Concat<T> concat(BindableColumn<T> firstColumn, BasicColumn... subsequentColumns) {
+        return new Concat<>(firstColumn, Arrays.asList(subsequentColumns));
+    }
+
+    public static <T> Concat<T> of(BindableColumn<T> firstColumn, List<BasicColumn> subsequentColumns) {
+        return new Concat<>(firstColumn, subsequentColumns);
+    }
+}

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

@@ -50,7 +50,7 @@ protected OperatorFunction<T> copy() {
     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.
+        // note - the cast below is added for type inference issues in some compilers
         return Stream.of(Stream.of((BasicColumn) column), Stream.of(secondColumn), subsequentColumns.stream())
                 .flatMap(Function.identity())
                 .map(column -> column.renderWithTableAlias(tableAliasCalculator))

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/elements/SqlElements.kt

@@ -32,6 +32,7 @@ import org.mybatis.dynamic.sql.select.aggregate.Max
 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.Concat
 import org.mybatis.dynamic.sql.select.function.Concatenate
 import org.mybatis.dynamic.sql.select.function.Divide
 import org.mybatis.dynamic.sql.select.function.Lower
@@ -138,6 +139,11 @@ fun <T> subtract(
     vararg subsequentColumns: BasicColumn
 ): Subtract<T> = Subtract.of(firstColumn, secondColumn, subsequentColumns.asList())
 
+fun <T> concat(
+    firstColumn: BindableColumn<T>,
+    vararg subsequentColumns: BasicColumn
+): Concat<T> = Concat.of(firstColumn, subsequentColumns.asList())
+
 fun <T> concatenate(
     firstColumn: BindableColumn<T>,
     secondColumn: BasicColumn,

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

@@ -1038,6 +1038,33 @@ void testAddConstantWithConstantFirst() {
         }
     }
 
+    @Test
+    void testConcat() {
+        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
+            CommonSelectMapper mapper = sqlSession.getMapper(CommonSelectMapper.class);
+
+            SelectStatementProvider selectStatement = select(id, concat(animalName, stringConstant(" - The Legend")).as("display_name"))
+                    .from(animalData, "a")
+                    .where(add(bodyWeight, brainWeight), isGreaterThan(10000.0))
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+
+            String expected = "select a.id, concat(a.animal_name, ' - The Legend') as display_name "
+                    + "from AnimalData a "
+                    + "where (a.body_weight + a.brain_weight) > #{parameters.p1,jdbcType=DOUBLE}";
+
+            List<Map<String, Object>> animals = mapper.selectManyMappedRows(selectStatement);
+
+            assertAll(
+                    () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
+                    () -> assertThat(animals).hasSize(3),
+                    () -> assertThat(animals.get(0)).containsEntry("DISPLAY_NAME", "African elephant - The Legend"),
+                    () -> assertThat(animals.get(1)).containsEntry("DISPLAY_NAME", "Dipliodocus - The Legend"),
+                    () -> assertThat(animals.get(2)).containsEntry("DISPLAY_NAME", "Brachiosaurus - The Legend")
+            );
+        }
+    }
+
     @Test
     void testConcatenate() {
         try (SqlSession sqlSession = sqlSessionFactory.openSession()) {

src/test/kotlin/examples/kotlin/spring/canonical/KotlinElementsTest.kt

@@ -24,6 +24,7 @@ import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
 import org.mybatis.dynamic.sql.util.kotlin.elements.applyOperator
 import org.mybatis.dynamic.sql.util.kotlin.elements.avg
+import org.mybatis.dynamic.sql.util.kotlin.elements.concat
 import org.mybatis.dynamic.sql.util.kotlin.elements.concatenate
 import org.mybatis.dynamic.sql.util.kotlin.elements.constant
 import org.mybatis.dynamic.sql.util.kotlin.elements.count
@@ -189,6 +190,23 @@ open class KotlinElementsTest {
         assertThat(rows[5]).isEqualTo(4)
     }
 
+    @Test
+    fun testConcat() {
+        val selectStatement = select(concat(firstName, stringConstant(" "), lastName)) {
+            from(person)
+            orderBy(id)
+        }
+
+        assertThat(selectStatement.selectStatement).isEqualTo(
+            "select concat(first_name, ' ', last_name) from Person order by id"
+        )
+
+        val rows = template.selectList(selectStatement, String::class)
+
+        assertThat(rows).hasSize(6)
+        assertThat(rows[5]).isEqualTo("Bamm Bamm Rubble")
+    }
+
     @Test
     fun testConcatenate() {
         val selectStatement = select(concatenate(firstName, stringConstant(" "), lastName)) {