refactor bulkInsert

Author: vincentlauvlwj

…support/postgresql/BulkInsertOrUpdate.kt …g/ktorm/support/postgresql/BulkInsert.ktktorm-support-postgresql/src/main/kotlin/org/ktorm/support/postgresql/BulkInsertOrUpdate.kt renamed to ktorm-support-postgresql/src/main/kotlin/org/ktorm/support/postgresql/BulkInsert.kt ktorm-support-postgresql/src/main/kotlin/org/ktorm/support/postgresql/BulkInsertOrUpdate.kt renamed to ktorm-support-postgresql/src/main/kotlin/org/ktorm/support/postgresql/BulkInsert.kt

@@ -25,23 +25,22 @@ import org.ktorm.expression.ColumnExpression
 import org.ktorm.expression.SqlExpression
 import org.ktorm.expression.TableExpression
 import org.ktorm.schema.BaseTable
-import org.ktorm.schema.Column
 
 /**
  * Bulk insert expression, represents a bulk insert statement in PostgreSQL.
  *
- * For example: `insert into table (column1, column2) values (?, ?), (?, ?), (?, ?)... ON
- * CONFLICT (...) DO NOTHING/UPDATE SET ...`.
+ * For example: 
+ * `insert into table (column1, column2) values (?, ?), (?, ?), (?, ?)... on conflict (...) do update set ...`.
  *
  * @property table the table to be inserted.
  * @property assignments column assignments of the bulk insert statement.
- * @property conflictTarget the index columns on which the conflict may happens.
+ * @property conflictColumns the index columns on which the conflict may happens.
  * @property updateAssignments the updated column assignments while key conflict exists.
  */
 public data class BulkInsertExpression(
     val table: TableExpression,
     val assignments: List<List<ColumnAssignmentExpression<*>>>,
-    val conflictTarget: List<ColumnExpression<*>>,
+    val conflictColumns: List<ColumnExpression<*>> = emptyList(),
     val updateAssignments: List<ColumnAssignmentExpression<*>> = emptyList(),
     override val isLeafNode: Boolean = false,
     override val extraProperties: Map<String, Any> = emptyMap()
@@ -55,55 +54,42 @@ public data class BulkInsertExpression(
  * special SQL using PostgreSQL's bulk insert syntax, instead of based on JDBC batch operations.
  * For this reason, its performance is much better than [batchInsert].
  *
- * The generated SQL is like: `insert into table (column1, column2) values (?, ?), (?, ?), (?, ?)... ON
- * CONFLICT (...) DO NOTHING/UPDATE SET ...`.
+ * The generated SQL is like: `insert into table (column1, column2) values (?, ?), (?, ?), (?, ?)...`.
  *
  * Usage:
  *
  * ```kotlin
- *      database.bulkInsert(Employees) {
- *          item {
- *              set(it.id, 1)
- *              set(it.name, "vince")
- *              set(it.job, "engineer")
- *              set(it.salary, 1000)
- *              set(it.hireDate, LocalDate.now())
- *              set(it.departmentId, 1)
- *          }
- *          item {
- *              set(it.id, 5)
- *              set(it.name, "vince")
- *              set(it.job, "engineer")
- *              set(it.salary, 1000)
- *              set(it.hireDate, LocalDate.now())
- *              set(it.departmentId, 1)
- *          }
- *
- *          onDuplicateKey(Employees.id) {
- *              // Or leave this empty to simply ignore without updating (do nothing)
- *              set(it.salary, it.salary + 900)
- *          }
- *      }
+ * database.bulkInsert(Employees) {
+ *     item {
+ *         set(it.id, 1)
+ *         set(it.name, "vince")
+ *         set(it.job, "engineer")
+ *         set(it.salary, 1000)
+ *         set(it.hireDate, LocalDate.now())
+ *         set(it.departmentId, 1)
+ *     }
+ *     item {
+ *         set(it.id, 5)
+ *         set(it.name, "vince")
+ *         set(it.job, "engineer")
+ *         set(it.salary, 1000)
+ *         set(it.hireDate, LocalDate.now())
+ *         set(it.departmentId, 1)
+ *     }
+ * }
  * ```
  *
  * @since 3.3.0
  * @param table the table to be inserted.
- * @param block the DSL block, extension function of [BulkInsertStatementBuilder],
- * used to construct the expression.
+ * @param block the DSL block, extension function of [BulkInsertStatementBuilder], used to construct the expression.
  * @return the effected row count.
  * @see batchInsert
  */
-public fun <T : BaseTable<*>> Database.bulkInsert(
-    table: T,
-    block: BulkInsertStatementBuilder<T>.() -> Unit
-): Int {
+public fun <T : BaseTable<*>> Database.bulkInsert(table: T, block: BulkInsertStatementBuilder<T>.() -> Unit): Int {
     val builder = BulkInsertStatementBuilder(table).apply(block)
 
-    val expression = BulkInsertExpression(
-        table = table.asExpression(),
-        assignments = builder.assignments,
-        conflictTarget = builder.conflictColumns.map { it.asExpression() },
-        updateAssignments = builder.updateAssignments
+    val expression = AliasRemover.visit(
+        BulkInsertExpression(table.asExpression(), builder.assignments)
     )
 
     return executeUpdate(expression)
@@ -115,8 +101,6 @@ public fun <T : BaseTable<*>> Database.bulkInsert(
 @KtormDsl
 public class BulkInsertStatementBuilder<T : BaseTable<*>>(internal val table: T) {
     internal val assignments = ArrayList<List<ColumnAssignmentExpression<*>>>()
-    internal val conflictColumns = ArrayList<Column<*>>()
-    internal val updateAssignments = ArrayList<ColumnAssignmentExpression<*>>()
 
     /**
      * Add the assignments of a new row to the bulk insert.
@@ -133,15 +117,4 @@ public class BulkInsertStatementBuilder<T : BaseTable<*>>(internal val table: T)
             throw IllegalArgumentException("Every item in a batch operation must be the same.")
         }
     }
-
-    /**
-     * Specify the update assignments while any key conflict exists.
-     */
-    public fun onDuplicateKey(vararg columns: Column<*>, block: AssignmentsBuilder.(T) -> Unit) {
-        val builder = PostgreSqlAssignmentsBuilder()
-        builder.block(table)
-
-        updateAssignments += builder.assignments
-        conflictColumns += columns
-    }
 }

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

@@ -90,11 +90,13 @@ public fun <T : BaseTable<*>> Database.insertOrUpdate(
         throw IllegalStateException(msg)
     }
 
-    val expression = InsertOrUpdateExpression(
-        table = table.asExpression(),
-        assignments = builder.assignments,
-        conflictTarget = builder.conflictColumns.ifEmpty { primaryKeys }.map { it.asExpression() },
-        updateAssignments = builder.updateAssignments
+    val expression = AliasRemover.visit(
+        InsertOrUpdateExpression(
+            table = table.asExpression(),
+            assignments = builder.assignments,
+            conflictTarget = builder.conflictColumns.ifEmpty { primaryKeys }.map { it.asExpression() },
+            updateAssignments = builder.updateAssignments
+        )
     )
 
     return executeUpdate(expression)
@@ -129,3 +131,25 @@ public class InsertOrUpdateStatementBuilder : PostgreSqlAssignmentsBuilder() {
         conflictColumns += columns
     }
 }
+
+/**
+ * [PostgreSqlExpressionVisitor] implementation used to removed table aliases, used by Ktorm internal.
+ */
+internal object AliasRemover : PostgreSqlExpressionVisitor() {
+
+    override fun visitTable(expr: TableExpression): TableExpression {
+        if (expr.tableAlias == null) {
+            return expr
+        } else {
+            return expr.copy(tableAlias = null)
+        }
+    }
+
+    override fun <T : Any> visitColumn(expr: ColumnExpression<T>): ColumnExpression<T> {
+        if (expr.table == null) {
+            return expr
+        } else {
+            return expr.copy(table = null)
+        }
+    }
+}