support excluded table for bulk insert

Author: vincentlauvlwj

ktorm-core/src/main/kotlin/org/ktorm/expression/SqlExpressions.kt

@@ -332,7 +332,7 @@ public data class ColumnExpression<T : Any>(
     val table: TableExpression?,
     val name: String,
     override val sqlType: SqlType<T>,
-    override val isLeafNode: Boolean = true,
+    override val isLeafNode: Boolean = false,
     override val extraProperties: Map<String, Any> = emptyMap()
 ) : ScalarExpression<T>()
 

ktorm-core/src/main/kotlin/org/ktorm/expression/SqlFormatter.kt

@@ -176,6 +176,7 @@ public abstract class SqlFormatter(
 
     protected val SqlExpression.removeBrackets: Boolean get() {
         return isLeafNode
+            || this is ColumnExpression<*>
             || this is FunctionExpression<*>
             || this is AggregateExpression<*>
             || this is ExistsExpression

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

@@ -25,7 +25,7 @@ import org.ktorm.expression.FunctionExpression
 import org.ktorm.expression.SqlExpression
 import org.ktorm.expression.TableExpression
 import org.ktorm.schema.BaseTable
-import org.ktorm.schema.ColumnDeclaring
+import org.ktorm.schema.Column
 
 /**
  * Bulk insert expression, represents a bulk insert statement in MySQL.
@@ -127,20 +127,20 @@ public class BulkInsertStatementBuilder<T : BaseTable<*>>(internal val table: T)
 }
 
 /**
- * DSL builder for bulk insert assignments.
+ * DSL builder for bulk insert on duplicate key clause.
  */
 @KtormDsl
 public class BulkInsertOnDuplicateKeyClauseBuilder : MySqlAssignmentsBuilder() {
 
     /**
      * Use VALUES() function in a ON DUPLICATE KEY UPDATE clause.
      */
-    public fun <T : Any> values(expr: ColumnDeclaring<T>): FunctionExpression<T> {
-        // values(expr)
+    public fun <T : Any> values(column: Column<T>): FunctionExpression<T> {
+        // values(column)
         return FunctionExpression(
             functionName = "values",
-            arguments = listOf(expr.asExpression()),
-            sqlType = expr.sqlType
+            arguments = listOf(column.asExpression()),
+            sqlType = column.sqlType
         )
     }
 }

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

@@ -195,9 +195,28 @@ public class BulkInsertOrUpdateStatementBuilder<T : BaseTable<*>>(table: T) : Bu
     /**
      * Specify the update assignments while any key conflict exists.
      */
-    public fun onConflict(vararg columns: Column<*>, block: AssignmentsBuilder.() -> Unit) {
-        val builder = PostgreSqlAssignmentsBuilder().apply(block)
+    public fun onConflict(vararg columns: Column<*>, block: BulkInsertOrUpdateOnConflictClauseBuilder.() -> Unit) {
+        val builder = BulkInsertOrUpdateOnConflictClauseBuilder().apply(block)
         updateAssignments += builder.assignments
         conflictColumns += columns
     }
 }
+
+/**
+ * DSL builder for bulk insert or update on conflict clause.
+ */
+@KtormDsl
+public class BulkInsertOrUpdateOnConflictClauseBuilder : PostgreSqlAssignmentsBuilder() {
+
+    /**
+     * Reference the 'EXCLUDED' table in a ON CONFLICT clause.
+     */
+    public fun <T : Any> excluded(column: Column<T>): ColumnExpression<T> {
+        // excluded.name
+        return ColumnExpression(
+            table = TableExpression(name = "excluded"),
+            name = column.name,
+            sqlType = column.sqlType
+        )
+    }
+}

ktorm-support-postgresql/src/test/kotlin/org/ktorm/support/postgresql/PostgreSqlTest.kt

@@ -167,7 +167,7 @@ class PostgreSqlTest : BaseTest() {
             item {
                 set(it.id, 1)
                 set(it.name, "vince")
-                set(it.job, "engineer")
+                set(it.job, "trainee")
                 set(it.salary, 1000)
                 set(it.hireDate, LocalDate.now())
                 set(it.departmentId, 1)
@@ -181,12 +181,23 @@ class PostgreSqlTest : BaseTest() {
                 set(it.departmentId, 1)
             }
             onConflict(it.id) {
+                set(it.job, it.job)
+                set(it.hireDate, excluded(it.hireDate))
                 set(it.salary, it.salary + 1000)
             }
         }
 
-        assert(database.employees.find { it.id eq 1 }!!.salary == 1100L)
-        assert(database.employees.find { it.id eq 5 }!!.salary == 1000L)
+        database.employees.find { it.id eq 1 }!!.let {
+            assert(it.job == "engineer")
+            assert(it.hireDate == LocalDate.now())
+            assert(it.salary == 1100L)
+        }
+
+        database.employees.find { it.id eq 5 }!!.let {
+            assert(it.job == "engineer")
+            assert(it.hireDate == LocalDate.now())
+            assert(it.salary == 1000L)
+        }
     }
 
     @Test