Coverage

Author: jeffgbutler

src/test/kotlin/examples/kotlin/mybatis3/canonical/GeneratedAlwaysDynamicSqlSupport.kt

@@ -0,0 +1,34 @@
+/*
+ *    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 examples.kotlin.mybatis3.canonical
+
+import org.mybatis.dynamic.sql.SqlTable
+import java.sql.JDBCType
+
+object GeneratedAlwaysDynamicSqlSupport {
+    val generatedAlways = GeneratedAlways()
+    val id = generatedAlways.id
+    val firstName = generatedAlways.firstName
+    val lastName = generatedAlways.lastName
+    val fullName = generatedAlways.fullName
+
+    class GeneratedAlways : SqlTable("GeneratedAlways") {
+        val id = column<Int>("id", JDBCType.INTEGER)
+        val firstName = column<String>("first_name", JDBCType.VARCHAR)
+        val lastName = column<String>("last_name", JDBCType.VARCHAR)
+        val fullName = column<String>("full_name", JDBCType.VARCHAR)
+    }
+}

src/test/kotlin/examples/kotlin/mybatis3/canonical/GeneratedAlwaysMapper.kt

@@ -0,0 +1,55 @@
+/*
+ *    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 examples.kotlin.mybatis3.canonical
+
+import examples.kotlin.mybatis3.canonical.GeneratedAlwaysDynamicSqlSupport.firstName
+import examples.kotlin.mybatis3.canonical.GeneratedAlwaysDynamicSqlSupport.generatedAlways
+import examples.kotlin.mybatis3.canonical.GeneratedAlwaysDynamicSqlSupport.lastName
+import org.apache.ibatis.annotations.InsertProvider
+import org.apache.ibatis.annotations.Options
+import org.apache.ibatis.annotations.Param
+import org.mybatis.dynamic.sql.insert.render.GeneralInsertStatementProvider
+import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider
+import org.mybatis.dynamic.sql.util.SqlProviderAdapter
+import org.mybatis.dynamic.sql.util.kotlin.mybatis3.insert
+import org.mybatis.dynamic.sql.util.kotlin.mybatis3.insertMultipleWithGeneratedKeys
+
+interface GeneratedAlwaysMapper {
+    @InsertProvider(type = SqlProviderAdapter::class, method = "insert")
+    @Options(useGeneratedKeys = true, keyProperty="record.id,record.fullName", keyColumn = "id,full_name")
+    fun insert(insertStatement: InsertStatementProvider<GeneratedAlwaysRecord>): Int
+
+    @InsertProvider(type = SqlProviderAdapter::class, method = "generalInsert")
+    fun generalInsert(insertStatement: GeneralInsertStatementProvider): Int
+
+    @InsertProvider(type = SqlProviderAdapter::class, method = "insertMultipleWithGeneratedKeys")
+    @Options(useGeneratedKeys = true, keyProperty="records.id,records.fullName", keyColumn = "id,full_name")
+    fun insertMultiple(insertStatement: String, @Param("records") records: List<GeneratedAlwaysRecord>): Int
+}
+
+fun GeneratedAlwaysMapper.insert(record: GeneratedAlwaysRecord): Int {
+    return insert(this::insert, record, generatedAlways) {
+        map(firstName).toProperty("firstName")
+        map(lastName).toProperty("lastName")
+    }
+}
+
+fun GeneratedAlwaysMapper.insertMultiple(records: Collection<GeneratedAlwaysRecord>): Int {
+    return insertMultipleWithGeneratedKeys(this::insertMultiple, records, generatedAlways) {
+        map(firstName).toProperty("firstName")
+        map(lastName).toProperty("lastName")
+    }
+}

src/test/kotlin/examples/kotlin/mybatis3/canonical/GeneratedAlwaysRecord.kt

@@ -0,0 +1,23 @@
+/*
+ *    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 examples.kotlin.mybatis3.canonical
+
+data class GeneratedAlwaysRecord(
+    var id: Int? = null,
+    var firstName: String?,
+    var lastName: String?,
+    var fullName: String? = null
+)

src/test/kotlin/examples/kotlin/mybatis3/canonical/GeneratedAlwaysTest.kt

@@ -0,0 +1,95 @@
+/*
+ *    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 examples.kotlin.mybatis3.canonical
+
+import org.apache.ibatis.datasource.unpooled.UnpooledDataSource
+import org.apache.ibatis.jdbc.ScriptRunner
+import org.apache.ibatis.mapping.Environment
+import org.apache.ibatis.session.Configuration
+import org.apache.ibatis.session.ExecutorType
+import org.apache.ibatis.session.SqlSession
+import org.apache.ibatis.session.SqlSessionFactoryBuilder
+import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import java.io.InputStreamReader
+import java.sql.DriverManager
+
+class GeneratedAlwaysTest {
+    private fun newSession(executorType: ExecutorType = ExecutorType.REUSE): SqlSession {
+        Class.forName(JDBC_DRIVER)
+        val script = javaClass.getResourceAsStream("/examples/kotlin/spring/CreateGeneratedAlwaysDB.sql")
+        DriverManager.getConnection(JDBC_URL, "sa", "").use { connection ->
+            val sr = ScriptRunner(connection)
+            sr.setLogWriter(null)
+            sr.runScript(InputStreamReader(script))
+        }
+
+        val ds = UnpooledDataSource(JDBC_DRIVER, JDBC_URL, "sa", "")
+        val environment = Environment("test", JdbcTransactionFactory(), ds)
+        val config = Configuration(environment)
+        config.addMapper(GeneratedAlwaysMapper::class.java)
+        return SqlSessionFactoryBuilder().build(config).openSession(executorType)
+    }
+
+    @Test
+    fun testInsertSingleRecord() {
+        newSession().use { session ->
+            val mapper = session.getMapper(GeneratedAlwaysMapper::class.java)
+
+            val record = GeneratedAlwaysRecord(
+                firstName = "Fred",
+                lastName = "Flintstone"
+            )
+
+            val rows = mapper.insert(record)
+
+            assertThat(rows).isEqualTo(1)
+            assertThat(record.id).isEqualTo(22)
+            assertThat(record.fullName).isEqualTo("Fred Flintstone")
+        }
+    }
+
+    @Test
+    fun testInsertMultiple() {
+        newSession().use { session ->
+            val mapper = session.getMapper(GeneratedAlwaysMapper::class.java)
+
+            val record1 = GeneratedAlwaysRecord(
+                firstName = "Fred",
+                lastName = "Flintstone"
+            )
+
+            val record2 = GeneratedAlwaysRecord(
+                firstName = "Barney",
+                lastName = "Rubble"
+            )
+
+            val rows = mapper.insertMultiple(listOf(record1, record2))
+
+            assertThat(rows).isEqualTo(2)
+            assertThat(record1.id).isEqualTo(22)
+            assertThat(record1.fullName).isEqualTo("Fred Flintstone")
+            assertThat(record2.id).isEqualTo(23)
+            assertThat(record2.fullName).isEqualTo("Barney Rubble")
+        }
+    }
+
+    companion object {
+        const val JDBC_URL = "jdbc:hsqldb:mem:aname"
+        const val JDBC_DRIVER = "org.hsqldb.jdbcDriver"
+    }
+}