Remove some obscure coding and standardize on a common exception

jeffgbutler · jeffgbutler · commit 45bcf1ad7a2a · 2022-02-16T12:49:05.000-05:00
KInvalidSQLException will now be thrown from any misuse of the Kotlin DSL
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/GroupingCriteriaCollector.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/GroupingCriteriaCollector.kt
@@ -47,7 +47,8 @@ class GroupingCriteriaCollector {
     internal var initialCriterion: SqlCriterion? = null
         private set(value) {
             if (field != null) {
-                throw DuplicateInitialCriterionException()
+                throw KInvalidSQLException("Setting more than one initial criterion is not allowed. " +
+                        "Additional criteria should be added with \"and\" or \"or\" expression")
             }
             field = value
         }
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/JoinCollector.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/JoinCollector.kt
@@ -24,12 +24,14 @@ typealias JoinReceiver = JoinCollector.() -> Unit
 
 @MyBatisDslMarker
 class JoinCollector {
-    val onJoinCriterion: JoinCriterion by lazy { internalOnCriterion }
-    val andJoinCriteria = mutableListOf<JoinCriterion>()
-    private lateinit var internalOnCriterion: JoinCriterion
+    private var onJoinCriterion: JoinCriterion? = null
+    internal val andJoinCriteria = mutableListOf<JoinCriterion>()
+
+    internal fun onJoinCriterion() : JoinCriterion =
+        onJoinCriterion?: throw KInvalidSQLException("You must specify an \"on\" condition in a join")
 
     fun on(leftColumn: BasicColumn): RightColumnCollector = RightColumnCollector {
-        internalOnCriterion = JoinCriterion.Builder()
+        onJoinCriterion = JoinCriterion.Builder()
             .withConnector("on")
             .withJoinColumn(leftColumn)
             .withJoinCondition(it)
@@ -48,7 +50,7 @@ class JoinCollector {
 
     @Deprecated("Please use: on(leftColumn) equalTo rightColumn")
     fun on(column: BasicColumn, condition: JoinCondition) {
-        internalOnCriterion = JoinCriterion.Builder()
+        onJoinCriterion = JoinCriterion.Builder()
             .withConnector("on")
             .withJoinColumn(column)
             .withJoinCondition(condition)
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KInvalidSQLException.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KInvalidSQLException.kt
@@ -16,11 +16,6 @@
 package org.mybatis.dynamic.sql.util.kotlin
 
 /**
- * This exception is thrown when a where clause contains more than one criterion and there
- * is not an "and" or an "or" to connect them.
- *
- * @since 1.4.0
+ * This exception is thrown if the library detects misuse of the Kotlin DSL that would result in invalid SQL
  */
-class DuplicateInitialCriterionException : RuntimeException(
-    "Setting more than one initial criterion is not allowed. " +
-            "Additional criteria should be added with \"and\" or \"or\" expression")
+class KInvalidSQLException(message: String) : RuntimeException(message)
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinBaseBuilders.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinBaseBuilders.kt
@@ -180,74 +180,74 @@ abstract class KotlinBaseJoiningBuilder<D : AbstractQueryExpressionDSL<*, *>> :
 
     fun join(table: SqlTable, joinCriteria: JoinReceiver): Unit =
         applyToDsl(joinCriteria) { jc ->
-            join(table, jc.onJoinCriterion, jc.andJoinCriteria)
+            join(table, jc.onJoinCriterion(), jc.andJoinCriteria)
         }
 
     fun join(table: SqlTable, alias: String, joinCriteria: JoinReceiver): Unit =
         applyToDsl(joinCriteria) { jc ->
-            join(table, alias, jc.onJoinCriterion, jc.andJoinCriteria)
+            join(table, alias, jc.onJoinCriterion(), jc.andJoinCriteria)
         }
 
     fun join(
         subQuery: KotlinQualifiedSubQueryBuilder.() -> Unit,
         joinCriteria: JoinReceiver
     ): Unit =
         applyToDsl(subQuery, joinCriteria) { sq, jc ->
-            join(sq, sq.correlationName, jc.onJoinCriterion, jc.andJoinCriteria)
+            join(sq, sq.correlationName, jc.onJoinCriterion(), jc.andJoinCriteria)
         }
 
     fun fullJoin(table: SqlTable, joinCriteria: JoinReceiver): Unit =
         applyToDsl(joinCriteria) { jc ->
-            fullJoin(table, jc.onJoinCriterion, jc.andJoinCriteria)
+            fullJoin(table, jc.onJoinCriterion(), jc.andJoinCriteria)
         }
 
     fun fullJoin(table: SqlTable, alias: String, joinCriteria: JoinReceiver): Unit =
         applyToDsl(joinCriteria) { jc ->
-            fullJoin(table, alias, jc.onJoinCriterion, jc.andJoinCriteria)
+            fullJoin(table, alias, jc.onJoinCriterion(), jc.andJoinCriteria)
         }
 
     fun fullJoin(
         subQuery: KotlinQualifiedSubQueryBuilder.() -> Unit,
         joinCriteria: JoinReceiver
     ): Unit =
         applyToDsl(subQuery, joinCriteria) { sq, jc ->
-            fullJoin(sq, sq.correlationName, jc.onJoinCriterion, jc.andJoinCriteria)
+            fullJoin(sq, sq.correlationName, jc.onJoinCriterion(), jc.andJoinCriteria)
         }
 
     fun leftJoin(table: SqlTable, joinCriteria: JoinReceiver): Unit =
         applyToDsl(joinCriteria) { jc ->
-            leftJoin(table, jc.onJoinCriterion, jc.andJoinCriteria)
+            leftJoin(table, jc.onJoinCriterion(), jc.andJoinCriteria)
         }
 
     fun leftJoin(table: SqlTable, alias: String, joinCriteria: JoinReceiver): Unit =
         applyToDsl(joinCriteria) { jc ->
-            leftJoin(table, alias, jc.onJoinCriterion, jc.andJoinCriteria)
+            leftJoin(table, alias, jc.onJoinCriterion(), jc.andJoinCriteria)
         }
 
     fun leftJoin(
         subQuery: KotlinQualifiedSubQueryBuilder.() -> Unit,
         joinCriteria: JoinReceiver
     ): Unit =
         applyToDsl(subQuery, joinCriteria) { sq, jc ->
-            leftJoin(sq, sq.correlationName, jc.onJoinCriterion, jc.andJoinCriteria)
+            leftJoin(sq, sq.correlationName, jc.onJoinCriterion(), jc.andJoinCriteria)
         }
 
     fun rightJoin(table: SqlTable, joinCriteria: JoinReceiver): Unit =
         applyToDsl(joinCriteria) { jc ->
-            rightJoin(table, jc.onJoinCriterion, jc.andJoinCriteria)
+            rightJoin(table, jc.onJoinCriterion(), jc.andJoinCriteria)
         }
 
     fun rightJoin(table: SqlTable, alias: String, joinCriteria: JoinReceiver): Unit =
         applyToDsl(joinCriteria) { jc ->
-            rightJoin(table, alias, jc.onJoinCriterion, jc.andJoinCriteria)
+            rightJoin(table, alias, jc.onJoinCriterion(), jc.andJoinCriteria)
         }
 
     fun rightJoin(
         subQuery: KotlinQualifiedSubQueryBuilder.() -> Unit,
         joinCriteria: JoinReceiver
     ): Unit =
         applyToDsl(subQuery, joinCriteria) { sq, jc ->
-            rightJoin(sq, sq.correlationName, jc.onJoinCriterion, jc.andJoinCriteria)
+            rightJoin(sq, sq.correlationName, jc.onJoinCriterion(), jc.andJoinCriteria)
         }
 
     private fun applyToDsl(joinCriteria: JoinReceiver, applyJoin: D.(JoinCollector) -> Unit) {
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinBatchInsertBuilder.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinBatchInsertBuilder.kt
@@ -38,10 +38,14 @@ class KotlinBatchInsertBuilder<T> (private val rows: Collection<T>): Buildable<B
     }
 
     override fun build(): BatchInsertModel<T> =
-        with(BatchInsertDSL.Builder<T>()) {
-            withRecords(rows)
-            withTable(table)
-            withColumnMappings(columnMappings)
-            build()
-        }.build()
+        if (table == null) {
+            throw KInvalidSQLException("Batch Insert Statements Must Contain an \"into\" phrase.")
+        } else {
+            with(BatchInsertDSL.Builder<T>()) {
+                withRecords(rows)
+                withTable(table)
+                withColumnMappings(columnMappings)
+                build()
+            }.build()
+        }
 }
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinCountBuilder.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinCountBuilder.kt
@@ -26,7 +26,7 @@ class KotlinCountBuilder(private val fromGatherer: CountDSL.FromGatherer<SelectM
     KotlinBaseJoiningBuilder<CountDSL<SelectModel>>(),
     Buildable<SelectModel> {
 
-    private lateinit var dsl: CountDSL<SelectModel>
+    private var dsl: CountDSL<SelectModel>? = null
 
     fun from(table: SqlTable): KotlinCountBuilder =
         apply {
@@ -35,13 +35,7 @@ class KotlinCountBuilder(private val fromGatherer: CountDSL.FromGatherer<SelectM
 
     override fun build(): SelectModel = getDsl().build()
 
-    override fun getDsl(): CountDSL<SelectModel> {
-        try {
-            return dsl
-        } catch (e: UninitializedPropertyAccessException) {
-            throw UninitializedPropertyAccessException(
-                "You must specify a \"from\" clause before any other clauses in a count statement", e
-            )
-        }
-    }
+    override fun getDsl(): CountDSL<SelectModel> =
+        dsl?: throw KInvalidSQLException(
+            "You must specify a \"from\" clause before any other clauses in a count statement")
 }
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinInsertBuilder.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinInsertBuilder.kt
@@ -30,18 +30,22 @@ class KotlinInsertBuilder<T> (private val row: T): Buildable<InsertModel<T>> {
     private val columnMappings = mutableListOf<AbstractColumnMapping>()
 
     fun into(table: SqlTable) {
-        this.table = table;
+        this.table = table
     }
 
     fun <C : Any> map(column: SqlColumn<C>) = SingleRowInsertColumnMapCompleter(column) {
         columnMappings.add(it)
     }
 
     override fun build(): InsertModel<T> =
-        with(InsertDSL.Builder<T>()) {
-            withRow(row)
-            withTable(table)
-            withColumnMappings(columnMappings)
-            build()
-        }.build()
+        if (table == null) {
+            throw KInvalidSQLException("Insert Statements Must Contain an \"into\" phrase.")
+        } else {
+            with(InsertDSL.Builder<T>()) {
+                withRow(row)
+                withTable(table)
+                withColumnMappings(columnMappings)
+                build()
+            }.build()
+        }
 }
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinMultiRowInsertBuilder.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinMultiRowInsertBuilder.kt
@@ -38,10 +38,14 @@ class KotlinMultiRowInsertBuilder<T> (private val rows: Collection<T>): Buildabl
     }
 
     override fun build(): MultiRowInsertModel<T> =
-        with(MultiRowInsertDSL.Builder<T>()) {
-            withRecords(rows)
-            withTable(table)
-            withColumnMappings(columnMappings)
-            build()
-        }.build()
+        if (table == null) {
+            throw KInvalidSQLException("Multi Row Insert Statements Must Contain an \"into\" phrase.")
+        } else {
+            with(MultiRowInsertDSL.Builder<T>()) {
+                withRecords(rows)
+                withTable(table)
+                withColumnMappings(columnMappings)
+                build()
+            }.build()
+        }
 }
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinSelectBuilder.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinSelectBuilder.kt
@@ -28,7 +28,7 @@ typealias SelectCompleter = KotlinSelectBuilder.() -> Unit
 class KotlinSelectBuilder(private val fromGatherer: QueryExpressionDSL.FromGatherer<SelectModel>) :
     KotlinBaseJoiningBuilder<QueryExpressionDSL<SelectModel>>(), Buildable<SelectModel> {
 
-    private lateinit var dsl: QueryExpressionDSL<SelectModel>
+    private var dsl: QueryExpressionDSL<SelectModel>? = null
 
     fun from(table: SqlTable) {
         dsl = fromGatherer.from(table)
@@ -72,13 +72,7 @@ class KotlinSelectBuilder(private val fromGatherer: QueryExpressionDSL.FromGathe
     override fun build(): SelectModel = getDsl().build()
 
     override fun getDsl(): QueryExpressionDSL<SelectModel> {
-        try {
-            return dsl
-        } catch (e: UninitializedPropertyAccessException) {
-            throw UninitializedPropertyAccessException(
-                "You must specify a \"from\" clause before any other clauses in a select statement",
-                e
-            )
-        }
+        return dsl?: throw KInvalidSQLException(
+            "You must specify a \"from\" clause before any other clauses in a select statement")
     }
 }
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinSubQueryBuilders.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinSubQueryBuilders.kt
@@ -23,7 +23,7 @@ import org.mybatis.dynamic.sql.util.Buildable
 
 @MyBatisDslMarker
 sealed class KotlinBaseSubQueryBuilder : Buildable<SelectModel> {
-    private lateinit var selectBuilder: KotlinSelectBuilder
+    private var selectBuilder: KotlinSelectBuilder? = null
 
     fun select(vararg selectList: BasicColumn, completer: SelectCompleter): Unit =
         select(selectList.toList(), completer)
@@ -40,13 +40,7 @@ sealed class KotlinBaseSubQueryBuilder : Buildable<SelectModel> {
     }
 
     override fun build(): SelectModel =
-        try {
-            selectBuilder.build()
-        } catch (e: UninitializedPropertyAccessException) {
-            throw UninitializedPropertyAccessException(
-                "You must specify a select statement", e
-            )
-        }
+        selectBuilder?.build()?: throw KInvalidSQLException("You must specify a select statement in a sub query")
 }
 
 class KotlinSubQueryBuilder : KotlinBaseSubQueryBuilder()
@@ -62,21 +56,14 @@ class KotlinQualifiedSubQueryBuilder : KotlinBaseSubQueryBuilder() {
 typealias InsertSelectCompleter = KotlinInsertSelectSubQueryBuilder.() -> Unit
 
 class KotlinInsertSelectSubQueryBuilder : KotlinBaseSubQueryBuilder() {
-    private lateinit var lateColumnList: List<SqlColumn<*>>
+    private var columnList: List<SqlColumn<*>>? = null
 
-    val columnList: List<SqlColumn<*>>
-        get(): List<SqlColumn<*>> =
-            try {
-                lateColumnList
-            } catch (e: UninitializedPropertyAccessException) {
-                throw UninitializedPropertyAccessException(
-                    "You must specify a column list in an insert with select statement", e
-                )
-            }
+    internal fun columnList(): List<SqlColumn<*>> =
+        columnList?: throw KInvalidSQLException("You must specify a column list in an insert select statement")
 
     fun columns(vararg columnList: SqlColumn<*>): Unit = columns(columnList.asList())
 
     fun columns(columnList: List<SqlColumn<*>>) {
-        this.lateColumnList = columnList
+        this.columnList = columnList
     }
 }
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/model/ModelBuilderFunctions.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/model/ModelBuilderFunctions.kt
@@ -77,7 +77,7 @@ fun <T> insertMultiple(rows: Collection<T>, completer: KotlinMultiRowInsertCompl
 fun insertSelect(table: SqlTable, completer: InsertSelectCompleter): InsertSelectModel =
     with(KotlinInsertSelectSubQueryBuilder().apply(completer)) {
         SqlBuilder.insertInto(table)
-            .withColumnList(columnList)
+            .withColumnList(columnList())
             .withSelectStatement(this)
             .build()
     }
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/general/GeneralKotlinTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/general/GeneralKotlinTest.kt
@@ -41,6 +41,7 @@ import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatExceptionOfType
 import org.junit.jupiter.api.Test
+import org.mybatis.dynamic.sql.util.kotlin.KInvalidSQLException
 import org.mybatis.dynamic.sql.util.kotlin.elements.`as`
 import org.mybatis.dynamic.sql.util.kotlin.elements.count
 import org.mybatis.dynamic.sql.util.kotlin.elements.insert
@@ -656,7 +657,7 @@ class GeneralKotlinTest {
 
     @Test
     fun testRawSelectWithoutFrom() {
-        assertThatExceptionOfType(UninitializedPropertyAccessException::class.java).isThrownBy {
+        assertThatExceptionOfType(KInvalidSQLException::class.java).isThrownBy {
             select(id `as` "A_ID", firstName, lastName, birthDate, employed, occupation, addressId) {
                 where { id isEqualTo 5 }
                 or {
@@ -674,7 +675,7 @@ class GeneralKotlinTest {
 
     @Test
     fun testRawCountWithoutFrom() {
-        assertThatExceptionOfType(UninitializedPropertyAccessException::class.java).isThrownBy {
+        assertThatExceptionOfType(KInvalidSQLException::class.java).isThrownBy {
             count(id) {
                 where { id isEqualTo 5 }
                 or {
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/joins/JoinMapperTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/joins/JoinMapperTest.kt
@@ -28,14 +28,17 @@ 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.assertj.core.api.Assertions.assertThatExceptionOfType
 import org.assertj.core.api.Assertions.entry
 import org.junit.jupiter.api.Test
+import org.mybatis.dynamic.sql.util.kotlin.KInvalidSQLException
 import org.mybatis.dynamic.sql.util.kotlin.elements.equalTo
 import org.mybatis.dynamic.sql.util.kotlin.elements.qualifiedWith
 import org.mybatis.dynamic.sql.util.kotlin.mybatis3.select
 import java.io.InputStreamReader
 import java.sql.DriverManager
 
+@Suppress("LargeClass")
 class JoinMapperTest {
 
     private fun newSession(): SqlSession {
@@ -755,6 +758,22 @@ class JoinMapperTest {
         }
     }
 
+    @Test
+    fun testJoinWithNoOnCondition() {
+        // create second table instance for self-join
+        val user2 = user.withAlias("other_user")
+
+        assertThatExceptionOfType(KInvalidSQLException::class.java).isThrownBy {
+            select(user.userId, user.userName, user.parentId) {
+                from(user, "u1")
+                join(user2, "u2") {
+                    and(user.userId) equalTo user2.parentId
+                }
+                where { user2.userId isEqualTo 4 }
+            }
+        }.withMessage("You must specify an \"on\" condition in a join")
+    }
+
     companion object {
         const val JDBC_URL = "jdbc:hsqldb:mem:aname"
         const val JDBC_DRIVER = "org.hsqldb.jdbcDriver"
diff --git a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt
diff --git a/src/test/kotlin/examples/kotlin/spring/canonical/InfixElementsTest.kt b/src/test/kotlin/examples/kotlin/spring/canonical/InfixElementsTest.kt

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,8 @@ class GroupingCriteriaCollector {`
`47`	`47`	`internal var initialCriterion: SqlCriterion? = null`
`48`	`48`	`private set(value) {`
`49`	`49`	`if (field != null) {`
`50`		`- throw DuplicateInitialCriterionException()`
	`50`	`+ throw KInvalidSQLException("Setting more than one initial criterion is not allowed. " +`
	`51`	`+ "Additional criteria should be added with \"and\" or \"or\" expression")`
`51`	`52`	`}`
`52`	`53`	`field = value`
`53`	`54`	`}`