@mikro-orm/knex 6.1.13-dev.8 → 6.2.0

package/dialects/mysql/MySqlExceptionConverter.d.ts

@@ -0,0 +1,9 @@
+import { ExceptionConverter, type Dictionary, type DriverException } from '@mikro-orm/core';
+export declare class MySqlExceptionConverter extends ExceptionConverter {
+    /**
+     * @link http://dev.mysql.com/doc/refman/5.7/en/error-messages-client.html
+     * @link http://dev.mysql.com/doc/refman/5.7/en/error-messages-server.html
+     * @link https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractMySQLDriver.php
+     */
+    convertException(exception: Error & Dictionary): DriverException;
+}

package/dialects/mysql/MySqlExceptionConverter.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlExceptionConverter = void 0;
+const core_1 = require("@mikro-orm/core");
+class MySqlExceptionConverter extends core_1.ExceptionConverter {
+    /* istanbul ignore next */
+    /**
+     * @link http://dev.mysql.com/doc/refman/5.7/en/error-messages-client.html
+     * @link http://dev.mysql.com/doc/refman/5.7/en/error-messages-server.html
+     * @link https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractMySQLDriver.php
+     */
+    convertException(exception) {
+        switch (exception.errno) {
+            case 1213:
+                return new core_1.DeadlockException(exception);
+            case 1205:
+                return new core_1.LockWaitTimeoutException(exception);
+            case 1050:
+                return new core_1.TableExistsException(exception);
+            case 1051:
+            case 1146:
+                return new core_1.TableNotFoundException(exception);
+            case 1216:
+            case 1217:
+            case 1451:
+            case 1452:
+            case 1701:
+                return new core_1.ForeignKeyConstraintViolationException(exception);
+            case 3819:
+                return new core_1.CheckConstraintViolationException(exception);
+            case 1062:
+            case 1557:
+            case 1569:
+            case 1586:
+                return new core_1.UniqueConstraintViolationException(exception);
+            case 1054:
+            case 1166:
+            case 1611:
+                return new core_1.InvalidFieldNameException(exception);
+            case 1052:
+            case 1060:
+            case 1110:
+                return new core_1.NonUniqueFieldNameException(exception);
+            case 1064:
+            case 1149:
+            case 1287:
+            case 1341:
+            case 1342:
+            case 1343:
+            case 1344:
+            case 1382:
+            case 1479:
+            case 1541:
+            case 1554:
+            case 1626:
+                return new core_1.SyntaxErrorException(exception);
+            case 1044:
+            case 1045:
+            case 1046:
+            case 1049:
+            case 1095:
+            case 1142:
+            case 1143:
+            case 1227:
+            case 1370:
+            case 1429:
+            case 2002:
+            case 2005:
+                return new core_1.ConnectionException(exception);
+            case 1048:
+            case 1121:
+            case 1138:
+            case 1171:
+            case 1252:
+            case 1263:
+            case 1364:
+            case 1566:
+                return new core_1.NotNullConstraintViolationException(exception);
+        }
+        return super.convertException(exception);
+    }
+}
+exports.MySqlExceptionConverter = MySqlExceptionConverter;

package/dialects/mysql/MySqlKnexDialect.d.ts

@@ -0,0 +1,5 @@
+import MySql2Dialect from 'knex/lib/dialects/mysql2';
+export declare class MySqlKnexDialect extends MySql2Dialect {
+    queryCompiler(): any;
+    columnCompiler(): any;
+}

package/dialects/mysql/MySqlKnexDialect.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlKnexDialect = void 0;
+// @ts-ignore
+const mysql2_1 = __importDefault(require("knex/lib/dialects/mysql2"));
+const MySqlQueryCompiler_1 = require("./MySqlQueryCompiler");
+const MySqlColumnCompiler_1 = require("./MySqlColumnCompiler");
+class MySqlKnexDialect extends mysql2_1.default {
+    queryCompiler() {
+        // eslint-disable-next-line prefer-rest-params
+        return new MySqlQueryCompiler_1.MySqlQueryCompiler(this, ...arguments);
+    }
+    columnCompiler() {
+        // eslint-disable-next-line prefer-rest-params
+        return new MySqlColumnCompiler_1.MySqlColumnCompiler(this, ...arguments);
+    }
+}
+exports.MySqlKnexDialect = MySqlKnexDialect;

