Insert SET methods can be infix

jeffgbutler · jeffgbutler · commit 007ab157f8f1 · 2022-02-07T12:10:54.000-05:00
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinInsertHelpers.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinInsertHelpers.kt
@@ -47,38 +47,38 @@ class KotlinGeneralInsertBuilder(private val dsl: GeneralInsertDSL) : Buildable<
                 set(column).toNull()
             }
 
-        fun toConstant(constant: String): Unit =
+        infix fun toConstant(constant: String): Unit =
             applyToDsl {
                 set(column).toConstant(constant)
             }
 
-        fun toStringConstant(constant: String): Unit =
+        infix fun toStringConstant(constant: String): Unit =
             applyToDsl {
                 set(column).toStringConstant(constant)
             }
 
-        fun toValue(value: T): Unit = toValue { value }
+        infix fun toValue(value: T): Unit = toValue { value }
 
-        fun toValue(value: () -> T): Unit =
+        infix fun toValue(value: () -> T): Unit =
             applyToDsl {
                 set(column).toValue(value)
             }
 
-        fun toValueOrNull(value: T?): Unit = toValueOrNull { value }
+        infix fun toValueOrNull(value: T?): Unit = toValueOrNull { value }
 
-        fun toValueOrNull(value: () -> T?): Unit =
+        infix fun toValueOrNull(value: () -> T?): Unit =
             applyToDsl {
                 set(column).toValueOrNull(value)
             }
 
-        fun toValueWhenPresent(value: T?): Unit = toValueWhenPresent { value }
+        infix fun toValueWhenPresent(value: T?): Unit = toValueWhenPresent { value }
 
-        fun toValueWhenPresent(value: () -> T?): Unit =
+        infix fun toValueWhenPresent(value: () -> T?): Unit =
             applyToDsl {
                 set(column).toValueWhenPresent(value)
             }
 
