postgresql: check empty insert & update #457

Author: vincentlauvlwj

ktorm-support-postgresql/src/main/kotlin/org/ktorm/support/postgresql/BulkInsert.kt

@@ -16,7 +16,6 @@
 
 package org.ktorm.support.postgresql
 
-import org.ktorm.database.CachedRowSet
 import org.ktorm.database.Database
 import org.ktorm.database.asIterable
 import org.ktorm.dsl.AssignmentsBuilder
@@ -97,8 +96,7 @@ public data class BulkInsertExpression(
 public fun <T : BaseTable<*>> Database.bulkInsert(
     table: T, block: BulkInsertStatementBuilder<T>.(T) -> Unit
 ): Int {
-    val builder = BulkInsertStatementBuilder(table).apply { block(table) }
-    val expression = BulkInsertExpression(table.asExpression(), builder.assignments)
+    val expression = buildBulkInsertExpression(table, returning = emptyList(), block = block)
     return executeUpdate(expression)
 }
 
@@ -145,7 +143,8 @@ public fun <T : BaseTable<*>> Database.bulkInsert(
 public fun <T : BaseTable<*>, C : Any> Database.bulkInsertReturning(
     table: T, returning: Column<C>, block: BulkInsertStatementBuilder<T>.(T) -> Unit
 ): List<C?> {
-    val rowSet = bulkInsertReturningRowSet(table, listOf(returning), block)
+    val expression = buildBulkInsertExpression(table, listOf(returning), block)
+    val (_, rowSet) = executeUpdateAndRetrieveKeys(expression)
     return rowSet.asIterable().map { row -> returning.sqlType.getResult(row, 1) }
 }
 
@@ -193,7 +192,8 @@ public fun <T : BaseTable<*>, C1 : Any, C2 : Any> Database.bulkInsertReturning(
     table: T, returning: Pair<Column<C1>, Column<C2>>, block: BulkInsertStatementBuilder<T>.(T) -> Unit
 ): List<Pair<C1?, C2?>> {
     val (c1, c2) = returning
-    val rowSet = bulkInsertReturningRowSet(table, listOf(c1, c2), block)
+    val expression = buildBulkInsertExpression(table, listOf(c1, c2), block)
+    val (_, rowSet) = executeUpdateAndRetrieveKeys(expression)
     return rowSet.asIterable().map { row -> Pair(c1.sqlType.getResult(row, 1), c2.sqlType.getResult(row, 2)) }
 }
 
@@ -241,7 +241,8 @@ public fun <T : BaseTable<*>, C1 : Any, C2 : Any, C3 : Any> Database.bulkInsertR
     table: T, returning: Triple<Column<C1>, Column<C2>, Column<C3>>, block: BulkInsertStatementBuilder<T>.(T) -> Unit
 ): List<Triple<C1?, C2?, C3?>> {
     val (c1, c2, c3) = returning
-    val rowSet = bulkInsertReturningRowSet(table, listOf(c1, c2, c3), block)
+    val expression = buildBulkInsertExpression(table, listOf(c1, c2, c3), block)
+    val (_, rowSet) = executeUpdateAndRetrieveKeys(expression)
     return rowSet.asIterable().map { row ->
         Triple(c1.sqlType.getResult(row, 1), c2.sqlType.getResult(row, 2), c3.sqlType.getResult(row, 3))
     }
@@ -250,19 +251,24 @@ public fun <T : BaseTable<*>, C1 : Any, C2 : Any, C3 : Any> Database.bulkInsertR
 /**
  * Bulk insert records to the table, returning row set.
  */
-private fun <T : BaseTable<*>> Database.bulkInsertReturningRowSet(
+private fun <T : BaseTable<*>> buildBulkInsertExpression(
     table: T, returning: List<Column<*>>, block: BulkInsertStatementBuilder<T>.(T) -> Unit
-): CachedRowSet {
+): BulkInsertExpression {
     val builder = BulkInsertStatementBuilder(table).apply { block(table) }
+    if (builder.assignments.isEmpty()) {
+        throw IllegalArgumentException("There are no items in the bulk operation.")
+    }
+    for (assignments in builder.assignments) {
+        if (assignments.isEmpty()) {
+            throw IllegalArgumentException("There are no columns to insert in the statement.")
+        }
+    }
 
-    val expression = BulkInsertExpression(
+    return BulkInsertExpression(
         table = table.asExpression(),
         assignments = builder.assignments,
         returningColumns = returning.map { it.asExpression() }
     )
-
-    val (_, rowSet) = executeUpdateAndRetrieveKeys(expression)
-    return rowSet
 }
 
 /**
@@ -487,6 +493,14 @@ private fun <T : BaseTable<*>> buildBulkInsertOrUpdateExpression(
     table: T, returning: List<Column<*>>, block: BulkInsertOrUpdateStatementBuilder<T>.(T) -> Unit
 ): BulkInsertExpression {
     val builder = BulkInsertOrUpdateStatementBuilder(table).apply { block(table) }
+    if (builder.assignments.isEmpty()) {
+        throw IllegalArgumentException("There are no items in the bulk operation.")
+    }
+    for (assignments in builder.assignments) {
+        if (assignments.isEmpty()) {
+            throw IllegalArgumentException("There are no columns to insert in the statement.")
+        }
+    }
 
     val conflictColumns = builder.conflictColumns.ifEmpty { table.primaryKeys }
     if (conflictColumns.isEmpty()) {

ktorm-support-postgresql/src/main/kotlin/org/ktorm/support/postgresql/InsertOrUpdate.kt

@@ -258,6 +258,9 @@ private fun <T : BaseTable<*>> buildInsertOrUpdateExpression(
     table: T, returning: List<Column<*>>, block: InsertOrUpdateStatementBuilder.(T) -> Unit
 ): InsertOrUpdateExpression {
     val builder = InsertOrUpdateStatementBuilder().apply { block(table) }
+    if (builder.assignments.isEmpty()) {
+        throw IllegalArgumentException("There are no columns to insert in the statement.")
+    }
 
     val conflictColumns = builder.conflictColumns.ifEmpty { table.primaryKeys }
     if (conflictColumns.isEmpty()) {
@@ -404,6 +407,9 @@ private fun <T : BaseTable<*>> Database.insertReturningRow(
     table: T, returning: List<Column<*>>, block: AssignmentsBuilder.(T) -> Unit
 ): CachedRowSet {
     val builder = PostgreSqlAssignmentsBuilder().apply { block(table) }
+    if (builder.assignments.isEmpty()) {
+        throw IllegalArgumentException("There are no columns to insert in the statement.")
+    }
 
     val expression = InsertOrUpdateExpression(
         table = table.asExpression(),