package/dialects/mysql/MySqlPlatform.d.ts

@@ -0,0 +1,31 @@
+import { type SimpleColumnMeta, type Type, type TransformContext } from '@mikro-orm/core';
+import { MySqlSchemaHelper } from './MySqlSchemaHelper';
+import { MySqlExceptionConverter } from './MySqlExceptionConverter';
+import { AbstractSqlPlatform } from '../../AbstractSqlPlatform';
+import type { IndexDef } from '../../typings';
+export declare class MySqlPlatform extends AbstractSqlPlatform {
+    protected readonly schemaHelper: MySqlSchemaHelper;
+    protected readonly exceptionConverter: MySqlExceptionConverter;
+    protected readonly ORDER_BY_NULLS_TRANSLATE: {
+        readonly "asc nulls first": "is not null";
+        readonly "asc nulls last": "is null";
+        readonly "desc nulls first": "is not null";
+        readonly "desc nulls last": "is null";
+    };
+    getDefaultCharset(): string;
+    convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
+    getJsonIndexDefinition(index: IndexDef): string[];
+    getBooleanTypeDeclarationSQL(): string;
+    getDefaultMappedType(type: string): Type<unknown>;
+    supportsUnsigned(): boolean;
+    /**
+     * Returns the default name of index for the given columns
+     * cannot go past 64 character length for identifiers in MySQL
+     */
+    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
+    getDefaultPrimaryName(tableName: string, columns: string[]): string;
+    supportsCreatingFullTextIndex(): boolean;
+    getFullTextWhereClause(): string;
+    getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
+    getOrderByExpression(column: string, direction: string): string[];
+}

package/dialects/mysql/MySqlPlatform.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlPlatform = void 0;
+const core_1 = require("@mikro-orm/core");
+const MySqlSchemaHelper_1 = require("./MySqlSchemaHelper");
+const MySqlExceptionConverter_1 = require("./MySqlExceptionConverter");
+const AbstractSqlPlatform_1 = require("../../AbstractSqlPlatform");
+class MySqlPlatform extends AbstractSqlPlatform_1.AbstractSqlPlatform {
+    schemaHelper = new MySqlSchemaHelper_1.MySqlSchemaHelper(this);
+    exceptionConverter = new MySqlExceptionConverter_1.MySqlExceptionConverter();
+    ORDER_BY_NULLS_TRANSLATE = {
+        [core_1.QueryOrder.asc_nulls_first]: 'is not null',
+        [core_1.QueryOrder.asc_nulls_last]: 'is null',
+        [core_1.QueryOrder.desc_nulls_first]: 'is not null',
+        [core_1.QueryOrder.desc_nulls_last]: 'is null',
+    };
+    getDefaultCharset() {
+        return 'utf8mb4';
+    }
+    convertJsonToDatabaseValue(value, context) {
+        if (context?.mode === 'query') {
+            return value;
+        }
+        return JSON.stringify(value);
+    }
+    getJsonIndexDefinition(index) {
+        return index.columnNames
+            .map(column => {
+            if (!column.includes('.')) {
+                return column;
+            }
+            const [root, ...path] = column.split('.');
+            return `(json_value(${this.quoteIdentifier(root)}, '$.${path.join('.')}' returning ${index.options?.returning ?? 'char(255)'}))`;
+        });
+    }
+    getBooleanTypeDeclarationSQL() {
+        return 'tinyint(1)';
+    }
+    getDefaultMappedType(type) {
+        if (type === 'tinyint(1)') {
+            return super.getDefaultMappedType('boolean');
+        }
+        return super.getDefaultMappedType(type);
+    }
+    supportsUnsigned() {
+        return true;
+    }
+    /**
+     * Returns the default name of index for the given columns
+     * cannot go past 64 character length for identifiers in MySQL
+     */
+    getIndexName(tableName, columns, type) {
+        if (type === 'primary') {
+            return this.getDefaultPrimaryName(tableName, columns);
+        }
+        const indexName = super.getIndexName(tableName, columns, type);
+        if (indexName.length > 64) {
+            return `${indexName.substring(0, 56 - type.length)}_${core_1.Utils.hash(indexName, 5)}_${type}`;
+        }
+        return indexName;
+    }
+    getDefaultPrimaryName(tableName, columns) {
+        return 'PRIMARY'; // https://dev.mysql.com/doc/refman/8.0/en/create-table.html#create-table-indexes-keys
+    }
+    supportsCreatingFullTextIndex() {
+        return true;
+    }
+    getFullTextWhereClause() {
+        return `match(:column:) against (:query in boolean mode)`;
+    }
+    getFullTextIndexExpression(indexName, schemaName, tableName, columns) {
+        /* istanbul ignore next */
+        const quotedTableName = this.quoteIdentifier(schemaName ? `${schemaName}.${tableName}` : tableName);
+        const quotedColumnNames = columns.map(c => this.quoteIdentifier(c.name));
+        const quotedIndexName = this.quoteIdentifier(indexName);
+        return `alter table ${quotedTableName} add fulltext index ${quotedIndexName}(${quotedColumnNames.join(',')})`;
+    }
+    getOrderByExpression(column, direction) {
+        const ret = [];
+        const dir = direction.toLowerCase();
+        if (dir in this.ORDER_BY_NULLS_TRANSLATE) {
+            ret.push(`${column} ${this.ORDER_BY_NULLS_TRANSLATE[dir]}`);
+        }
+        ret.push(`${column} ${dir.replace(/(\s|nulls|first|last)*/gi, '')}`);
+        return ret;
+    }
+}
+exports.MySqlPlatform = MySqlPlatform;

