feat: allow expressions in unique constraint (#1518)

Co-authored-by: Eric So <[email protected]>
Co-authored-by: Igal Klebanov <[email protected]>

Author: ericsodev

src/operation-node/unique-constraint-node.ts

@@ -1,11 +1,12 @@
-import { freeze } from '../util/object-utils.js'
+import { logOnce } from '../util/log-once.js'
+import { freeze, isString } from '../util/object-utils.js'
 import { ColumnNode } from './column-node.js'
 import { IdentifierNode } from './identifier-node.js'
 import { OperationNode } from './operation-node.js'
 
 export interface UniqueConstraintNode extends OperationNode {
   readonly kind: 'UniqueConstraintNode'
-  readonly columns: ReadonlyArray<ColumnNode>
+  readonly columns: ReadonlyArray<OperationNode>
   readonly name?: IdentifierNode
   readonly nullsNotDistinct?: boolean
   readonly deferrable?: boolean
@@ -18,21 +19,56 @@ export type UniqueConstraintNodeProps = Omit<
 >
 
 /**
+ * TODO: remove this interface once support for `string[]` is removed.
+ *
  * @internal
  */
-export const UniqueConstraintNode = freeze({
+interface UniqueConstraintNodeFactory {
+  is(node: OperationNode): node is UniqueConstraintNode
+  create(
+    columns: OperationNode[],
+    constraintName?: string,
+    nullsNotDistinct?: boolean,
+  ): UniqueConstraintNode
+  /**
+   * @deprecated pass `ColumnNode[]` instead of strings.
+   */
+  create(
+    columns: string[],
+    constraintName?: string,
+    nullsNotDistinct?: boolean,
+  ): UniqueConstraintNode
+  cloneWith(
+    node: UniqueConstraintNode,
+    props: UniqueConstraintNodeProps,
+  ): UniqueConstraintNode
+}
+
+/**
+ * @internal
+ */
+export const UniqueConstraintNode: UniqueConstraintNodeFactory = freeze({
   is(node: OperationNode): node is UniqueConstraintNode {
     return node.kind === 'UniqueConstraintNode'
   },
 
   create(
-    columns: string[],
+    columns: string[] | OperationNode[],
     constraintName?: string,
     nullsNotDistinct?: boolean,
   ): UniqueConstraintNode {
+    // TODO: remove this block when support for `string[]` is removed.
+    if (isString(columns.at(0))) {
+      logOnce(
+        '`UniqueConstraintNode.create(columns: string[], ...)` is deprecated - pass `ColumnNode[]` instead.',
+      )
+
+      columns = (columns as string[]).map(ColumnNode.create)
+    }
+
     return freeze({
       kind: 'UniqueConstraintNode',
-      columns: freeze(columns.map(ColumnNode.create)),
+      columns: freeze(columns) as OperationNode[],
       name: constraintName ? IdentifierNode.create(constraintName) : undefined,
       nullsNotDistinct,
     })
@@ -42,9 +78,6 @@ export const UniqueConstraintNode = freeze({
     node: UniqueConstraintNode,
     props: UniqueConstraintNodeProps,
   ): UniqueConstraintNode {
-    return freeze({
-      ...node,
-      ...props,
-    })
+    return freeze({ ...node, ...props })
   },
 })

src/schema/alter-table-builder.ts

@@ -7,7 +7,7 @@ import { OperationNodeSource } from '../operation-node/operation-node-source.js'
 import { RenameColumnNode } from '../operation-node/rename-column-node.js'
 import { CompiledQuery } from '../query-compiler/compiled-query.js'
 import { Compilable } from '../util/compilable.js'
-import { freeze, noop } from '../util/object-utils.js'
+import { freeze, isString, noop } from '../util/object-utils.js'
 import {
   ColumnDefinitionBuilder,
   ColumnDefinitionBuilderCallback,
@@ -55,6 +55,10 @@ import {
   CheckConstraintBuilderCallback,
 } from './check-constraint-builder.js'
 import { RenameConstraintNode } from '../operation-node/rename-constraint-node.js'
+import {
+  ExpressionOrFactory,
+  parseExpression,
+} from '../parser/expression-parser.js'
 
 /**
  * This builder can be used to create a `alter table` query.
@@ -173,12 +177,19 @@ export class AlterTableBuilder implements ColumnAlteringInterface {
    */
   addUniqueConstraint(
     constraintName: string,
-    columns: string[],
+    columns: (string | ExpressionOrFactory<any, any, any>)[],
     build: UniqueConstraintNodeBuilderCallback = noop,
   ): AlterTableExecutor {
     const uniqueConstraintBuilder = build(
       new UniqueConstraintNodeBuilder(
-        UniqueConstraintNode.create(columns, constraintName),
+        UniqueConstraintNode.create(
+          columns.map((column) =>
+            isString(column)
+              ? ColumnNode.create(column)
+              : parseExpression(column),
+          ),
+          constraintName,
+        ),
       ),
     )
 

src/schema/create-table-builder.ts

@@ -9,7 +9,7 @@ import { Compilable } from '../util/compilable.js'
 import { QueryExecutor } from '../query-executor/query-executor.js'
 import { ColumnDefinitionBuilder } from './column-definition-builder.js'
 import { QueryId } from '../util/query-id.js'
-import { freeze, noop } from '../util/object-utils.js'
+import { freeze, isString, noop } from '../util/object-utils.js'
 import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node.js'
 import { ColumnNode } from '../operation-node/column-node.js'
 import {
@@ -30,7 +30,10 @@ import {
   UniqueConstraintNodeBuilder,
   UniqueConstraintNodeBuilderCallback,
 } from './unique-constraint-builder.js'
-import { parseExpression } from '../parser/expression-parser.js'
+import {
+  ExpressionOrFactory,
+  parseExpression,
+} from '../parser/expression-parser.js'
 import {
   PrimaryKeyConstraintBuilder,
   PrimaryKeyConstraintBuilderCallback,
@@ -243,15 +246,39 @@ export class CreateTableBuilder<TB extends string, C extends string = never>
    *   )
    *   .execute()
    * ```
+   *
+   * In dialects such as MySQL you create unique constraints on expressions as follows:
+   *
+   * ```ts
+   *
+   * import { sql } from 'kysely'
+   *
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('first_name', 'varchar(64)')
+   *   .addColumn('last_name', 'varchar(64)')
+   *   .addUniqueConstraint(
+   *     'first_name_last_name_unique',
+   *     [sql`(lower('first_name'))`, 'last_name']
+   *   )
+   *   .execute()
+   * ```
    */
   addUniqueConstraint(
     constraintName: string,
-    columns: C[],
+    columns: (C | ExpressionOrFactory<any, any, any>)[],
     build: UniqueConstraintNodeBuilderCallback = noop,
   ): CreateTableBuilder<TB, C> {
     const uniqueConstraintBuilder = build(
       new UniqueConstraintNodeBuilder(
-        UniqueConstraintNode.create(columns, constraintName),
+        UniqueConstraintNode.create(
+          columns.map((column) =>
+            isString(column)
+              ? ColumnNode.create(column)
+              : parseExpression(column),
+          ),
+          constraintName,
+        ),
       ),
     )
 

test/node/src/schema.test.ts

@@ -517,6 +517,33 @@ for (const dialect of DIALECTS) {
         await builder.execute()
       })
 
+      if (sqlSpec === 'mysql') {
+        it('should create a table with a unique constraints using expressions', async () => {
+          const builder = ctx.db.schema
+            .createTable('test')
+            .addColumn('a', 'varchar(255)')
+            .addColumn('b', 'varchar(255)')
+            .addColumn('c', 'varchar(255)')
+            .addUniqueConstraint('a_b_unique', [
+              sql`(lower(a))`,
+              sql`(lower(b))`,
+            ])
+            .addUniqueConstraint('a_c_unique', [sql`(lower(a))`, 'c'])
+
+          testSql(builder, dialect, {
+            postgres: NOT_SUPPORTED,
+            mysql: {
+              sql: 'create table `test` (`a` varchar(255), `b` varchar(255), `c` varchar(255), constraint `a_b_unique` unique ((lower(a)), (lower(b))), constraint `a_c_unique` unique ((lower(a)), `c`))',
+              parameters: [],
+            },
+            mssql: NOT_SUPPORTED,
+            sqlite: NOT_SUPPORTED,
+          })
+
+          await builder.execute()
+        })
+      }
+
       if (sqlSpec === 'postgres') {
         it('should create a table with a unique constraint and "nulls not distinct" option', async () => {
           const builder = ctx.db.schema
@@ -3367,6 +3394,29 @@ for (const dialect of DIALECTS) {
         })
       }
 
+      if (sqlSpec === 'mysql') {
+        it('should add a unique constraint using expressions', async () => {
+          const builder = ctx.db.schema
+            .alterTable('test')
+            .addUniqueConstraint('unique_constraint', [
+              sql`(lower(varchar_col))`,
+              'integer_col',
+            ])
+
+          testSql(builder, dialect, {
+            postgres: NOT_SUPPORTED,
+            mysql: {
+              sql: 'alter table `test` add constraint `unique_constraint` unique ((lower(varchar_col)), `integer_col`)',
+              parameters: [],
+            },
+            mssql: NOT_SUPPORTED,
+            sqlite: NOT_SUPPORTED,
+          })
+
+          await builder.execute()
+        })
+      }
+
       if (
         sqlSpec === 'postgres' ||
         sqlSpec === 'mysql' ||