Add methods that allow us to remove use of the Kotlin spread operator

Arrays are always turned into lists eventually, so we can support that at the edges.

Author: jeffgbutler

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

@@ -141,10 +141,18 @@ static FromGatherer<SelectModel> select(BasicColumn...selectList) {
         return SelectDSL.select(selectList);
     }
 
+    static FromGatherer<SelectModel> select(Collection<BasicColumn> selectList) {
+        return SelectDSL.select(selectList);
+    }
+    
     static FromGatherer<SelectModel> selectDistinct(BasicColumn...selectList) {
         return SelectDSL.selectDistinct(selectList);
     }
 
+    static FromGatherer<SelectModel> selectDistinct(Collection<BasicColumn> selectList) {
+        return SelectDSL.selectDistinct(selectList);
+    }
+    
     static UpdateDSL<UpdateModel> update(SqlTable table) {
         return UpdateDSL.update(table);
     }

src/main/java/org/mybatis/dynamic/sql/select/QueryExpressionDSL.java

@@ -15,7 +15,9 @@
  */
 package org.mybatis.dynamic.sql.select;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
 
@@ -45,7 +47,7 @@ public class QueryExpressionDSL<R> extends AbstractQueryExpressionDSL<QueryExpre
     QueryExpressionDSL(FromGatherer<R> fromGatherer) {
         super(fromGatherer.table);
         connector = fromGatherer.connector;
-        selectList = Arrays.asList(fromGatherer.selectList);
+        selectList = fromGatherer.selectList;
         isDistinct = fromGatherer.isDistinct;
         selectDSL = Objects.requireNonNull(fromGatherer.selectDSL);
     }