-        private fun applyToDsl(block: GeneralInsertDSL.() -> Unit): Unit {
+        private fun applyToDsl(block: GeneralInsertDSL.() -> Unit) {
             this@KotlinGeneralInsertBuilder.dsl.apply(block)
         }
     }
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/canonical/GeneratedAlwaysTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/canonical/GeneratedAlwaysTest.kt
@@ -1,5 +1,5 @@
 /*
- *    Copyright 2016-2021 the original author or authors.
+ *    Copyright 2016-2022 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.
@@ -129,8 +129,8 @@ class GeneratedAlwaysTest {
             val mapper = session.getMapper(GeneratedAlwaysMapper::class.java)
 
             val insertStatement = insertInto(generatedAlways) {
-                set(firstName).toValue("Fred")
-                set(lastName).toValue("Flintstone")
+                set(firstName) toValue "Fred"
+                set(lastName) toValue "Flintstone"
             }
 
             val rows = mapper.generalInsert(insertStatement)
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/canonical/PersonMapperTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/canonical/PersonMapperTest.kt
@@ -228,13 +228,13 @@ class PersonMapperTest {
             val mapper = session.getMapper(PersonMapper::class.java)
 
             val rows = mapper.generalInsert {
-                set(id).toValue(100)
-                set(firstName).toValue("Joe")
-                set(lastName).toValue(LastName("Jones"))
-                set(employed).toValue(true)
-                set(occupation).toValue("Developer")
-                set(addressId).toValue(1)
-                set(birthDate).toValue(Date())
+                set(id) toValue 100
+                set(firstName) toValue "Joe"
+                set(lastName) toValue LastName("Jones")
+                set(employed) toValue true
+                set(occupation) toValue "Developer"
+                set(addressId) toValue 1
+                set(birthDate) toValue Date()
             }
 
             assertThat(rows).isEqualTo(1)
@@ -718,11 +718,11 @@ class PersonMapperTest {
             val mapper: AddressMapper = session.getMapper(AddressMapper::class.java)
 
             val insertStatement = insertInto(address) {
-                set(address.id).toValue(4)
-                set(address.streetAddress).toValue("987 Elm Street")
-                set(address.city).toValue("Mayberry")
-                set(address.state).toValue("NC")
-                set(address.addressType).toValue(AddressType.HOME)
+                set(address.id) toValue 4
+                set(address.streetAddress) toValue "987 Elm Street"
+                set(address.city) toValue "Mayberry"
+                set(address.state) toValue "NC"
+                set(address.addressType) toValue AddressType.HOME
             }
 
             val rows = mapper.generalInsert(insertStatement)
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/custom/render/KCustomRenderingTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/custom/render/KCustomRenderingTest.kt
@@ -125,9 +125,9 @@ class KCustomRenderingTest {
         sqlSessionFactory.openSession().use { sqlSession ->
             val mapper = sqlSession.getMapper(KJsonTestMapper::class.java)
             var insertStatement = insertInto(jsonTest) {
-                set(id).toValue(1)
-                set(description).toValue("Fred")
-                set(info).toValue("{\"firstName\": \"Fred\", \"lastName\": \"Flintstone\", \"age\": 30}")
+                set(id) toValue 1
+                set(description) toValue "Fred"
+                set(info) toValue "{\"firstName\": \"Fred\", \"lastName\": \"Flintstone\", \"age\": 30}"
             }
             val expected = "insert into JsonTest (id, description, info) " +
                 "values (#{parameters.p1,jdbcType=INTEGER}, #{parameters.p2,jdbcType=VARCHAR}, " +
@@ -136,9 +136,9 @@ class KCustomRenderingTest {
             var rows = mapper!!.generalInsert(insertStatement)
             assertThat(rows).isEqualTo(1)
             insertStatement = insertInto(jsonTest) {
-                set(id).toValue(2)
-                set(description).toValue("Wilma")
-                set(info).toValue("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}")
+                set(id) toValue 2
+                set(description) toValue "Wilma"
+                set(info) toValue "{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}"
             }
             rows = mapper.generalInsert(insertStatement)
             assertThat(rows).isEqualTo(1)
diff --git a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTemplateDirectTest.kt b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTemplateDirectTest.kt
@@ -190,13 +190,13 @@ open class CanonicalSpringKotlinTemplateDirectTest {
     @Test
     fun testGeneralInsert() {
         val rows = template.insertInto(person) {
-            set(id).toValue(100)
-            set(firstName).toValue("Joe")
-            set(lastName).toValue(LastName("Jones"))
-            set(birthDate).toValue(Date())
-            set(employed).toValue(true)
-            set(occupation).toValue("Developer")
-            set(addressId).toValue(1)
+            set(id) toValue 100
+            set(firstName) toValue "Joe"
+            set(lastName) toValue LastName("Jones")
+            set(birthDate) toValue Date()
+            set(employed) toValue true
+            set(occupation) toValue "Developer"
+            set(addressId) toValue 1
         }
 
         assertThat(rows).isEqualTo(1)
@@ -279,8 +279,8 @@ open class CanonicalSpringKotlinTemplateDirectTest {
 
         val rows = template.withKeyHolder(keyHolder) {
             insertInto(generatedAlways) {
-                set(generatedAlways.firstName).toValue("Fred")
-                set(generatedAlways.lastName).toValue("Flintstone")
+                set(generatedAlways.firstName) toValue "Fred"
+                set(generatedAlways.lastName) toValue "Flintstone"
             }
         }
 
diff --git a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt
@@ -272,13 +272,13 @@ open class CanonicalSpringKotlinTest {
     fun testGeneralInsert() {
 
         val insertStatement = insertInto(person) {
-            set(id).toConstant("100")
-            set(firstName).toStringConstant("Joe")
-            set(lastName).toValue(LastName("Jones"))
-            set(birthDate).toValue(Date())
-            set(employed).toValue(true)
+            set(id) toConstant "100"
+            set(firstName) toStringConstant "Joe"
+            set(lastName) toValue LastName("Jones")
+            set(birthDate) toValue Date()
+            set(employed) toValue true
             set(occupation).toNull()
-            set(addressId).toValue(1)
+            set(addressId) toValue 1
         }
 
         val expected =
@@ -309,13 +309,13 @@ open class CanonicalSpringKotlinTest {
     fun testGeneralInsertSpecialConditions() {
 
         val insertStatement = insertInto(person) {
-            set(id).toConstant("100")
-            set(firstName).toStringConstant("Joe")
-            set(lastName).toValue(LastName("Jones"))
-            set(birthDate).toValue(Date())
-            set(employed).toValueOrNull(true)
-            set(occupation).toValueWhenPresent(null)
-            set(addressId).toValue(1)
+            set(id) toConstant "100"
+            set(firstName) toStringConstant "Joe"
+            set(lastName) toValue LastName("Jones")
+            set(birthDate) toValue Date()
+            set(employed) toValueOrNull true
+            set(occupation) toValueWhenPresent null
+            set(addressId) toValue 1
         }
 
         val expected =
@@ -453,8 +453,8 @@ open class CanonicalSpringKotlinTest {
     @DirtiesContext(methodMode = DirtiesContext.MethodMode.AFTER_METHOD)
     fun testGeneralInsertWithGeneratedKey() {
         val insertStatement = insertInto(generatedAlways) {
-            set(generatedAlways.firstName).toValue("Fred")
-            set(generatedAlways.lastName).toValue("Flintstone")
+            set(generatedAlways.firstName) toValue "Fred"
+            set(generatedAlways.lastName) toValue "Flintstone"
         }
 
         val keyHolder = GeneratedKeyHolder()

Original file line number	Diff line number	Diff line change
`@@ -47,38 +47,38 @@ class KotlinGeneralInsertBuilder(private val dsl: GeneralInsertDSL) : Buildable<`
`47`	`47`	`set(column).toNull()`
`48`	`48`	`}`
`49`	`49`
`50`		`- fun toConstant(constant: String): Unit =`
	`50`	`+ infix fun toConstant(constant: String): Unit =`
`51`	`51`	`applyToDsl {`
`52`	`52`	`set(column).toConstant(constant)`
`53`	`53`	`}`
`54`	`54`
`55`		`- fun toStringConstant(constant: String): Unit =`
	`55`	`+ infix fun toStringConstant(constant: String): Unit =`
`56`	`56`	`applyToDsl {`
`57`	`57`	`set(column).toStringConstant(constant)`
`58`	`58`	`}`
`59`	`59`
`60`		`- fun toValue(value: T): Unit = toValue { value }`
	`60`	`+ infix fun toValue(value: T): Unit = toValue { value }`
`61`	`61`
`62`		`- fun toValue(value: () -> T): Unit =`
	`62`	`+ infix fun toValue(value: () -> T): Unit =`
`63`	`63`	`applyToDsl {`
`64`	`64`	`set(column).toValue(value)`
`65`	`65`	`}`
`66`	`66`
`67`		`- fun toValueOrNull(value: T?): Unit = toValueOrNull { value }`
	`67`	`+ infix fun toValueOrNull(value: T?): Unit = toValueOrNull { value }`
`68`	`68`
`69`		`- fun toValueOrNull(value: () -> T?): Unit =`
	`69`	`+ infix fun toValueOrNull(value: () -> T?): Unit =`
`70`	`70`	`applyToDsl {`
`71`	`71`	`set(column).toValueOrNull(value)`
`72`	`72`	`}`
`73`	`73`
`74`		`- fun toValueWhenPresent(value: T?): Unit = toValueWhenPresent { value }`
	`74`	`+ infix fun toValueWhenPresent(value: T?): Unit = toValueWhenPresent { value }`
`75`	`75`
`76`		`- fun toValueWhenPresent(value: () -> T?): Unit =`
	`76`	`+ infix fun toValueWhenPresent(value: () -> T?): Unit =`
`77`	`77`	`applyToDsl {`
`78`	`78`	`set(column).toValueWhenPresent(value)`
`79`	`79`	`}`
`80`	`80`
`81`		`- private fun applyToDsl(block: GeneralInsertDSL.() -> Unit): Unit {`
	`81`	`+ private fun applyToDsl(block: GeneralInsertDSL.() -> Unit) {`
`82`	`82`	`this@KotlinGeneralInsertBuilder.dsl.apply(block)`
`83`	`83`	`}`
`84`	`84`	`}`