Implement better method for handling multi-row inserts with generated keys

Author: jeffgbutler

src/main/java/org/mybatis/dynamic/sql/util/SqlProviderAdapter.java

@@ -1,5 +1,5 @@
 /*
- *    Copyright 2016-2020 the original author or authors.
+ *    Copyright 2016-2021 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.
@@ -51,16 +51,27 @@ public String insertMultiple(MultiRowInsertStatementProvider<?> insertStatement)
         return insertStatement.getInsertStatement();
     }
 
+    /**
+     * This adapter method is intended for use with MyBatis' @InsertProvider annotation when there are generated
+     * values expected from executing the insert statement.
+     *
+     * @param parameterMap The parameter map is automatically created by MyBatis when there are multiple
+     *     parameters in the insert method.
+     * @return the SQL statement contained in the parameter map. This is assumed to be the one
+     *     and only map entry of type String.
+     */
     public String insertMultipleWithGeneratedKeys(Map<String, Object> parameterMap) {
         List<String> entries = parameterMap.entrySet().stream()
                 .filter(e -> e.getKey().startsWith("param")) //$NON-NLS-1$
-                .filter(e -> e.getValue() instanceof String)
+                .filter(e -> String.class.isAssignableFrom(e.getValue().getClass()))
                 .map(e -> (String) e.getValue())
                 .collect(Collectors.toList());
+
         if (entries.size() == 1) {
             return entries.get(0);
         } else {
-            throw new RuntimeException("The parameters for insertMultipleWithGeneratedKeys must contain exactly one parameter of type String");
+            throw new IllegalArgumentException("The parameters for insertMultipleWithGeneratedKeys" + //$NON-NLS-1$
+                    " must contain exactly one parameter of type String"); //$NON-NLS-1$
         }
     }
 

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