@@ -155,7 +157,7 @@ protected QueryExpressionDSL<R> getThis() {
 
     public static class FromGatherer<R> {
         private String connector;
-        private BasicColumn[] selectList;
+        private List<BasicColumn> selectList;
         private SelectDSL<R> selectDSL;
         private boolean isDistinct;
         private SqlTable table;
@@ -179,7 +181,7 @@ public QueryExpressionDSL<R> from(SqlTable table, String tableAlias) {
 
         public static class Builder<R> {
             private String connector;
-            private BasicColumn[] selectList;
+            private List<BasicColumn> selectList = new ArrayList<>();
             private SelectDSL<R> selectDSL;
             private boolean isDistinct;
 
@@ -188,8 +190,8 @@ public Builder<R> withConnector(String connector) {
                 return this;
             }
 
-            public Builder<R> withSelectList(BasicColumn[] selectList) {
-                this.selectList = selectList;
+            public Builder<R> withSelectList(Collection<BasicColumn> selectList) {
+                this.selectList.addAll(selectList);
                 return this;
             }
 
@@ -430,6 +432,10 @@ public UnionBuilder(String connector) {
         }
 
         public FromGatherer<R> select(BasicColumn...selectList) {
+            return select(Arrays.asList(selectList));
+        }
+
+        public FromGatherer<R> select(List<BasicColumn> selectList) {
             return new FromGatherer.Builder<R>()
                     .withConnector(connector)
                     .withSelectList(selectList)
@@ -438,6 +444,10 @@ public FromGatherer<R> select(BasicColumn...selectList) {
         }
 
         public FromGatherer<R> selectDistinct(BasicColumn...selectList) {
+            return selectDistinct(Arrays.asList(selectList));
+        }
+
+        public FromGatherer<R> selectDistinct(List<BasicColumn> selectList) {
             return new FromGatherer.Builder<R>()
                     .withConnector(connector)
                     .withSelectList(selectList)

src/main/java/org/mybatis/dynamic/sql/select/SelectDSL.java

@@ -16,6 +16,8 @@
 package org.mybatis.dynamic.sql.select;
 
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
 import java.util.function.Function;
@@ -49,23 +51,41 @@ private SelectDSL(Function<SelectModel, R> adapterFunction) {
     }
 
     public static QueryExpressionDSL.FromGatherer<SelectModel> select(BasicColumn...selectList) {
+        return select(Arrays.asList(selectList));
+    }
+    
+    public static QueryExpressionDSL.FromGatherer<SelectModel> select(Collection<BasicColumn> selectList) {
         return select(Function.identity(), selectList);
     }
 
     public static <R> QueryExpressionDSL.FromGatherer<R> select(Function<SelectModel, R> adapterFunction,
             BasicColumn...selectList) {
+        return select(adapterFunction, Arrays.asList(selectList));
+    }
+    
+    public static <R> QueryExpressionDSL.FromGatherer<R> select(Function<SelectModel, R> adapterFunction,
+            Collection<BasicColumn> selectList) {
         return new FromGatherer.Builder<R>()
                 .withSelectList(selectList)
                 .withSelectDSL(new SelectDSL<>(adapterFunction))
                 .build();
     }
 
     public static QueryExpressionDSL.FromGatherer<SelectModel> selectDistinct(BasicColumn...selectList) {
+        return selectDistinct(Arrays.asList(selectList));
+    }
+    
+    public static QueryExpressionDSL.FromGatherer<SelectModel> selectDistinct(Collection<BasicColumn> selectList) {
         return selectDistinct(Function.identity(), selectList);
     }
 
     public static <R> QueryExpressionDSL.FromGatherer<R> selectDistinct(Function<SelectModel, R> adapterFunction,
             BasicColumn...selectList) {
+        return selectDistinct(adapterFunction, Arrays.asList(selectList));
+    }
+    
+    public static <R> QueryExpressionDSL.FromGatherer<R> selectDistinct(Function<SelectModel, R> adapterFunction,
+            Collection<BasicColumn> selectList) {
         return new FromGatherer.Builder<R>()
                 .withSelectList(selectList)
                 .withSelectDSL(new SelectDSL<>(adapterFunction))

src/main/java/org/mybatis/dynamic/sql/util/mybatis3/MyBatis3Utils.java

@@ -88,6 +88,11 @@ public static <R> List<R> selectDistinct(Function<SelectStatementProvider, List<
         return selectDistinct(mapper, SqlBuilder.selectDistinct(selectList).from(table), completer);
     }
 
+    public static <R> List<R> selectDistinct(Function<SelectStatementProvider, List<R>> mapper,
+            Collection<BasicColumn> selectList, SqlTable table, SelectDSLCompleter completer) {
+        return selectDistinct(mapper, SqlBuilder.selectDistinct(selectList).from(table), completer);
+    }
+
     public static <R> List<R> selectDistinct(Function<SelectStatementProvider, List<R>> mapper,
             QueryExpressionDSL<SelectModel> start, SelectDSLCompleter completer) {
         return mapper.apply(completer.apply(start).build().render(RenderingStrategies.MYBATIS3));
@@ -98,6 +103,11 @@ public static <R> List<R> selectList(Function<SelectStatementProvider, List<R>>
         return selectList(mapper, SqlBuilder.select(selectList).from(table), completer);
     }
 
+    public static <R> List<R> selectList(Function<SelectStatementProvider, List<R>> mapper,
+            Collection<BasicColumn> selectList, SqlTable table, SelectDSLCompleter completer) {
+        return selectList(mapper, SqlBuilder.select(selectList).from(table), completer);
+    }
+
     public static <R> List<R> selectList(Function<SelectStatementProvider, List<R>> mapper,
             QueryExpressionDSL<SelectModel> start, SelectDSLCompleter completer) {
         return mapper.apply(completer.apply(start).build().render(RenderingStrategies.MYBATIS3));
@@ -109,6 +119,12 @@ public static <R> R selectOne(Function<SelectStatementProvider, R> mapper,
         return selectOne(mapper, SqlBuilder.select(selectList).from(table), completer);
     }
 
+    @Nullable
+    public static <R> R selectOne(Function<SelectStatementProvider, R> mapper,
+            Collection<BasicColumn> selectList, SqlTable table, SelectDSLCompleter completer) {
+        return selectOne(mapper, SqlBuilder.select(selectList).from(table), completer);
+    }
+
     @Nullable
     public static <R> R selectOne(Function<SelectStatementProvider, R> mapper,
             QueryExpressionDSL<SelectModel> start,
@@ -117,15 +133,14 @@ public static <R> R selectOne(Function<SelectStatementProvider, R> mapper,
     }
 
     @NotNull
-    public static <R> Optional<R> selectOptional(Function<SelectStatementProvider, Optional<R>> mapper,
-                                            BasicColumn[] selectList, SqlTable table, SelectDSLCompleter completer) {
+    public static <R> Optional<R> selectOptional(Function<SelectStatementProvider, Optional<R>> mapper, 
+            BasicColumn[] selectList, SqlTable table, SelectDSLCompleter completer) {
         return selectOptional(mapper, SqlBuilder.select(selectList).from(table), completer);
     }
 
     @NotNull
-    public static <R> Optional<R> selectOptional(Function<SelectStatementProvider, Optional<R>> mapper,
-                                  QueryExpressionDSL<SelectModel> start,
-                                  SelectDSLCompleter completer) {
+    public static <R> Optional<R> selectOptional(Function<SelectStatementProvider, Optional<R>> mapper, 
+            QueryExpressionDSL<SelectModel> start, SelectDSLCompleter completer) {
         return mapper.apply(completer.apply(start).build().render(RenderingStrategies.MYBATIS3));
     }
 

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/mybatis3/UtilityFunctions.kt

@@ -57,14 +57,14 @@ fun update(table: SqlTable, complete: UpdateCompleter) =
  * Function to handle platform type issues. Use this function, instead of calling MyBatis3Utils directly, to
  * avoid having to specify a return type explicitly.
  */
-fun <T> selectDistinct(mapper: (SelectStatementProvider) -> List<T>, selectList: Array<out BasicColumn>, table: SqlTable,
+fun <T> selectDistinct(mapper: (SelectStatementProvider) -> List<T>, selectList: List<BasicColumn>, table: SqlTable,
                        completer: SelectCompleter): List<T> =
         MyBatis3Utils.selectDistinct(mapper, selectList, table, completer)
 
 /**
  * Function to handle platform type issues. Use this function, instead of calling MyBatis3Utils directly, to
  * avoid having to specify a return type explicitly.
  */
-fun <T> selectList(mapper: (SelectStatementProvider) -> List<T>, selectList: Array<out BasicColumn>, table: SqlTable,
+fun <T> selectList(mapper: (SelectStatementProvider) -> List<T>, selectList: List<BasicColumn>, table: SqlTable,
                    completer: SelectCompleter): List<T> =
         MyBatis3Utils.selectList(mapper, selectList, table, completer)

src/site/markdown/docs/kotlin.md

@@ -54,9 +54,9 @@ interface PersonMapper {
 And then extensions could be added to make a shortcut method as follows:
 
 ```kotlin
-private val columnList = arrayOf(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId)
+private val columnList = listOf(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId)
 
-fun PersonMapper.select(completer: SelectCompleter): List<PersonRecord> =
+fun PersonMapper.select(completer: SelectCompleter) =
         selectList(this::selectMany, columnList, Person, completer)
 ```
 
@@ -251,7 +251,7 @@ interface PersonMapper {
 These methods can be used to create simplified select methods with Kotlin extension methods:
 
 ```kotlin
-private val columnList = arrayOf(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId)
+private val columnList = listOf(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId)
 
 fun PersonMapper.selectOne(completer: SelectCompleter) =
         MyBatis3Utils.selectOne(this::selectOne, columnList, Person, completer)

src/test/kotlin/examples/kotlin/canonical/PersonMapperExtensions.kt

@@ -83,7 +83,7 @@ fun PersonMapper.insertSelective(record: PersonRecord) =
             map(addressId).toPropertyWhenPresent("addressId", record::addressId)
         }
 
-private val columnList = arrayOf(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId)
+private val columnList = listOf(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId)
 
 fun PersonMapper.selectOne(completer: SelectCompleter) =
         MyBatis3Utils.selectOne(this::selectOne, columnList, Person, completer)

src/test/kotlin/examples/kotlin/canonical/PersonWithAddressMapperExtensions.kt

@@ -29,11 +29,11 @@ import org.mybatis.dynamic.sql.util.kotlin.fromJoining
 import org.mybatis.dynamic.sql.util.kotlin.fullJoin
 import org.mybatis.dynamic.sql.util.mybatis3.MyBatis3Utils
 
-private val columnList = arrayOf(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, Address.id,
+private val columnList = listOf(id.`as`("A_ID"), firstName, lastName, birthDate, employed, occupation, Address.id,
         Address.streetAddress, Address.city, Address.state)
 
 fun PersonWithAddressMapper.selectOne(completer: SelectCompleter): PersonWithAddress? {
-    val start = select(*columnList).fromJoining(Person) {
+    val start = select(columnList).fromJoining(Person) {
         fullJoin(Address) {
             on(Person.addressId, equalTo(Address.id))
         }
@@ -43,7 +43,7 @@ fun PersonWithAddressMapper.selectOne(completer: SelectCompleter): PersonWithAdd
 }
 
 fun PersonWithAddressMapper.select(completer: SelectCompleter): List<PersonWithAddress> {
-    val start = select(*columnList).fromJoining(Person, "p") {
+    val start = select(columnList).fromJoining(Person, "p") {
         fullJoin(Address) {
             on(Person.addressId, equalTo(Address.id))
         }