@mikro-orm/sql 7.1.0-dev.21 → 7.1.0-dev.23

package/AbstractSqlPlatform.d.ts

@@ -50,8 +50,19 @@ export declare abstract class AbstractSqlPlatform extends Platform {
      * @internal
      */
     quoteCollation(collation: string): string;
-    /** @internal */
-    protected validateCollationName(collation: string): void;
+    /**
+     * PG ICU locale names include hyphens (`en-US-x-icu`) and libc locales include dots (`en_US.utf8`),
+     * so word-chars alone would reject valid real-world collations.
+     * @internal
+     */
+    validateCollationName(collation: string): void;
+    /**
+     * Whether collation names compare case-insensitively in this dialect. MySQL/MariaDB, MSSQL, and
+     * SQLite use case-insensitive collation identifiers; PostgreSQL stores them as case-sensitive
+     * names in `pg_collation` (e.g. `en-US-x-icu` is distinct from `EN-US-X-ICU`).
+     * @internal
+     */
+    caseInsensitiveCollationNames(): boolean;
     /** @internal */
     validateJsonPropertyName(name: string): void;
     /**

package/AbstractSqlPlatform.js

@@ -123,12 +123,25 @@ export class AbstractSqlPlatform extends Platform {
         this.validateCollationName(collation);
         return this.quoteIdentifier(collation);
     }
-    /** @internal */
+    /**
+     * PG ICU locale names include hyphens (`en-US-x-icu`) and libc locales include dots (`en_US.utf8`),
+     * so word-chars alone would reject valid real-world collations.
+     * @internal
+     */
     validateCollationName(collation) {
-        if (!/^[\w]+$/.test(collation)) {
-            throw new Error(`Invalid collation name: '${collation}'. Collation names must contain only word characters.`);
+        if (!/^[\w\-.]+$/.test(collation)) {
+            throw new Error(`Invalid collation name: '${collation}'. Collation names must contain only word characters, hyphens, and dots.`);
         }
     }
+    /**
+     * Whether collation names compare case-insensitively in this dialect. MySQL/MariaDB, MSSQL, and
+     * SQLite use case-insensitive collation identifiers; PostgreSQL stores them as case-sensitive
+     * names in `pg_collation` (e.g. `en-US-x-icu` is distinct from `EN-US-X-ICU`).
+     * @internal
+     */
+    caseInsensitiveCollationNames() {
+        return true;
+    }
     /** @internal */
     validateJsonPropertyName(name) {
         if (!AbstractSqlPlatform.#JSON_PROPERTY_NAME_RE.test(name)) {

package/dialects/mysql/MySqlSchemaHelper.js

@@ -35,7 +35,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
         return sql;
     }
     getListTablesSQL() {
-        return `select table_name as table_name, nullif(table_schema, schema()) as schema_name, table_comment as table_comment from information_schema.tables where table_type = 'BASE TABLE' and table_schema = schema()`;
+        return `select table_name as table_name, nullif(table_schema, schema()) as schema_name, table_comment as table_comment, table_collation as table_collation from information_schema.tables where table_type = 'BASE TABLE' and table_schema = schema()`;
     }
     getListViewsSQL() {
         return `select table_name as view_name, nullif(table_schema, schema()) as schema_name, view_definition from information_schema.views where table_schema = schema()`;
@@ -72,6 +72,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
         for (const t of tables) {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
+            table.collation = t.table_collation ?? undefined;
             const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
             table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums[key]);
             if (triggers[key]) {
@@ -211,22 +212,25 @@ export class MySqlSchemaHelper extends SchemaHelper {
         return sql;
     }
     async getAllColumns(connection, tables, ctx) {
-        const sql = `select table_name as table_name,
-      nullif(table_schema, schema()) as schema_name,
-      column_name as column_name,
-      column_default as column_default,
-      nullif(column_comment, '') as column_comment,
-      is_nullable as is_nullable,
-      data_type as data_type,
-      column_type as column_type,
-      column_key as column_key,
-      extra as extra,
-      generation_expression as generation_expression,
-      numeric_precision as numeric_precision,
-      numeric_scale as numeric_scale,
-      ifnull(datetime_precision, character_maximum_length) length
-      from information_schema.columns where table_schema = database() and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name))})
-      order by ordinal_position`;
+        const sql = `select c.table_name as table_name,
+      nullif(c.table_schema, schema()) as schema_name,
+      c.column_name as column_name,
+      c.column_default as column_default,
+      nullif(c.column_comment, '') as column_comment,
+      c.is_nullable as is_nullable,
+      c.data_type as data_type,
+      c.column_type as column_type,
+      c.column_key as column_key,
+      c.extra as extra,
+      c.generation_expression as generation_expression,
+      c.numeric_precision as numeric_precision,
+      c.numeric_scale as numeric_scale,
+      ifnull(c.datetime_precision, c.character_maximum_length) length,
+      nullif(c.collation_name, t.table_collation) as collation_name
+      from information_schema.columns c
+      join information_schema.tables t on t.table_schema = c.table_schema and t.table_name = c.table_name
+      where c.table_schema = database() and c.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name))})
+      order by c.ordinal_position`;
         const allColumns = await connection.execute(sql, [], 'all', ctx);
         const str = (val) => (val != null ? '' + val : val);
         const extra = (val) => val.replace(/auto_increment|default_generated|(stored|virtual) generated/i, '').trim() || undefined;
@@ -257,6 +261,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
                 precision: col.numeric_precision,
                 scale: col.numeric_scale,
                 comment: col.column_comment,
+                collation: col.collation_name ?? undefined,
                 extra: extra(col.extra),
                 generated,
             });
@@ -417,10 +422,13 @@ export class MySqlSchemaHelper extends SchemaHelper {
         const col = this.createTableColumn(column, table, changedProperties);
         return [`alter table ${table.getQuotedName()} modify ${col}`];
     }
+    // MySQL MODIFY/CHANGE resets omitted column attributes to the table default, so collation must
+    // be re-emitted on rename and comment-only paths to preserve a non-default column collation.
     getColumnDeclarationSQL(col) {
         let ret = col.type;
         ret += col.unsigned ? ' unsigned' : '';
         ret += col.autoincrement ? ' auto_increment' : '';
+        ret += col.collation ? ` ${this.getCollateSQL(col.collation)}` : '';
         ret += ' ';
         ret += col.nullable ? 'null' : 'not null';
         ret += col.default ? ' default ' + col.default : '';

package/dialects/postgresql/BasePostgreSqlPlatform.d.ts

@@ -112,4 +112,5 @@ export declare class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     }[]): string;
     getJsonArrayElementPropertySQL(alias: string, property: string, type: string): string;
     getDefaultClientUrl(): string;
+    caseInsensitiveCollationNames(): boolean;
 }

package/dialects/postgresql/BasePostgreSqlPlatform.js

@@ -380,4 +380,7 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     getDefaultClientUrl() {
         return 'postgresql://postgres@127.0.0.1:5432';
     }
+    caseInsensitiveCollationNames() {
+        return false;
+    }
 }

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -67,6 +67,12 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     /** Generates SQL to drop a PostgreSQL trigger and its associated function. */
     dropTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
     private getSchemaQualifiedTriggerFnName;
+    /**
+     * Resolves the real name of the implicit 'default' collation (the DB's `datcollate`),
+     * so the comparator can treat `@Property({ collation: '<datcollate>' })` as equivalent
+     * to a column that introspects as using the default.
+     */
+    getDatabaseCollation(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string | undefined>;
     getAllTriggers(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<SqlTriggerDef[]>>;
     private getTriggersSQL;
     getAllForeignKeys(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<Dictionary<ForeignKey>>>;
@@ -79,6 +85,7 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     getDropNativeEnumSQL(name: string, schema?: string): string;
     getAlterNativeEnumSQL(name: string, schema?: string, value?: string, items?: string[], oldItems?: string[]): string;
     private getEnumDefinitions;
+    protected getCollateSQL(collation: string): string;
     createTableColumn(column: Column, table: DatabaseTable): string | undefined;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     castColumn(name: string, type: string): string;

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -149,9 +149,11 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const fks = await this.getAllForeignKeys(connection, tablesBySchema, ctx);
         const partitionings = await this.getPartitions(connection, tablesBySchema, ctx);
         const triggers = await this.getAllTriggers(connection, tablesBySchema);
+        const dbCollation = await this.getDatabaseCollation(connection, ctx);
         for (const t of tables) {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
+            table.collation = dbCollation;
             const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
             const enums = this.getEnumDefinitions(checks[key] ?? []);
             if (columns[key]) {
@@ -366,10 +368,12 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       is_identity,
       identity_generation,
       generation_expression,
-      pg_catalog.col_description(pgc.oid, cols.ordinal_position::int) column_comment
+      pg_catalog.col_description(pgc.oid, cols.ordinal_position::int) column_comment,
+      coll.collname as collation_name
       from information_schema.columns cols
       join pg_class pgc on cols.table_name = pgc.relname
       join pg_attribute pga on pgc.oid = pga.attrelid and cols.column_name = pga.attname
+      left join pg_collation coll on pga.attcollation = coll.oid and coll.collname <> 'default'
       where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(table_schema = ${this.platform.quoteValue(schema)} and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}))`).join(' or ')})
       order by ordinal_position`;
         const allColumns = await connection.execute(sql, [], 'all', ctx);
@@ -419,6 +423,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                         ? col.generation_expression + ' stored'
                         : undefined,
                 comment: col.column_comment,
+                collation: col.collation_name ?? undefined,
             };
             let enumKey = column.type;
             let enumEntry = nativeEnums?.[enumKey];
@@ -504,6 +509,15 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         }
         return this.platform.quoteIdentifier(rawName);
     }
+    /**
+     * Resolves the real name of the implicit 'default' collation (the DB's `datcollate`),
+     * so the comparator can treat `@Property({ collation: '<datcollate>' })` as equivalent
+     * to a column that introspects as using the default.
+     */
+    async getDatabaseCollation(connection, ctx) {
+        const [row] = await connection.execute(`select datcollate as collation from pg_database where datname = current_database()`, [], 'all', ctx);
+        return row?.collation;
+    }
     async getAllTriggers(connection, tablesBySchemas) {
         const sql = this.getTriggersSQL(tablesBySchemas);
         const allTriggers = await connection.execute(sql);
@@ -694,6 +708,9 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             return o;
         }, {});
     }