@@ -1,5 +1,5 @@
 /*
- *    Copyright 2016-2020 the original author or authors.
+ *    Copyright 2016-2021 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,6 +18,7 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.function.Function;
+import java.util.function.ToIntBiFunction;
 import java.util.function.ToIntFunction;
 import java.util.function.ToLongFunction;
 import java.util.function.UnaryOperator;
@@ -138,6 +139,12 @@ public static <R> int insertMultiple(ToIntFunction<MultiRowInsertStatementProvid
         return mapper.applyAsInt(insertMultiple(records, table, completer));
     }
 
+    public static <R> int insertMultipleWithGeneratedKeys(ToIntBiFunction<String, List<R>> mapper,
+            Collection<R> records, SqlTable table, UnaryOperator<MultiRowInsertDSL<R>> completer) {
+        MultiRowInsertStatementProvider<R> provider = insertMultiple(records, table, completer);
+        return mapper.applyAsInt(provider.getInsertStatement(), provider.getRecords());
+    }
+
     public static SelectStatementProvider select(BasicColumn[] selectList, SqlTable table,
             SelectDSLCompleter completer) {
         return select(SqlBuilder.select(selectList).from(table), completer);

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

@@ -1,5 +1,5 @@
 /*
- *    Copyright 2016-2020 the original author or authors.
+ *    Copyright 2016-2021 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.
@@ -73,7 +73,7 @@ fun <T> insertMultipleWithGeneratedKeys(
     table: SqlTable,
     completer: MultiRowInsertCompleter<T>
 ): Int =
-    with(insertMultiple(records).into(table, completer)) {
+    with(SqlBuilder.insertMultiple(records).into(table, completer)) {
         mapper(insertStatement, this.records)
     }
 

src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapper.java

@@ -1,5 +1,5 @@
 /*
- *    Copyright 2016-2020 the original author or authors.
+ *    Copyright 2016-2021 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.
@@ -23,7 +23,6 @@
 import java.util.List;
 import java.util.Optional;
 
-import org.apache.ibatis.annotations.Insert;
 import org.apache.ibatis.annotations.InsertProvider;
 import org.apache.ibatis.annotations.Options;
 import org.apache.ibatis.annotations.Param;
@@ -33,7 +32,6 @@
 import org.apache.ibatis.annotations.SelectProvider;
 import org.mybatis.dynamic.sql.BasicColumn;
 import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
-import org.mybatis.dynamic.sql.insert.render.MultiRowInsertStatementProvider;
 import org.mybatis.dynamic.sql.select.SelectDSLCompleter;
 import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
 import org.mybatis.dynamic.sql.update.UpdateDSL;
@@ -42,11 +40,10 @@
 import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
 
 import examples.generated.always.GeneratedAlwaysRecord;
-import org.mybatis.dynamic.sql.util.mybatis3.CommonInsertMapper;
 import org.mybatis.dynamic.sql.util.mybatis3.CommonUpdateMapper;
 import org.mybatis.dynamic.sql.util.mybatis3.MyBatis3Utils;
 
-public interface GeneratedAlwaysMapper extends CommonInsertMapper<GeneratedAlwaysRecord>, CommonUpdateMapper {
+public interface GeneratedAlwaysMapper extends CommonUpdateMapper {
     @SelectProvider(type=SqlProviderAdapter.class, method="select")
     @Results(id="gaResults", value={
         @Result(property="id", column="id", id=true),
@@ -60,23 +57,14 @@ public interface GeneratedAlwaysMapper extends CommonInsertMapper<GeneratedAlway
     @ResultMap("gaResults")
     Optional<GeneratedAlwaysRecord> selectOne(SelectStatementProvider selectStatement);
 
-    @Override
     @InsertProvider(type=SqlProviderAdapter.class, method="insert")
     @Options(useGeneratedKeys=true, keyProperty="record.fullName")
     int insert(InsertStatementProvider<GeneratedAlwaysRecord> insertStatement);
 
-    // This is kludgy. Currently MyBatis does not support nested lists in parameter objects
-    // when returning generated keys.
-    // So we need to do this silliness and decompose the multi row insert into its component parts
-    // for the actual MyBatis call
-    @Insert("${insertStatement}")
+    @InsertProvider(type=SqlProviderAdapter.class, method="insertMultipleWithGeneratedKeys")
     @Options(useGeneratedKeys=true, keyProperty="records.fullName")
     int insertMultiple(@Param("insertStatement") String statement, @Param("records") List<GeneratedAlwaysRecord> records);
 
-    default int insertMultiple(MultiRowInsertStatementProvider<GeneratedAlwaysRecord> multiInsert) {
-        return insertMultiple(multiInsert.getInsertStatement(), multiInsert.getRecords());
-    }
-
     BasicColumn[] selectList =
             BasicColumn.columnList(id, firstName, lastName, fullName);
 
@@ -100,6 +88,18 @@ default int insert(GeneratedAlwaysRecord record) {
         );
     }
 
+    default int insertMultiple(GeneratedAlwaysRecord...records) {
+        return insertMultiple(Arrays.asList(records));
+    }
+
+    default int insertMultiple(Collection<GeneratedAlwaysRecord> records) {
+        return MyBatis3Utils.insertMultipleWithGeneratedKeys(this::insertMultiple, records, generatedAlways, c ->
+                c.map(id).toProperty("id")
+                        .map(firstName).toProperty("firstName")
+                        .map(lastName).toProperty("lastName")
+        );
+    }
+
     default int insertSelective(GeneratedAlwaysRecord record) {
         return MyBatis3Utils.insert(this::insert, record, generatedAlways, c ->
                 c.map(id).toPropertyWhenPresent("id", record::getId)
@@ -133,16 +133,4 @@ static UpdateDSL<UpdateModel> updateSelectiveColumns(GeneratedAlwaysRecord recor
                 .set(firstName).equalToWhenPresent(record::getFirstName)
                 .set(lastName).equalToWhenPresent(record::getLastName);
     }
-
-    default int insertMultiple(GeneratedAlwaysRecord...records) {
-        return insertMultiple(Arrays.asList(records));
-    }
-
-    default int insertMultiple(Collection<GeneratedAlwaysRecord> records) {
-        return MyBatis3Utils.insertMultiple(this::insertMultiple, records, generatedAlways, c ->
-                c.map(id).toProperty("id")
-                        .map(firstName).toProperty("firstName")
-                        .map(lastName).toProperty("lastName")
-                );
-    }
 }

src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapperTest.java

@@ -227,7 +227,7 @@ void testMultiInsertWithArrayAndVariousMappings() {
 
             assertThat(multiRowInsert.getInsertStatement()).isEqualTo(statement);
 
-            int rows = mapper.insertMultiple(multiRowInsert);
+            int rows = mapper.insertMultiple(multiRowInsert.getInsertStatement(), multiRowInsert.getRecords());
 
             assertAll(
                     () -> assertThat(rows).isEqualTo(1),

src/test/java/org/mybatis/dynamic/sql/util/SqlProviderAdapterTest.java

@@ -0,0 +1,35 @@
+/*
+ *    Copyright 2016-2021 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.util;
+
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+class SqlProviderAdapterTest {
+    @Test
+    void testThatInsertMultipleWithGeneratedKeysThrowsException() {
+        Map<String, Object> parameters = new HashMap<>();
+        SqlProviderAdapter adapter = new SqlProviderAdapter();
+
+        assertThatExceptionOfType(IllegalArgumentException.class)
+                .isThrownBy(() -> adapter.insertMultipleWithGeneratedKeys(parameters))
+                .withMessage("The parameters for insertMultipleWithGeneratedKeys must contain exactly one parameter of type String");
+    }
+}