package/dialects/mysql/MySqlQueryCompiler.d.ts

@@ -0,0 +1,5 @@
+import BaseMySqlQueryCompiler from 'knex/lib/dialects/mysql/query/mysql-querycompiler';
+export declare class MySqlQueryCompiler extends BaseMySqlQueryCompiler {
+    whereBasic(statement: any): any;
+    whereRaw(statement: any): any;
+}

package/dialects/mysql/MySqlQueryCompiler.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlQueryCompiler = void 0;
+/* istanbul ignore file */
+// @ts-ignore
+const mysql_querycompiler_1 = __importDefault(require("knex/lib/dialects/mysql/query/mysql-querycompiler"));
+// @ts-ignore
+const querycompiler_1 = __importDefault(require("knex/lib/query/querycompiler"));
+// upsert support from https://github.com/knex/knex/pull/6050
+class MySqlQueryCompiler extends mysql_querycompiler_1.default {
+    // mysql dialect disallows query non scalar params, but we dont use it to execute the query, it always goes through the `platform.formatQuery()`
+    whereBasic(statement) {
+        return querycompiler_1.default.prototype.whereBasic.call(this, statement);
+    }
+    // mysql dialect disallows query non scalar params, but we dont use it to execute the query, it always goes through the `platform.formatQuery()`
+    whereRaw(statement) {
+        return querycompiler_1.default.prototype.whereRaw.call(this, statement);
+    }
+}
+exports.MySqlQueryCompiler = MySqlQueryCompiler;

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -0,0 +1,43 @@
+import type { Knex } from 'knex';
+import type { CheckDef, Column, IndexDef, TableDifference, Table, ForeignKey } from '../../typings';
+import { type Dictionary, type Type } from '@mikro-orm/core';
+import type { AbstractSqlConnection } from '../../AbstractSqlConnection';
+import { SchemaHelper } from '../../schema/SchemaHelper';
+import type { DatabaseSchema } from '../../schema/DatabaseSchema';
+import type { DatabaseTable } from '../../schema/DatabaseTable';
+export declare class MySqlSchemaHelper extends SchemaHelper {
+    private readonly _cache;
+    static readonly DEFAULT_VALUES: {
+        'now()': string[];
+        'current_timestamp(?)': string[];
+        '0': string[];
+    };
+    getSchemaBeginning(charset: string): string;
+    disableForeignKeysSQL(): string;
+    enableForeignKeysSQL(): string;
+    finalizeTable(table: Knex.CreateTableBuilder, charset: string, collate?: string): void;
+    getListTablesSQL(): string;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[]): Promise<void>;
+    getAllIndexes(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<IndexDef[]>>;
+    getAllColumns(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Column[]>>;
+    getAllChecks(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<CheckDef[]>>;
+    getAllForeignKeys(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Dictionary<ForeignKey>>>;
+    getPreAlterTable(tableDiff: TableDifference, safe: boolean): string;
+    configureColumnDefault(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
+    getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column): string;
+    getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string;
+    getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
+    createTableColumn(table: Knex.TableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>): Knex.ColumnBuilder | undefined;
+    configureColumn(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
+    private getColumnDeclarationSQL;
+    getForeignKeysSQL(tableName: string, schemaName?: string): string;
+    getAllEnumDefinitions(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Dictionary<string[]>>>;
+    private supportsCheckConstraints;
+    protected getChecksSQL(tables: Table[]): string;
+    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName: string, columns?: Column[]): Promise<CheckDef[]>;
+    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
+    getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Column[]>;
+    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<IndexDef[]>;
+    normalizeDefaultValue(defaultValue: string, length: number): string | number;
+    protected wrap(val: string | null | undefined, type: Type<unknown>): string | null | undefined;
+}

package/dialects/mysql/MySqlSchemaHelper.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlSchemaHelper = void 0;
+const core_1 = require("@mikro-orm/core");
+const SchemaHelper_1 = require("../../schema/SchemaHelper");
+class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
+    _cache = {};
+    static DEFAULT_VALUES = {
+        'now()': ['now()', 'current_timestamp'],
+        'current_timestamp(?)': ['current_timestamp(?)'],
+        '0': ['0', 'false'],
+    };
+    getSchemaBeginning(charset) {
+        return `set names ${charset};\n${this.disableForeignKeysSQL()}\n\n`;
+    }
+    disableForeignKeysSQL() {
+        return 'set foreign_key_checks = 0;';
+    }
+    enableForeignKeysSQL() {
+        return 'set foreign_key_checks = 1;';
+    }
+    finalizeTable(table, charset, collate) {
+        table.engine('InnoDB');
+        table.charset(charset);
+        if (collate) {
+            table.collate(collate);
+        }
+    }
+    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()`;
+    }
+    async loadInformationSchema(schema, connection, tables) {
+        if (tables.length === 0) {
+            return;
+        }
+        const columns = await this.getAllColumns(connection, tables);
+        const indexes = await this.getAllIndexes(connection, tables);
+        const checks = await this.getAllChecks(connection, tables);
+        const fks = await this.getAllForeignKeys(connection, tables);
+        const enums = await this.getAllEnumDefinitions(connection, tables);
+        for (const t of tables) {
+            const key = this.getTableKey(t);
+            const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
+            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]);
+        }
+    }
+    async getAllIndexes(connection, tables) {
+        const sql = `select table_name as table_name, nullif(table_schema, schema()) as schema_name, index_name as index_name, non_unique as non_unique, column_name as column_name, expression as expression
+        from information_schema.statistics where table_schema = database()
+        and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')})
+        order by schema_name, table_name, index_name, seq_in_index`;
+        const allIndexes = await connection.execute(sql);
+        const ret = {};
+        for (const index of allIndexes) {
+            const key = this.getTableKey(index);
+            const indexDef = {
+                columnNames: [index.column_name],
+                keyName: index.index_name,
+                unique: !index.non_unique,
+                primary: index.index_name === 'PRIMARY',
+                constraint: !index.non_unique,
+            };
+            if (!index.column_name || index.expression?.match(/ where /i)) {
+                indexDef.expression = index.expression; // required for the `getCreateIndexSQL()` call
+                indexDef.expression = this.getCreateIndexSQL(index.table_name, indexDef, !!index.expression);
+            }
+            ret[key] ??= [];
+            ret[key].push(indexDef);
+        }
+        for (const key of Object.keys(ret)) {
+            ret[key] = await this.mapIndexes(ret[key]);
+        }
+        return ret;
+    }
+    async getAllColumns(connection, tables) {
+        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,
+      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 allColumns = await connection.execute(sql);
+        const str = (val) => val != null ? '' + val : val;
+        const extra = (val) => val.replace(/auto_increment|default_generated|(stored|virtual) generated/i, '').trim();
+        const ret = {};
+        for (const col of allColumns) {
+            const mappedType = this.platform.getMappedType(col.column_type);
+            const defaultValue = str(this.normalizeDefaultValue((mappedType.compareAsType() === 'boolean' && ['0', '1'].includes(col.column_default))
+                ? ['false', 'true'][+col.column_default]
+                : col.column_default, col.length));
+            const key = this.getTableKey(col);
+            const generated = col.generation_expression ? `(${col.generation_expression.replaceAll(`\\'`, `'`)}) ${col.extra.match(/stored generated/i) ? 'stored' : 'virtual'}` : undefined;
+            ret[key] ??= [];
+            ret[key].push({
+                name: col.column_name,
+                type: this.platform.isNumericColumn(mappedType) ? col.column_type.replace(/ unsigned$/, '').replace(/\(\d+\)$/, '') : col.column_type,
+                mappedType,
+                unsigned: col.column_type.endsWith(' unsigned'),
+                length: col.length,
+                default: this.wrap(defaultValue, mappedType),
+                nullable: col.is_nullable === 'YES',
+                primary: col.column_key === 'PRI',
+                unique: col.column_key === 'UNI',
+                autoincrement: col.extra === 'auto_increment',
+                precision: col.numeric_precision,
+                scale: col.numeric_scale,
+                comment: col.column_comment,
+                extra: extra(col.extra),
+                generated,
+            });
+        }
+        return ret;
+    }
+    async getAllChecks(connection, tables) {
+        /* istanbul ignore next */
+        if (!await this.supportsCheckConstraints(connection)) {
+            return {};
+        }
+        const sql = this.getChecksSQL(tables);
+        const allChecks = await connection.execute(sql);
+        const ret = {};
+        for (const check of allChecks) {
+            const key = this.getTableKey(check);
+            ret[key] ??= [];
+            ret[key].push({
+                name: check.name,
+                columnName: check.column_name,
+                definition: `check ${check.expression}`,
+                expression: check.expression.replace(/^\((.*)\)$/, '$1'),
+            });
+        }
+        return ret;
+    }
+    async getAllForeignKeys(connection, tables) {
+        const sql = `select k.constraint_name as constraint_name, nullif(k.table_schema, schema()) as schema_name, k.table_name as table_name, k.column_name as column_name, k.referenced_table_name as referenced_table_name, k.referenced_column_name as referenced_column_name, c.update_rule as update_rule, c.delete_rule as delete_rule
+        from information_schema.key_column_usage k
+        inner join information_schema.referential_constraints c on c.constraint_name = k.constraint_name and c.table_name = k.table_name
+        where k.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')})
+        and k.table_schema = database() and c.constraint_schema = database() and k.referenced_column_name is not null
+        order by constraint_name, k.ordinal_position`;
+        const allFks = await connection.execute(sql);
+        const ret = {};
+        for (const fk of allFks) {
+            const key = this.getTableKey(fk);
+            ret[key] ??= [];
+            ret[key].push(fk);
+        }
+        Object.keys(ret).forEach(key => {
+            const parts = key.split('.');
+            /* istanbul ignore next */
+            const schemaName = parts.length > 1 ? parts[0] : undefined;
+            ret[key] = this.mapForeignKeys(ret[key], key, schemaName);
+        });
+        return ret;
+    }
+    getPreAlterTable(tableDiff, safe) {
+        // Dropping primary keys requires to unset autoincrement attribute on the particular column first.
+        const pk = Object.values(tableDiff.removedIndexes).find(idx => idx.primary);
+        if (!pk || safe) {
+            return '';
+        }
+        return pk.columnNames
+            .filter(col => tableDiff.fromTable.hasColumn(col))
+            .map(col => tableDiff.fromTable.getColumn(col))
+            .filter(col => col.autoincrement)
+            .map(col => `alter table \`${tableDiff.name}\` modify \`${col.name}\` ${this.getColumnDeclarationSQL({ ...col, autoincrement: false })}`)
+            .join(';\n');
+    }
+    configureColumnDefault(column, col, knex, changedProperties) {
+        if (changedProperties || column.default !== undefined) {
+            if (column.default == null) {
+                col.defaultTo(null);
+            }
+            else {
+                col.defaultTo(knex.raw(column.default + (column.extra ? ' ' + column.extra : '')));
+            }
+        }
+        return col;
+    }
+    getRenameColumnSQL(tableName, oldColumnName, to) {
+        tableName = this.platform.quoteIdentifier(tableName);
+        oldColumnName = this.platform.quoteIdentifier(oldColumnName);
+        const columnName = this.platform.quoteIdentifier(to.name);
+        return `alter table ${tableName} change ${oldColumnName} ${columnName} ${this.getColumnDeclarationSQL(to)}`;
+    }
+    getRenameIndexSQL(tableName, index, oldIndexName) {
+        tableName = this.platform.quoteIdentifier(tableName);
+        oldIndexName = this.platform.quoteIdentifier(oldIndexName);
+        const keyName = this.platform.quoteIdentifier(index.keyName);
+        return `alter table ${tableName} rename index ${oldIndexName} to ${keyName}`;
+    }
+    getChangeColumnCommentSQL(tableName, to, schemaName) {
+        tableName = this.platform.quoteIdentifier(tableName);
+        const columnName = this.platform.quoteIdentifier(to.name);
+        return `alter table ${tableName} modify ${columnName} ${this.getColumnDeclarationSQL(to)}`;
+    }
+    createTableColumn(table, column, fromTable, changedProperties) {
+        if (column.mappedType instanceof core_1.MediumIntType) {
+            return table.specificType(column.name, this.getColumnDeclarationSQL(column, true));
+        }
+        return super.createTableColumn(table, column, fromTable, changedProperties);
+    }
+    configureColumn(column, col, knex, changedProperties) {
+        if (column.mappedType instanceof core_1.MediumIntType) {
+            return col;
+        }
+        return super.configureColumn(column, col, knex, changedProperties);
+    }
+    getColumnDeclarationSQL(col, addPrimary = false) {
+        let ret = col.type;
+        ret += col.unsigned ? ' unsigned' : '';
+        ret += col.autoincrement ? ' auto_increment' : '';
+        ret += ' ';
+        ret += col.nullable ? 'null' : 'not null';
+        ret += col.default ? ' default ' + col.default : '';
+        if (addPrimary && col.primary) {
+            ret += ' primary key';
+        }
+        ret += col.comment ? ` comment ${this.platform.quoteValue(col.comment)}` : '';
+        return ret;
+    }
+    /* istanbul ignore next kept for BC */
+    getForeignKeysSQL(tableName, schemaName) {
+        return `select distinct k.constraint_name as constraint_name, k.column_name as column_name, k.referenced_table_name as referenced_table_name, k.referenced_column_name as referenced_column_name, c.update_rule as update_rule, c.delete_rule as delete_rule `
+            + `from information_schema.key_column_usage k `
+            + `inner join information_schema.referential_constraints c on c.constraint_name = k.constraint_name and c.table_name = '${tableName}' `
+            + `where k.table_name = '${tableName}' and k.table_schema = database() and c.constraint_schema = database() and k.referenced_column_name is not null`;
+    }
+    async getAllEnumDefinitions(connection, tables) {
+        const sql = `select column_name as column_name, column_type as column_type, table_name as table_name
+      from information_schema.columns
+      where data_type = 'enum' and table_name in (${tables.map(t => `'${t.table_name}'`).join(', ')}) and table_schema = database()`;
+        const enums = await connection.execute(sql);
+        return enums.reduce((o, item) => {
+            o[item.table_name] ??= {};
+            o[item.table_name][item.column_name] = item.column_type.match(/enum\((.*)\)/)[1].split(',').map((item) => item.match(/'(.*)'/)[1]);
+            return o;
+        }, {});
+    }
+    async supportsCheckConstraints(connection) {
+        if (this._cache.supportsCheckConstraints != null) {
+            return this._cache.supportsCheckConstraints;
+        }
+        const sql = `select 1 from information_schema.tables where table_name = 'CHECK_CONSTRAINTS' and table_schema = 'information_schema'`;
+        const res = await connection.execute(sql);
+        return this._cache.supportsCheckConstraints = res.length > 0;
+    }
+    getChecksSQL(tables) {
+        return `select cc.constraint_schema as table_schema, tc.table_name as table_name, cc.constraint_name as name, cc.check_clause as expression
+      from information_schema.check_constraints cc
+      join information_schema.table_constraints tc
+        on tc.constraint_schema = cc.constraint_schema
+        and tc.constraint_name = cc.constraint_name
+        and constraint_type = 'CHECK'
+      where tc.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name))}) and tc.constraint_schema = database()
+      order by tc.constraint_name`;
+    }
+    /* istanbul ignore next */
+    async getChecks(connection, tableName, schemaName, columns) {
+        const res = await this.getAllChecks(connection, [{ table_name: tableName, schema_name: schemaName }]);
+        return res[tableName];
+    }
+    /* istanbul ignore next */
+    async getEnumDefinitions(connection, checks, tableName, schemaName) {
+        const res = await this.getAllEnumDefinitions(connection, [{ table_name: tableName, schema_name: schemaName }]);
+        return res[tableName];
+    }
+    /* istanbul ignore next */
+    async getColumns(connection, tableName, schemaName) {
+        const res = await this.getAllColumns(connection, [{ table_name: tableName, schema_name: schemaName }]);
+        return res[tableName];
+    }
+    /* istanbul ignore next */
+    async getIndexes(connection, tableName, schemaName) {
+        const res = await this.getAllIndexes(connection, [{ table_name: tableName, schema_name: schemaName }]);
+        return res[tableName];
+    }
+    normalizeDefaultValue(defaultValue, length) {
+        return super.normalizeDefaultValue(defaultValue, length, MySqlSchemaHelper.DEFAULT_VALUES);
+    }
+    wrap(val, type) {
+        const stringType = type instanceof core_1.StringType || type instanceof core_1.TextType || type instanceof core_1.EnumType;
+        return typeof val === 'string' && val.length > 0 && stringType ? this.platform.quoteValue(val) : val;
+    }
+}
+exports.MySqlSchemaHelper = MySqlSchemaHelper;

package/dialects/mysql/index.d.ts

@@ -0,0 +1,6 @@
+export * from './MariaDbKnexDialect';
+export * from './MySqlKnexDialect';
+export * from './MySqlConnection';
+export * from './MySqlExceptionConverter';
+export * from './MySqlSchemaHelper';
+export * from './MySqlPlatform';

package/dialects/mysql/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./MariaDbKnexDialect"), exports);
+__exportStar(require("./MySqlKnexDialect"), exports);
+__exportStar(require("./MySqlConnection"), exports);
+__exportStar(require("./MySqlExceptionConverter"), exports);
+__exportStar(require("./MySqlSchemaHelper"), exports);
+__exportStar(require("./MySqlPlatform"), exports);

package/dialects/postgresql/PostgreSqlKnexDialect.d.ts

@@ -0,0 +1,6 @@
+import PostgresDialect from 'knex/lib/dialects/postgres';
+import type { Configuration } from '@mikro-orm/core';
+export declare class PostgreSqlKnexDialect extends PostgresDialect {
+    ormConfig: Configuration;
+    tableCompiler(): any;
+}