Add composite foreign key

exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Column.kt

@@ -14,7 +14,7 @@ private val comparator: Comparator<Column<*>> = compareBy({ it.table.tableName }
  * Represents a column.
  */
 class Column<T>(
-    /** Table where the columns is declared. */
+    /** Table where the columns are declared. */
     val table: Table,
     /** Name of the column. */
     val name: String,
@@ -25,7 +25,7 @@ class Column<T>(
 
     /** Returns the column that this column references. */
     val referee: Column<*>?
-        get() = foreignKey?.target
+        get() = foreignKey?.targetOf(this)
 
     /** Returns the column that this column references, casted as a column of type [S], or `null` if the cast fails. */
     @Suppress("UNCHECKED_CAST")

exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Constraints.kt

@@ -51,30 +51,45 @@ enum class ReferenceOption {
  * Represents a foreign key constraint.
  */
 data class ForeignKeyConstraint(
-    val target: Column<*>,
-    val from: Column<*>,
+    val references: Map<Column<*>, Column<*>>,
     private val onUpdate: ReferenceOption?,
     private val onDelete: ReferenceOption?,
     private val name: String?
 ) : DdlAware {
+    constructor(
+        target: Column<*>,
+        from: Column<*>,
+        onUpdate: ReferenceOption?,
+        onDelete: ReferenceOption?,
+        name: String?
+    ) : this(mapOf(from to target), onUpdate, onDelete, name)
+
     private val tx: Transaction
         get() = TransactionManager.current()
 
+    val target: LinkedHashSet<Column<*>> = LinkedHashSet(references.values)
+
+    val targetTable: Table = target.first().table
+
     /** Name of the child table. */
-    val targetTable: String
-        get() = tx.identity(target.table)
+    val targetTableName: String
+        get() = tx.identity(targetTable)
+
+    /** Names of the foreign key columns. */
+    private val targetColumns: String
+        get() = target.joinToString { tx.identity(it) }
+
+    val from: LinkedHashSet<Column<*>> = LinkedHashSet(references.keys)
 
-    /** Name of the foreign key column. */
-    val targetColumn: String
-        get() = tx.identity(target)
+    val fromTable: Table = from.first().table
 
     /** Name of the parent table. */
-    val fromTable: String
-        get() = tx.identity(from.table)
+    val fromTableName: String
+        get() = tx.identity(fromTable)
 
-    /** Name of the key column from the parent table. */
-    val fromColumn
-        get() = tx.identity(from)
+    /** Names of the key columns from the parent table. */
+    private val fromColumns: String
+        get() = from.joinToString { tx.identity(it) }
 
     /** Reference option when performing update operations. */
     val updateRule: ReferenceOption?
@@ -91,27 +106,27 @@ data class ForeignKeyConstraint(
     /** Name of this constraint. */
     val fkName: String
         get() = tx.db.identifierManager.cutIfNecessaryAndQuote(
-            name ?: "fk_${from.table.tableNameWithoutScheme}_${from.name}_${target.name}"
+            name ?: "fk_${fromTable.tableNameWithoutScheme}_${from.joinToString("_") { it.name }}__${target.joinToString("_") { it.name }}"
         ).inProperCase()
     internal val foreignKeyPart: String
         get() = buildString {
             if (fkName.isNotBlank()) {
                 append("CONSTRAINT $fkName ")
             }
-            append("FOREIGN KEY ($fromColumn) REFERENCES $targetTable($targetColumn)")
+            append("FOREIGN KEY ($fromColumns) REFERENCES $targetTableName($targetColumns)")
             if (deleteRule != ReferenceOption.NO_ACTION) {
                 append(" ON DELETE $deleteRule")
             }
             if (updateRule != ReferenceOption.NO_ACTION) {
                 if (currentDialect is OracleDialect) {
-                    exposedLogger.warn("Oracle doesn't support FOREIGN KEY with ON UPDATE clause. Please check your $fromTable table.")
+                    exposedLogger.warn("Oracle doesn't support FOREIGN KEY with ON UPDATE clause. Please check your $fromTableName table.")
                 } else {
                     append(" ON UPDATE $updateRule")
                 }
             }
         }
 
-    override fun createStatement(): List<String> = listOf("ALTER TABLE $fromTable ADD $foreignKeyPart")
+    override fun createStatement(): List<String> = listOf("ALTER TABLE $fromTableName ADD $foreignKeyPart")
 
     override fun modifyStatement(): List<String> = dropStatement() + createStatement()
 
@@ -120,8 +135,16 @@ data class ForeignKeyConstraint(
             is MysqlDialect -> "FOREIGN KEY"
             else -> "CONSTRAINT"
         }
-        return listOf("ALTER TABLE $fromTable DROP $constraintType $fkName")
+        return listOf("ALTER TABLE $fromTableName DROP $constraintType $fkName")
     }
+
+    fun targetOf(from: Column<*>): Column<*>? = references[from]
+
+    operator fun plus(other: ForeignKeyConstraint): ForeignKeyConstraint {
+        return copy(references = references + other.references)
+    }
+
+    override fun toString() = "ForeignKeyConstraint(fkName='$fkName')"
 }
 
 /**

exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/SchemaUtils.kt

@@ -117,9 +117,13 @@ object SchemaUtils {
         }
     }
 
-    fun createFKey(reference: Column<*>): List<String> {
-        val foreignKey = reference.foreignKey
-        require(foreignKey != null && (foreignKey.deleteRule != null || foreignKey.updateRule != null)) { "$reference does not reference anything" }
+    fun createFKey(foreignKey: ForeignKeyConstraint): List<String> {
+        val allFromColumnsBelongsToTheSameTable = foreignKey.from.all { it.table == foreignKey.fromTable }
+        require(allFromColumnsBelongsToTheSameTable) { "not all referencing columns of $foreignKey belong to the same table " }
+        val allTargetColumnsBelongToTheSameTable = foreignKey.target.all { it.table == foreignKey.targetTable }
+        require(allTargetColumnsBelongToTheSameTable) { "not all referenced columns of $foreignKey belong to the same table " }
+        require(foreignKey.from.size == foreignKey.target.size) { "$foreignKey referencing columns are not in accordance with referenced" }
+        require(foreignKey.deleteRule != null || foreignKey.updateRule != null) { "$foreignKey has no reference constraint actions" }
         return foreignKey.createStatement()
     }
 
@@ -204,19 +208,16 @@ object SchemaUtils {
                 }
 
                 for (table in tables) {
-                    for (column in table.columns) {
-                        val foreignKey = column.foreignKey
-                        if (foreignKey != null) {
-                            val existingConstraint = existingColumnConstraint[table to column]?.firstOrNull()
-                            if (existingConstraint == null) {
-                                statements.addAll(createFKey(column))
-                            } else if (existingConstraint.target.table != foreignKey.target.table ||
-                                foreignKey.deleteRule != existingConstraint.deleteRule ||
-                                foreignKey.updateRule != existingConstraint.updateRule
-                            ) {
-                                statements.addAll(existingConstraint.dropStatement())
-                                statements.addAll(createFKey(column))
-                            }
+                    for (foreignKey in table.foreignKeys) {
+                        val existingConstraint = existingColumnConstraint[table to foreignKey.from]?.firstOrNull()
+                        if (existingConstraint == null) {
+                            statements.addAll(createFKey(foreignKey))
+                        } else if (existingConstraint.targetTable != foreignKey.targetTable ||
+                            foreignKey.deleteRule != existingConstraint.deleteRule ||
+                            foreignKey.updateRule != existingConstraint.updateRule
+                        ) {
+                            statements.addAll(existingConstraint.dropStatement())
+                            statements.addAll(createFKey(foreignKey))
                         }
                     }
                 }
@@ -352,7 +353,7 @@ object SchemaUtils {
                 val constraint = fk.first()
                 val fkPartToLog = fk.joinToString(", ") { it.fkName }
                 exposedLogger.warn(
-                    "\t\t\t'${pair.first}'.'${pair.second}' -> '${constraint.fromTable}'.'${constraint.fromColumn}':\t$fkPartToLog"
+                    "\t\t\t'${pair.first}'.'${pair.second}' -> '${constraint.fromTableName}':\t$fkPartToLog"
                 )
             }
 
@@ -397,7 +398,7 @@ object SchemaUtils {
         val fKeyConstraints = currentDialect.columnConstraints(*tables).keys
         val existingIndices = currentDialect.existingIndices(*tables)
         fun List<Index>.filterFKeys() = if (isMysql) {
-            filterNot { it.table to it.columns.singleOrNull() in fKeyConstraints }
+            filterNot { it.table to LinkedHashSet(it.columns) in fKeyConstraints }
         } else {
             this
         }

exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Table.kt

@@ -346,6 +346,11 @@ open class Table(name: String = "") : ColumnSet(), DdlAware {
     /** Returns all indices declared on the table. */
     val indices: List<Index> get() = _indices
 
+    private val _foreignKeys = mutableListOf<ForeignKeyConstraint>()
+
+    /** Returns all foreignKeys declared on the table. */
+    val foreignKeys: List<ForeignKeyConstraint> get() = columns.mapNotNull { it.foreignKey } + _foreignKeys
+
     private val checkConstraints = mutableListOf<Pair<String, Op<Boolean>>>()
 
     /**
@@ -818,7 +823,7 @@ open class Table(name: String = "") : ColumnSet(), DdlAware {
         onDelete: ReferenceOption? = null,
         onUpdate: ReferenceOption? = null,
         fkName: String? = null
-    ): Column<T?> = Column<T>(this, name, refColumn.columnType.cloneAsBaseType()).references(refColumn, onDelete, onUpdate, fkName).nullable()
+    ): Column<T?> = reference(name, refColumn, onDelete, onUpdate, fkName).nullable()
 
     /**
      * Creates a column with the specified [name] with an optional reference to the [refColumn] column with [onDelete], [onUpdate], and [fkName] options.
@@ -841,10 +846,7 @@ open class Table(name: String = "") : ColumnSet(), DdlAware {
         onDelete: ReferenceOption? = null,
         onUpdate: ReferenceOption? = null,
         fkName: String? = null
-    ): Column<E?> {
-        val entityIdColumn = entityId(name, (refColumn.columnType as EntityIDColumnType<T>).idColumn) as Column<E>
-        return entityIdColumn.references(refColumn, onDelete, onUpdate, fkName).nullable()
-    }
+    ): Column<E?> = reference(name, refColumn, onDelete, onUpdate, fkName).nullable()
 
     /**
      * Creates a column with the specified [name] with an optional reference to the `id` column in [foreign] table with [onDelete], [onUpdate], and [fkName] options.
@@ -865,7 +867,7 @@ open class Table(name: String = "") : ColumnSet(), DdlAware {
         onDelete: ReferenceOption? = null,
         onUpdate: ReferenceOption? = null,
         fkName: String? = null
-    ): Column<EntityID<T>?> = entityId(name, foreign).references(foreign.id, onDelete, onUpdate, fkName).nullable()
+    ): Column<EntityID<T>?> = reference(name, foreign, onDelete, onUpdate, fkName).nullable()
 
     // Miscellaneous
 
@@ -939,6 +941,45 @@ open class Table(name: String = "") : ColumnSet(), DdlAware {
      */
     fun uniqueIndex(customIndexName: String? = null, vararg columns: Column<*>): Unit = index(customIndexName, true, *columns)
 
+    /**
+     * Creates a composite foreign key.
+     *
+     * @param from Columns that compose the foreign key. Their order should match the order of columns in referenced primary key.
+     * @param target Primary key of the referenced table.
+     * @param onUpdate Reference option when performing update operations.
+     * @param onUpdate Reference option when performing delete operations.
+     * @param name Custom foreign key name
+     */
+    fun foreignKey(
+        vararg from: Column<*>,
+        target: PrimaryKey,
+        onUpdate: ReferenceOption? = null,
+        onDelete: ReferenceOption? = null,
+        name: String? = null
+    ) {
+        _foreignKeys.add(ForeignKeyConstraint(from.zip(target.columns).toMap(), onUpdate, onDelete, name))
+    }
+
+    /**
+     * Creates a composite foreign key.
+     *
+     * @param references Pairs of columns that compose the foreign key.
+     * First value of pair is a column of referencing table, second value - a column of a referenced one.
+     * All referencing columns must belong to this table.
+     * All referenced columns must belong to the same table.
+     * @param onUpdate Reference option when performing update operations.
+     * @param onUpdate Reference option when performing delete operations.
+     * @param name Custom foreign key name
+     */
+    fun foreignKey(
+        vararg references: Pair<Column<*>, Column<*>>,
+        onUpdate: ReferenceOption? = null,
+        onDelete: ReferenceOption? = null,
+        name: String? = null
+    ) {
+        _foreignKeys.add(ForeignKeyConstraint(references.toMap(), onUpdate, onDelete, name))
+    }
+
     // Check constraints
 
     /**
@@ -1019,7 +1060,7 @@ open class Table(name: String = "") : ColumnSet(), DdlAware {
 
         val addForeignKeysInAlterPart = SchemaUtils.checkCycle(this) && currentDialect !is SQLiteDialect
 
-        val foreignKeyConstraints = columns.mapNotNull { it.foreignKey }
+        val foreignKeyConstraints = foreignKeys
 
         val createTable = buildString {
             append("CREATE TABLE ")

exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/vendors/Default.kt

@@ -6,6 +6,8 @@ import org.jetbrains.exposed.sql.transactions.TransactionManager
 import java.nio.ByteBuffer
 import java.util.*
 import java.util.concurrent.ConcurrentHashMap
+import kotlin.collections.HashMap
+import kotlin.collections.LinkedHashSet
 
 /**
  * Provides definitions for all the supported SQL data types.
@@ -578,8 +580,8 @@ interface DatabaseDialect {
     /** Returns a map with the column metadata of all the defined columns in each of the specified [tables]. */
     fun tableColumns(vararg tables: Table): Map<Table, List<ColumnMetadata>> = emptyMap()
 
-    /** Returns a map with the foreign key constraints of all the defined columns in each of the specified [tables]. */
-    fun columnConstraints(vararg tables: Table): Map<Pair<Table, Column<*>>, List<ForeignKeyConstraint>> = emptyMap()
+    /** Returns a map with the foreign key constraints of all the defined columns sets in each of the specified [tables]. */
+    fun columnConstraints(vararg tables: Table): Map<Pair<Table, LinkedHashSet<Column<*>>>, List<ForeignKeyConstraint>> = emptyMap()
 
     /** Returns a map with all the defined indices in each of the specified [tables]. */
     fun existingIndices(vararg tables: Table): Map<Table, List<Index>> = emptyMap()
@@ -701,15 +703,15 @@ abstract class VendorDialect(
     override fun tableColumns(vararg tables: Table): Map<Table, List<ColumnMetadata>> =
         TransactionManager.current().connection.metadata { columns(*tables) }
 
-    override fun columnConstraints(vararg tables: Table): Map<Pair<Table, Column<*>>, List<ForeignKeyConstraint>> {
-        val constraints = HashMap<Pair<Table, Column<*>>, MutableList<ForeignKeyConstraint>>()
+    override fun columnConstraints(vararg tables: Table): Map<Pair<Table, LinkedHashSet<Column<*>>>, List<ForeignKeyConstraint>> {
+        val constraints = HashMap<Pair<Table, LinkedHashSet<Column<*>>>, MutableList<ForeignKeyConstraint>>()
 
         val tablesToLoad = tables.filter { !columnConstraintsCache.containsKey(it.nameInDatabaseCase()) }
 
         fillConstraintCacheForTables(tablesToLoad)
         tables.forEach { table ->
             columnConstraintsCache[table.nameInDatabaseCase()].orEmpty().forEach {
-                constraints.getOrPut(it.from.table to it.from) { arrayListOf() }.add(it)
+                constraints.getOrPut(table to it.from) { arrayListOf() }.add(it)
             }
         }
         return constraints
@@ -725,7 +727,7 @@ abstract class VendorDialect(
     protected fun String.quoteIdentifierWhenWrongCaseOrNecessary(tr: Transaction): String =
         tr.db.identifierManager.quoteIdentifierWhenWrongCaseOrNecessary(this)
 
-    protected val columnConstraintsCache: MutableMap<String, List<ForeignKeyConstraint>> = ConcurrentHashMap()
+    protected val columnConstraintsCache: MutableMap<String, Collection<ForeignKeyConstraint>> = ConcurrentHashMap()
 
     protected open fun fillConstraintCacheForTables(tables: List<Table>): Unit =
         columnConstraintsCache.putAll(TransactionManager.current().db.metadata { tableConstraints(tables) })