Basic support for generated keys in Spring

Author: jeffgbutler

src/main/java/org/mybatis/dynamic/sql/insert/BatchInsertModel.java

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2019 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.
@@ -17,6 +17,7 @@
 
 import java.util.Collection;
 
+import org.jetbrains.annotations.NotNull;
 import org.mybatis.dynamic.sql.insert.render.BatchInsert;
 import org.mybatis.dynamic.sql.insert.render.BatchInsertRenderer;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
@@ -27,6 +28,7 @@ private BatchInsertModel(Builder<T> builder) {
         super(builder);
     }
 
+    @NotNull
     public BatchInsert<T> render(RenderingStrategy renderingStrategy) {
         return BatchInsertRenderer.withBatchInsertModel(this)
                 .withRenderingStrategy(renderingStrategy)

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

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2017 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.

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinInsertHelpers.kt

@@ -15,6 +15,8 @@
  */
 package org.mybatis.dynamic.sql.util.kotlin
 
+import org.mybatis.dynamic.sql.insert.BatchInsertDSL
+import org.mybatis.dynamic.sql.insert.BatchInsertModel
 import org.mybatis.dynamic.sql.insert.GeneralInsertDSL
 import org.mybatis.dynamic.sql.insert.GeneralInsertModel
 import org.mybatis.dynamic.sql.insert.InsertDSL
@@ -28,3 +30,5 @@ typealias GeneralInsertCompleter = GeneralInsertDSL.() -> Buildable<GeneralInser
 typealias InsertCompleter<T> = InsertDSL<T>.() -> Buildable<InsertModel<T>>
 
 typealias MultiRowInsertCompleter<T> = MultiRowInsertDSL<T>.() -> Buildable<MultiRowInsertModel<T>>
+
+typealias BatchInsertCompleter<T> = BatchInsertDSL<T>.() -> Buildable<BatchInsertModel<T>>

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/NamedParameterJdbcTemplateExtensions.kt

@@ -21,6 +21,7 @@ import org.mybatis.dynamic.sql.BasicColumn
 import org.mybatis.dynamic.sql.SqlBuilder
 import org.mybatis.dynamic.sql.SqlTable
 import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider
+import org.mybatis.dynamic.sql.insert.render.BatchInsert
 import org.mybatis.dynamic.sql.insert.render.GeneralInsertStatementProvider
 import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider
 import org.mybatis.dynamic.sql.insert.render.MultiRowInsertStatementProvider
@@ -39,6 +40,7 @@ import org.springframework.dao.EmptyResultDataAccessException
 import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource
 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
+import org.springframework.jdbc.core.namedparam.SqlParameterSourceUtils
 import org.springframework.jdbc.support.KeyHolder
 import java.sql.ResultSet
 
@@ -60,10 +62,17 @@ fun NamedParameterJdbcTemplate.delete(deleteStatement: DeleteStatementProvider)
 fun NamedParameterJdbcTemplate.deleteFrom(table: SqlTable, completer: DeleteCompleter) =
     delete(org.mybatis.dynamic.sql.util.kotlin.spring.deleteFrom(table, completer))
 
+// batch insert
+fun <T> NamedParameterJdbcTemplate.insert(insertStatement: BatchInsert<T>): IntArray =
+    batchUpdate(insertStatement.insertStatementSQL, SqlParameterSourceUtils.createBatch(insertStatement.records))
+
 // single record insert
 fun <T> NamedParameterJdbcTemplate.insert(insertStatement: InsertStatementProvider<T>) =
     update(insertStatement.insertStatement, BeanPropertySqlParameterSource(insertStatement.record))
 
+fun <T> NamedParameterJdbcTemplate.insert(insertStatement: InsertStatementProvider<T>, keyHolder: KeyHolder) =
+    update(insertStatement.insertStatement, BeanPropertySqlParameterSource(insertStatement.record), keyHolder)
+
 fun <T> NamedParameterJdbcTemplate.insert(record: T) =
     SingleRowInsertHelper(record, this)
 
@@ -94,6 +103,10 @@ fun <T> NamedParameterJdbcTemplate.insertMultiple(records: List<T>) =
 fun <T> NamedParameterJdbcTemplate.insertMultiple(insertStatement: MultiRowInsertStatementProvider<T>) =
     update(insertStatement.insertStatement, BeanPropertySqlParameterSource(insertStatement))
 
+fun <T> NamedParameterJdbcTemplate.insertMultiple(insertStatement: MultiRowInsertStatementProvider<T>,
+                                                  keyHolder: KeyHolder) =
+    update(insertStatement.insertStatement, BeanPropertySqlParameterSource(insertStatement), keyHolder)
+
 fun NamedParameterJdbcTemplate.select(vararg selectList: BasicColumn) =
     SelectListFromGatherer(selectList.toList(), this)
 

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/ProviderBuilderFunctions.kt

@@ -17,13 +17,15 @@ package org.mybatis.dynamic.sql.util.kotlin.spring
 
 import org.mybatis.dynamic.sql.SqlBuilder
 import org.mybatis.dynamic.sql.SqlTable
+import org.mybatis.dynamic.sql.insert.BatchInsertDSL
 import org.mybatis.dynamic.sql.insert.GeneralInsertDSL
 import org.mybatis.dynamic.sql.insert.InsertDSL
 import org.mybatis.dynamic.sql.insert.MultiRowInsertDSL
 import org.mybatis.dynamic.sql.render.RenderingStrategies
 import org.mybatis.dynamic.sql.select.CountDSL
 import org.mybatis.dynamic.sql.select.QueryExpressionDSL
 import org.mybatis.dynamic.sql.select.SelectModel
+import org.mybatis.dynamic.sql.util.kotlin.BatchInsertCompleter
 import org.mybatis.dynamic.sql.util.kotlin.CountCompleter
 import org.mybatis.dynamic.sql.util.kotlin.DeleteCompleter
 import org.mybatis.dynamic.sql.util.kotlin.GeneralInsertCompleter
@@ -44,6 +46,9 @@ fun deleteFrom(table: SqlTable, completer: DeleteCompleter) =
     completer(KotlinDeleteBuilder(SqlBuilder.deleteFrom(table))).build()
         .render(RenderingStrategies.SPRING_NAMED_PARAMETER)
 
+fun <T> BatchInsertDSL.IntoGatherer<T>.into(table: SqlTable, completer: BatchInsertCompleter<T>) =
+    completer(into(table)).build().render(RenderingStrategies.SPRING_NAMED_PARAMETER)
+
 fun <T> InsertDSL.IntoGatherer<T>.into(table: SqlTable, completer: InsertCompleter<T>) =
     completer(into(table)).build().render(RenderingStrategies.SPRING_NAMED_PARAMETER)
 

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

@@ -16,7 +16,6 @@
 package examples.kotlin.spring.canonical
 
 import examples.kotlin.spring.canonical.AddressDynamicSqlSupport.Address
-import examples.kotlin.spring.canonical.GeneratedAlwaysDynamicSqlSupport.GeneratedAlways
 import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.Person
 import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.Person.addressId
 import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.Person.birthDate
@@ -33,15 +32,14 @@ import org.mybatis.dynamic.sql.util.kotlin.spring.*
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
 import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder
 import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType
-import org.springframework.jdbc.support.GeneratedKeyHolder
 import java.util.*
 
 class CanonicalSpringKotlinTemplateDirectTest {
     private lateinit var template: NamedParameterJdbcTemplate
 
     @BeforeEach
     fun setup() {
-        val db = EmbeddedDatabaseBuilder().run {
+        val db = with(EmbeddedDatabaseBuilder()) {
             setType(EmbeddedDatabaseType.HSQL)
             generateUniqueName(true)
             addScript("classpath:/examples/kotlin/spring/CreateGeneratedAlwaysDB.sql")
@@ -233,16 +231,6 @@ class CanonicalSpringKotlinTemplateDirectTest {
     }
 
     fun testGeneralInsertWithGeneratedKey() {
-//        val keyHolder = GeneratedKeyHolder()
-//
-//        val rows = template.insertInto(GeneratedAlways) {
-//            set(GeneratedAlways.firstName).toValue("Fred")
-//            set(GeneratedAlways.lastName).toValue("Flintstone")
-//        }.withKeyHolder(keyHolder)
-//
-//        assertThat(rows).isEqualTo(1)
-//        assertThat(keyHolder.keys).containsEntry("ID", 22)
-//        assertThat(keyHolder.keys).containsEntry("FULL_NAME", "Fred Flintstone")
         TODO()
     }
 

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

@@ -34,7 +34,6 @@ import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
 import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder
 import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType
 import org.springframework.jdbc.support.GeneratedKeyHolder
-import org.springframework.jdbc.support.KeyHolder
 import java.util.*
 
 @Suppress("LargeClass", "MaxLineLength")
@@ -43,7 +42,7 @@ class CanonicalSpringKotlinTest {
 
     @BeforeEach
     fun setup() {
-        val db = EmbeddedDatabaseBuilder().run {
+        val db = with(EmbeddedDatabaseBuilder()) {
             setType(EmbeddedDatabaseType.HSQL)
             generateUniqueName(true)
             addScript("classpath:/examples/kotlin/spring/CreateGeneratedAlwaysDB.sql")
@@ -315,8 +314,25 @@ class CanonicalSpringKotlinTest {
         assertThat(rows).isEqualTo(2)
     }
 
+    @Test
     fun testBatchInsert() {
-        TODO()
+        val record1 = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
+        val record2 = PersonRecord(101, "Sarah", LastName("Smith"), Date(), true, "Architect", 2)
+
+        val insertStatement = insert(record1, record2).into(Person) {
+            map(id).toProperty("id")
+            map(firstName).toProperty("firstName")
+            map(lastName).toProperty("lastNameAsString")
+            map(birthDate).toProperty("birthDate")
+            map(employed).toProperty("employedAsString")
+            map(occupation).toProperty("occupation")
+            map(addressId).toProperty("addressId")
+        }
+
+        val rows = template.insert(insertStatement)
+        assertThat(rows).hasSize(2)
+        assertThat(rows[0]).isEqualTo(1)
+        assertThat(rows[1]).isEqualTo(1)
     }
 
     @Test
@@ -334,12 +350,42 @@ class CanonicalSpringKotlinTest {
         assertThat(keyHolder.keys).containsEntry("FULL_NAME", "Fred Flintstone")
     }
 
+    @Test
     fun testInsertWithGeneratedKey() {
-        TODO()
+        val record = GeneratedAlwaysRecord(firstName = "Fred", lastName = "Flintstone")
+
+        val insertStatement = insert(record).into(GeneratedAlways) {
+            map(firstName).toProperty("firstName")
+            map(lastName).toProperty("lastName")
+        }
+
+        val keyHolder = GeneratedKeyHolder()
+
+        val rows = template.insert(insertStatement, keyHolder)
+        assertThat(rows).isEqualTo(1)
+        assertThat(keyHolder.keys).containsEntry("ID", 22)
+        assertThat(keyHolder.keys).containsEntry("FULL_NAME", "Fred Flintstone")
     }
 
+    @Test
     fun testMultiRowInsertWithGeneratedKey() {
-        TODO()
+        val record1 = GeneratedAlwaysRecord(firstName = "Fred", lastName = "Flintstone")
+        val record2 = GeneratedAlwaysRecord(firstName = "Barney", lastName = "Rubble")
+
+        val insertStatement = insertMultiple(record1, record2)
+            .into(GeneratedAlways) {
+            map(firstName).toProperty("firstName")
+            map(lastName).toProperty("lastName")
+        }
+
+        val keyHolder = GeneratedKeyHolder()
+
+        val rows = template.insertMultiple(insertStatement, keyHolder)
+        assertThat(rows).isEqualTo(2)
+        assertThat(keyHolder.keyList[0]).containsEntry("ID", 22)
+        assertThat(keyHolder.keyList[0]).containsEntry("FULL_NAME", "Fred Flintstone")
+        assertThat(keyHolder.keyList[1]).containsEntry("ID", 23)
+        assertThat(keyHolder.keyList[1]).containsEntry("FULL_NAME", "Barney Rubble")
     }
 
     @Test

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

@@ -58,3 +58,10 @@ data class AddressRecord(
     var city: String? = null,
     var state: String? = null
 )
+
+data class GeneratedAlwaysRecord (
+    var id: Int? = null,
+    var firstName: String? = null,
+    var lastName: String? = null,
+    var fullName: String? = null
+)

src/test/resources/examples/kotlin/spring/CreateGeneratedAlwaysDB.sql

@@ -1,5 +1,5 @@
 --
---    Copyright 2016-2019 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.