+    getCollateSQL(collation) {
+        return `collate ${this.platform.quoteCollation(collation)}`;
+    }
     createTableColumn(column, table) {
         const pk = table.getPrimaryKey();
         const compositePK = pk?.composite;
@@ -726,6 +743,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 columnType += ` generated always as ${column.generated}`;
             }
             col.push(columnType);
+            Utils.runIfNotEmpty(() => col.push(this.getCollateSQL(column.collation)), column.collation);
             Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
             Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable);
         }

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -165,6 +165,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
             col.push(`check (${checks[check].expression})`);
             checks.splice(check, 1);
         }
+        Utils.runIfNotEmpty(() => col.push(this.getCollateSQL(column.collation)), column.collation);
         Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
         Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable && !column.generated);
         Utils.runIfNotEmpty(() => col.push('primary key'), column.primary);
@@ -291,6 +292,17 @@ export class SqliteSchemaHelper extends SchemaHelper {
                     generated = `${match[2]} ${storage}`;
                 }
             }
+            // Strip string literals first (their contents could contain unbalanced parens), then
+            // repeatedly strip the innermost balanced `(...)` until none remain — a single pass would
+            // only remove the innermost level, leaving `collate` tokens inside nested CHECK/default
+            // expressions exposed to the column-collation regex.
+            let cleanDef = (columnDefinitions[col.name]?.definition ?? '').replace(/'[^']*'/g, '').replace(/"[^"]*"/g, '');
+            let prev;
+            do {
+                prev = cleanDef;
+                cleanDef = cleanDef.replace(/\([^()]*\)/g, '');
+            } while (cleanDef !== prev);
+            const collationMatch = /\bcollate\s+([`"']?)([\w\-.]+)\1/i.exec(cleanDef);
             return {
                 name: col.name,
                 type: col.type,
@@ -301,6 +313,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
                 unsigned: false,
                 autoincrement: !composite && col.pk && this.platform.isNumericColumn(mappedType) && hasAutoincrement,
                 generated,
+                collation: collationMatch ? collationMatch[2] : undefined,
             };
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.0-dev.21",
+  "version": "7.1.0-dev.23",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",
@@ -50,10 +50,10 @@
     "kysely": "0.28.16"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.12"
+    "@mikro-orm/core": "^7.0.13"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.21"
+    "@mikro-orm/core": "7.1.0-dev.23"
   },
   "engines": {
     "node": ">= 22.17.0"

package/schema/DatabaseTable.d.ts

@@ -16,6 +16,13 @@ export declare class DatabaseTable {
     }>;
     comment?: string;
     partitioning?: TablePartitioning;
+    /**
+     * Effective collation the column defaults to when no explicit `COLLATE` is set on a column.
+     * For MySQL/MariaDB this is the table collation; for PostgreSQL and MSSQL this is the database default;
+     * SQLite has no configurable default. Used by `SchemaComparator.diffCollation` to avoid flapping
+     * when a property explicitly names the default collation.
+     */
+    collation?: string;
     constructor(platform: AbstractSqlPlatform, name: string, schema?: string | undefined);
     getQuotedName(): string;
     getColumns(): Column[];

package/schema/DatabaseTable.js

@@ -15,6 +15,13 @@ export class DatabaseTable {
     nativeEnums = {}; // for postgres
     comment;
     partitioning;
+    /**
+     * Effective collation the column defaults to when no explicit `COLLATE` is set on a column.
+     * For MySQL/MariaDB this is the table collation; for PostgreSQL and MSSQL this is the database default;
+     * SQLite has no configurable default. Used by `SchemaComparator.diffCollation` to avoid flapping
+     * when a property explicitly names the default collation.
+     */
+    collation;
     constructor(platform, name, schema) {
         this.name = name;
         this.schema = schema;
@@ -130,6 +137,7 @@ export class DatabaseTable {
                 default: prop.defaultRaw,
                 enumItems: prop.nativeEnumName || prop.items?.every(i => typeof i === 'string') ? prop.items : undefined,
                 comment: prop.comment,
+                collation: prop.collation,
                 extra: prop.extra,
                 ignoreSchemaChanges: prop.ignoreSchemaChanges,
             };
@@ -665,6 +673,7 @@ export class DatabaseTable {
             columnOptions.scale = column.scale;
             columnOptions.extra = column.extra;
             columnOptions.comment = column.comment;
+            columnOptions.collation = column.collation;
             columnOptions.enum = !!column.enumItems?.length;
             columnOptions.items = column.enumItems;
         }
@@ -731,6 +740,7 @@ export class DatabaseTable {
             scale: column.scale,
             extra: column.extra,
             comment: column.comment,
+            collation: column.collation,
             index: index ? index.keyName : undefined,
             unique: unique ? unique.keyName : undefined,
             enum: !!column.enumItems?.length,
@@ -985,6 +995,7 @@ export class DatabaseTable {
                 scale: fixedPrecision ? null : (c.scale ?? null),
                 default: c.default ?? null,
                 comment: c.comment ?? null,
+                collation: c.collation ?? null,
                 enumItems: c.enumItems ?? [],
                 mappedType: Utils.keys(t).find(k => t[k] === c.mappedType.constructor),
             };

package/schema/SchemaComparator.d.ts

@@ -39,6 +39,15 @@ export declare class SchemaComparator {
     diffColumn(fromColumn: Column, toColumn: Column, fromTable: DatabaseTable, logging?: boolean): Set<string>;
     diffEnumItems(items1?: string[], items2?: string[]): boolean;
     diffComment(comment1?: string, comment2?: string): boolean;
+    /**
+     * `from` is the introspected DB state, `to` is the target metadata. A column-level `COLLATE`
+     * clause naming the table/database default is just verbose syntax for inheriting that default,
+     * so both sides are normalized — anything matching `tableDefault` collapses to `undefined` and
+     * compares equal to "no explicit collation". Comparison is case-insensitive on dialects that
+     * treat collation identifiers as case-insensitive (MySQL/MSSQL/SQLite); PostgreSQL's
+     * `pg_collation.collname` is case-sensitive and is compared verbatim.
+     */
+    diffCollation(fromCollation?: string, toCollation?: string, tableDefault?: string): boolean;
     /**
      * Finds the difference between the indexes index1 and index2.
      * Compares index1 with index2 and returns index2 if there are any differences or false in case there are no differences.

package/schema/SchemaComparator.js

@@ -571,6 +571,11 @@ export class SchemaComparator {
             log(`'comment' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('comment');
         }
+        if (!(fromColumn.ignoreSchemaChanges?.includes('collation') || toColumn.ignoreSchemaChanges?.includes('collation')) &&
+            this.diffCollation(fromColumn.collation, toColumn.collation, fromTable.collation)) {
+            log(`'collation' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
+            changedProperties.add('collation');
+        }
         const isNonNativeEnumArray = !(fromColumn.nativeEnumName || toColumn.nativeEnumName) &&
             (fromColumn.mappedType instanceof ArrayType || toColumn.mappedType instanceof ArrayType);
         if (!isNonNativeEnumArray && this.diffEnumItems(fromColumn.enumItems, toColumn.enumItems)) {
@@ -592,6 +597,19 @@ export class SchemaComparator {
         // eslint-disable-next-line eqeqeq
         return comment1 != comment2 && !(comment1 == null && comment2 === '') && !(comment2 == null && comment1 === '');
     }
+    /**
+     * `from` is the introspected DB state, `to` is the target metadata. A column-level `COLLATE`
+     * clause naming the table/database default is just verbose syntax for inheriting that default,
+     * so both sides are normalized — anything matching `tableDefault` collapses to `undefined` and
+     * compares equal to "no explicit collation". Comparison is case-insensitive on dialects that
+     * treat collation identifiers as case-insensitive (MySQL/MSSQL/SQLite); PostgreSQL's
+     * `pg_collation.collname` is case-sensitive and is compared verbatim.
+     */
+    diffCollation(fromCollation, toCollation, tableDefault) {
+        const fold = this.#platform.caseInsensitiveCollationNames() ? (s) => s.toLowerCase() : (s) => s;
+        const norm = (c) => c && tableDefault && fold(c) === fold(tableDefault) ? undefined : c == null ? undefined : fold(c);
+        return norm(fromCollation) !== norm(toCollation);
+    }
     /**
      * Finds the difference between the indexes index1 and index2.
      * Compares index1 with index2 and returns index2 if there are any differences or false in case there are no differences.

package/schema/SchemaHelper.d.ts

@@ -97,6 +97,8 @@ export declare abstract class SchemaHelper {
     hasNonDefaultPrimaryKeyName(table: DatabaseTable): boolean;
     castColumn(name: string, type: string): string;
     alterTableColumn(column: Column, table: DatabaseTable, changedProperties: Set<string>): string[];
+    /** Returns the bare `collate <name>` clause for column DDL. Overridden by PostgreSQL to quote the identifier. */
+    protected getCollateSQL(collation: string): string;
     createTableColumn(column: Column, table: DatabaseTable, changedProperties?: Set<string>): string | undefined;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     getPostAlterTable(tableDiff: TableDifference, safe: boolean): string[];

package/schema/SchemaHelper.js

@@ -381,7 +381,7 @@ export class SchemaHelper {
             this.append(ret, this.alterTableColumn(column, diff.fromTable, changedProperties));
         }
         for (const { column, changedProperties } of Object.values(diff.changedColumns).filter(diff => diff.changedProperties.has('comment'))) {
-            if (['type', 'nullable', 'autoincrement', 'unsigned', 'default', 'enumItems'].some(t => changedProperties.has(t))) {
+            if (['type', 'nullable', 'autoincrement', 'unsigned', 'default', 'enumItems', 'collation'].some(t => changedProperties.has(t))) {
                 continue; // will be handled via column update
             }
             ret.push(this.getChangeColumnCommentSQL(tableName, column, schemaName));
@@ -458,7 +458,7 @@ export class SchemaHelper {
         if (changedProperties.has('default') && column.default == null) {
             sql.push(`alter table ${table.getQuotedName()} alter column ${this.quote(column.name)} drop default`);
         }
-        if (changedProperties.has('type')) {
+        if (changedProperties.has('type') || changedProperties.has('collation')) {
             let type = column.type + (column.generated ? ` generated always as ${column.generated}` : '');
             if (column.nativeEnumName) {
                 const parts = type.split('.');
@@ -470,7 +470,8 @@ export class SchemaHelper {
                 }
                 type = this.quote(type);
             }
-            sql.push(`alter table ${table.getQuotedName()} alter column ${this.quote(column.name)} type ${type + this.castColumn(column.name, type)}`);
+            const collateClause = column.collation ? ` ${this.getCollateSQL(column.collation)}` : '';
+            sql.push(`alter table ${table.getQuotedName()} alter column ${this.quote(column.name)} type ${type + collateClause + this.castColumn(column.name, type)}`);
         }
         if (changedProperties.has('default') && column.default != null) {
             sql.push(`alter table ${table.getQuotedName()} alter column ${this.quote(column.name)} set default ${column.default}`);
@@ -481,6 +482,11 @@ export class SchemaHelper {
         }
         return sql;
     }
+    /** Returns the bare `collate <name>` clause for column DDL. Overridden by PostgreSQL to quote the identifier. */
+    getCollateSQL(collation) {
+        this.platform.validateCollationName(collation);
+        return `collate ${collation}`;
+    }
     createTableColumn(column, table, changedProperties) {
         const compositePK = table.getPrimaryKey()?.composite;
         const primaryKey = !changedProperties && !this.hasNonDefaultPrimaryKeyName(table);
@@ -488,6 +494,7 @@ export class SchemaHelper {
         const useDefault = column.default != null && column.default !== 'null' && !column.autoincrement;
         const col = [this.quote(column.name), columnType];
         Utils.runIfNotEmpty(() => col.push('unsigned'), column.unsigned && this.platform.supportsUnsigned());
+        Utils.runIfNotEmpty(() => col.push(this.getCollateSQL(column.collation)), column.collation);
         Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
         Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable && !column.generated);
         Utils.runIfNotEmpty(() => col.push('auto_increment'), column.autoincrement);

package/typings.d.ts

@@ -44,6 +44,7 @@ export interface Column {
     default?: string | null;
     defaultConstraint?: string;
     comment?: string;
+    collation?: string;
     generated?: string;
     nativeEnumName?: string;
     enumItems?: string[];
@@ -51,7 +52,7 @@ export interface Column {
     unique?: boolean;
     /** mysql only */
     extra?: string;
-    ignoreSchemaChanges?: ('type' | 'extra' | 'default')[];
+    ignoreSchemaChanges?: ('type' | 'extra' | 'default' | 'collation')[];
 }
 export interface ForeignKey {
     columnNames: string[];