@mikro-orm/knex 6.0.0-dev.4 → 6.0.0-dev.5

package/{dist/schema → schema}/DatabaseTable.js

@@ -30,7 +30,7 @@ class DatabaseTable {
     getChecks() {
         return this.checks;
     }
-    init(cols, indexes, checks, pks, fks, enums) {
+    init(cols, indexes = [], checks = [], pks, fks = {}, enums = {}) {
         this.indexes = indexes;
         this.checks = checks;
         this.foreignKeys = fks;
@@ -82,6 +82,7 @@ class DatabaseTable {
                 enumItems: prop.items?.every(core_1.Utils.isString) ? prop.items : undefined,
                 comment: prop.comment,
                 extra: prop.extra,
+                ignoreSchemaChanges: prop.ignoreSchemaChanges,
             };
             (_a = this.columns[field]).unsigned || (_a.unsigned = this.columns[field].autoincrement);
             const defaultValue = this.platform.getSchemaHelper().normalizeDefaultValue(prop.defaultRaw, prop.length);

package/{dist/schema → schema}/SchemaComparator.d.ts

@@ -8,6 +8,7 @@ import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
 export declare class SchemaComparator {
     private readonly platform;
     private readonly helper;
+    private readonly logger;
     constructor(platform: AbstractSqlPlatform);
     /**
      * Returns a SchemaDifference object containing the differences between the schemas fromSchema and toSchema.
@@ -37,7 +38,7 @@ export declare class SchemaComparator {
      * Returns the difference between the columns
      * If there are differences this method returns field2, otherwise the boolean false.
      */
-    diffColumn(column1: Column, column2: Column): Set<string>;
+    diffColumn(column1: Column, column2: Column, tableName?: string): Set<string>;
     diffEnumItems(items1?: string[], items2?: string[]): boolean;
     diffComment(comment1?: string, comment2?: string): boolean;
     /**
@@ -52,4 +53,5 @@ export declare class SchemaComparator {
     diffCheck(check1: Check, check2: Check): boolean;
     hasSameDefaultValue(from: Column, to: Column): boolean;
     private mapColumnToProperty;
+    private log;
 }

package/{dist/schema → schema}/SchemaComparator.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaComparator = void 0;
+const util_1 = require("util");
 const core_1 = require("@mikro-orm/core");
 /**
  * Compares two Schemas and return an instance of SchemaDifference.
@@ -9,6 +10,7 @@ class SchemaComparator {
     constructor(platform) {
         this.platform = platform;
         this.helper = this.platform.getSchemaHelper();
+        this.logger = this.platform.getConfig().getLogger();
     }
     /**
      * Returns a SchemaDifference object containing the differences between the schemas fromSchema and toSchema.
@@ -105,18 +107,22 @@ class SchemaComparator {
             renamedColumns: {},
             renamedIndexes: {},
             fromTable,
+            toTable,
         };
         if (this.diffComment(fromTable.comment, toTable.comment)) {
             tableDifferences.changedComment = toTable.comment;
+            this.log(`table comment changed for ${tableDifferences.name}`, { fromTableComment: fromTable.comment, toTableComment: toTable.comment });
         }
         const fromTableColumns = fromTable.getColumns();
         const toTableColumns = toTable.getColumns();
+        const tableName = (toTable.schema ? toTable.schema + '.' : '') + toTable.name;
         // See if all the columns in "from" table exist in "to" table
         for (const column of toTableColumns) {
             if (fromTable.hasColumn(column.name)) {
                 continue;
             }
             tableDifferences.addedColumns[column.name] = column;
+            this.log(`column ${tableDifferences.name}.${column.name} of type ${column.type} added`);
             changes++;
         }
         /* See if there are any removed columns in "to" table */
@@ -124,11 +130,12 @@ class SchemaComparator {
             // See if column is removed in "to" table.
             if (!toTable.hasColumn(column.name)) {
                 tableDifferences.removedColumns[column.name] = column;
+                this.log(`column ${tableDifferences.name}.${column.name} removed`);
                 changes++;
                 continue;
             }
             // See if column has changed properties in "to" table.
-            const changedProperties = this.diffColumn(column, toTable.getColumn(column.name));
+            const changedProperties = this.diffColumn(column, toTable.getColumn(column.name), tableName);
             if (changedProperties.size === 0) {
                 continue;
             }
@@ -138,6 +145,7 @@ class SchemaComparator {
                 column: toTable.getColumn(column.name),
                 changedProperties,
             };
+            this.log(`column ${tableDifferences.name}.${column.name} changed`, { changedProperties });
             changes++;
         }
         this.detectColumnRenamings(tableDifferences);
@@ -149,6 +157,7 @@ class SchemaComparator {
                 continue;
             }
             tableDifferences.addedIndexes[index.keyName] = index;
+            this.log(`index ${index.keyName} added to table ${tableDifferences.name}`, { index });
             changes++;
         }
         // See if there are any removed indexes in "to" table
@@ -156,6 +165,7 @@ class SchemaComparator {
             // See if index is removed in "to" table.
             if ((index.primary && !toTable.hasPrimaryKey()) || !index.primary && !toTable.hasIndex(index.keyName)) {
                 tableDifferences.removedIndexes[index.keyName] = index;
+                this.log(`index ${index.keyName} removed from table ${tableDifferences.name}`);
                 changes++;
                 continue;
             }
@@ -165,6 +175,7 @@ class SchemaComparator {
                 continue;
             }
             tableDifferences.changedIndexes[index.keyName] = toTableIndex;
+            this.log(`index ${index.keyName} changed in table ${tableDifferences.name}`, { fromTableIndex: index, toTableIndex });
             changes++;
         }
         this.detectIndexRenamings(tableDifferences);
@@ -176,12 +187,14 @@ class SchemaComparator {
                 continue;
             }
             tableDifferences.addedChecks[check.name] = check;
+            this.log(`check constraint ${check.name} added to table ${tableDifferences.name}`, { check });
             changes++;
         }
         // See if there are any removed checks in "to" table
         for (const check of fromTableChecks) {
             if (!toTable.hasCheck(check.name)) {
                 tableDifferences.removedChecks[check.name] = check;
+                this.log(`check constraint ${check.name} removed from table ${tableDifferences.name}`);
                 changes++;
                 continue;
             }
@@ -190,6 +203,7 @@ class SchemaComparator {
             if (!this.diffCheck(check, toTableCheck)) {
                 continue;
             }
+            this.log(`check constraint ${check.name} changed in table ${tableDifferences.name}`, { fromTableCheck: check, toTableCheck });
             tableDifferences.changedChecks[check.name] = toTableCheck;
             changes++;
         }
@@ -202,6 +216,7 @@ class SchemaComparator {
                     delete toForeignKeys[toConstraint.constraintName];
                 }
                 else if (fromConstraint.constraintName.toLowerCase() === toConstraint.constraintName.toLowerCase()) {
+                    this.log(`FK constraint ${fromConstraint.constraintName} changed in table ${tableDifferences.name}`, { fromConstraint, toConstraint });
                     tableDifferences.changedForeignKeys[toConstraint.constraintName] = toConstraint;
                     changes++;
                     delete fromForeignKeys[fromConstraint.constraintName];
@@ -211,10 +226,12 @@ class SchemaComparator {
         }
         for (const fromConstraint of Object.values(fromForeignKeys)) {
             tableDifferences.removedForeignKeys[fromConstraint.constraintName] = fromConstraint;
+            this.log(`FK constraint ${fromConstraint.constraintName} removed from table ${tableDifferences.name}`);
             changes++;
         }
         for (const toConstraint of Object.values(toForeignKeys)) {
             tableDifferences.addedForeignKeys[toConstraint.constraintName] = toConstraint;
+            this.log(`FK constraint ${toConstraint.constraintName} added from table ${tableDifferences.name}`, { constraint: toConstraint });
             changes++;
         }
         return changes ? tableDifferences : false;
@@ -249,6 +266,7 @@ class SchemaComparator {
             tableDifferences.renamedColumns[removedColumnName] = addedColumn;
             delete tableDifferences.addedColumns[addedColumnName];
             delete tableDifferences.removedColumns[removedColumnName];
+            this.log(`renamed column detected in table ${tableDifferences.name}`, { old: removedColumnName, new: addedColumnName });
         }
     }
     /**
@@ -282,6 +300,7 @@ class SchemaComparator {
             tableDifferences.renamedIndexes[removedIndexName] = addedIndex;
             delete tableDifferences.addedIndexes[addedIndexName];
             delete tableDifferences.removedIndexes[removedIndexName];
+            this.log(`renamed index detected in table ${tableDifferences.name}`, { old: removedIndexName, new: addedIndexName });
         }
     }
     diffForeignKey(key1, key2) {
@@ -294,7 +313,10 @@ class SchemaComparator {
         if (key1.referencedTableName !== key2.referencedTableName) {
             return true;
         }
-        const rule = (key, method) => (key[method] ?? this.platform.getDefaultIntegrityRule()).toLowerCase();
+        const defaultRule = ['restrict', 'no action'];
+        const rule = (key, method) => {
+            return (key[method] ?? defaultRule[0]).toLowerCase().replace(defaultRule[1], defaultRule[0]);
+        };
         const compare = (method) => rule(key1, method) === rule(key2, method);
         return !compare('updateRule') || !compare('deleteRule');
     }
@@ -302,34 +324,53 @@ class SchemaComparator {
      * Returns the difference between the columns
      * If there are differences this method returns field2, otherwise the boolean false.
      */
-    diffColumn(column1, column2) {
+    diffColumn(column1, column2, tableName) {
         const changedProperties = new Set();
         const prop1 = this.mapColumnToProperty({ ...column1, autoincrement: false });
         const prop2 = this.mapColumnToProperty({ ...column2, autoincrement: false });
-        const columnType1 = column1.mappedType.getColumnType(prop1, this.platform);
-        const columnType2 = column2.mappedType.getColumnType(prop2, this.platform);
-        if (columnType1 !== columnType2) {
+        const columnType1 = column1.mappedType.getColumnType(prop1, this.platform).toLowerCase();
+        const columnType2 = column2.mappedType.getColumnType(prop2, this.platform).toLowerCase();
+        const log = (msg, params) => {
+            if (tableName) {
+                const copy = core_1.Utils.copy(params);
+                core_1.Utils.dropUndefinedProperties(copy);
+                this.log(msg, copy);
+            }
+        };
+        if (columnType1 !== columnType2 &&
+            !(column1.ignoreSchemaChanges?.includes('type') ||
+                column2.ignoreSchemaChanges?.includes('type'))) {
+            log(`'type' changed for column ${tableName}.${column1.name}`, { columnType1, columnType2 });
             changedProperties.add('type');
         }
         if (column1.nullable !== column2.nullable) {
+            log(`'nullable' changed for column ${tableName}.${column1.name}`, { column1, column2 });
             changedProperties.add('nullable');
         }
         if (!!column1.autoincrement !== !!column2.autoincrement) {
+            log(`'autoincrement' changed for column ${tableName}.${column1.name}`, { column1, column2 });
             changedProperties.add('autoincrement');
         }
         if (column1.unsigned !== column2.unsigned && this.platform.supportsUnsigned()) {
+            log(`'unsigned' changed for column ${tableName}.${column1.name}`, { column1, column2 });
             changedProperties.add('unsigned');
         }
         if (!this.hasSameDefaultValue(column1, column2)) {
+            log(`'default' changed for column ${tableName}.${column1.name}`, { column1, column2 });
             changedProperties.add('default');
         }
         if (this.diffComment(column1.comment, column2.comment)) {
+            log(`'comment' changed for column ${tableName}.${column1.name}`, { column1, column2 });
             changedProperties.add('comment');
         }
         if (this.diffEnumItems(column1.enumItems, column2.enumItems)) {
+            log(`'enumItems' changed for column ${tableName}.${column1.name}`, { column1, column2 });
             changedProperties.add('enumItems');
         }
-        if ((column1.extra || '').toLowerCase() !== (column2.extra || '').toLowerCase()) {
+        if ((column1.extra || '').toLowerCase() !== (column2.extra || '').toLowerCase() &&
+            !(column1.ignoreSchemaChanges?.includes('extra') ||
+                column2.ignoreSchemaChanges?.includes('extra'))) {
+            log(`'extra' changed for column ${tableName}.${column1.name}`, { column1, column2 });
             changedProperties.add('extra');
         }
         return changedProperties;
@@ -347,8 +388,8 @@ class SchemaComparator {
      * Compares index1 with index2 and returns index2 if there are any differences or false in case there are no differences.
      */
     diffIndex(index1, index2) {
-        // if one of them is a custom expression, compare only by name
-        if (index1.expression || index2.expression) {
+        // if one of them is a custom expression or full text index, compare only by name
+        if (index1.expression || index2.expression || index1.type === 'fulltext' || index2.type === 'fulltext') {
             return index1.keyName !== index2.keyName;
         }
         return !this.isIndexFulfilledBy(index1, index2) || !this.isIndexFulfilledBy(index2, index1);
@@ -384,7 +425,8 @@ class SchemaComparator {
         return index1.primary === index2.primary && index1.unique === index2.unique;
     }
     diffCheck(check1, check2) {
-        return check1.expression !== check2.expression;
+        const unquote = (str) => str?.replace(/['"`]/g, '');
+        return unquote(check1.expression) !== unquote(check2.expression);
     }
     hasSameDefaultValue(from, to) {
         if (from.default == null || from.default.toString().toLowerCase() === 'null' || from.default.toString().startsWith('nextval(')) {
@@ -423,5 +465,11 @@ class SchemaComparator {
             scale: match ? +match[2] : column.scale,
         };
     }
+    log(message, params) {
+        if (params) {
+            message += ' ' + (0, util_1.inspect)(params);
+        }
+        this.logger.log('schema', message);
+    }
 }
 exports.SchemaComparator = SchemaComparator;

package/{dist/schema → schema}/SchemaGenerator.d.ts

@@ -1,19 +1,17 @@
+import type { MikroORM } from '@mikro-orm/core';
 import { AbstractSchemaGenerator } from '@mikro-orm/core';
 import type { SchemaDifference } from '../typings';
 import { DatabaseSchema } from './DatabaseSchema';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
-import { SqlEntityManager } from '../SqlEntityManager';
 /**
  * Should be renamed to `SqlSchemaGenerator` in v6
  */
 export declare class SchemaGenerator extends AbstractSchemaGenerator<AbstractSqlDriver> {
     private readonly helper;
-    private readonly knex;
     private readonly options;
-    /**
-     * @deprecated For back compatibility, we also support EM as the parameter.
-     */
-    constructor(em: SqlEntityManager);
+    protected lastEnsuredDatabase?: string;
+    static register(orm: MikroORM): void;
+    /** @deprecated use `dropSchema` and `createSchema` commands respectively */
     generate(): Promise<string>;
     createSchema(options?: {
         wrap?: boolean;
@@ -34,6 +32,10 @@ export declare class SchemaGenerator extends AbstractSchemaGenerator<AbstractSql
         dropDb?: boolean;
         schema?: string;
     }): Promise<void>;
+    clearDatabase(options?: {
+        schema?: string;
+        truncate?: boolean;
+    }): Promise<void>;
     getDropSchemaSQL(options?: {
         wrap?: boolean;
         dropMigrationsTable?: boolean;
@@ -86,7 +88,7 @@ export declare class SchemaGenerator extends AbstractSchemaGenerator<AbstractSql
     dropDatabase(name: string): Promise<void>;
     execute(sql: string, options?: {
         wrap?: boolean;
-    }): Promise<void>;
+    }): Promise<undefined>;
     private wrapSchema;
     private createSchemaBuilder;
     private createTable;
@@ -95,7 +97,7 @@ export declare class SchemaGenerator extends AbstractSchemaGenerator<AbstractSql
     private createCheck;
     private dropCheck;
     private dropTable;
-    private configureColumn;
     private createForeignKeys;
     private dump;
+    private get knex();
 }

package/{dist/schema → schema}/SchemaGenerator.js

@@ -4,20 +4,19 @@ exports.SchemaGenerator = void 0;
 const core_1 = require("@mikro-orm/core");
 const DatabaseSchema_1 = require("./DatabaseSchema");
 const SchemaComparator_1 = require("./SchemaComparator");
-const SqlEntityManager_1 = require("../SqlEntityManager");
 /**
  * Should be renamed to `SqlSchemaGenerator` in v6
  */
 class SchemaGenerator extends core_1.AbstractSchemaGenerator {
-    /**
-     * `orm.getSchemaGenerator()` should be preferred way of getting the SchemaGenerator instance.
-     */
-    constructor(driver) {
-        super(driver instanceof SqlEntityManager_1.SqlEntityManager ? driver.getDriver() : driver);
+    constructor() {
+        super(...arguments);
         this.helper = this.platform.getSchemaHelper();
-        this.knex = this.connection.getKnex();
         this.options = this.config.get('schemaGenerator');
     }
+    static register(orm) {
+        orm.config.registerExtension('@mikro-orm/schema-generator', new SchemaGenerator(orm.em));
+    }
+    /** @deprecated use `dropSchema` and `createSchema` commands respectively */
     async generate() {
         const [dropSchema, createSchema] = await Promise.all([
             this.getDropSchemaSQL({ wrap: false }),
@@ -35,7 +34,11 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
      */
     async ensureDatabase() {
         const dbName = this.config.get('dbName');
+        if (this.lastEnsuredDatabase === dbName) {
+            return true;
+        }
         const exists = await this.helper.databaseExists(this.connection, dbName);
+        this.lastEnsuredDatabase = dbName;
         if (!exists) {
             this.config.set('dbName', this.helper.getManagementDbName());
             await this.driver.reconnect();
@@ -48,7 +51,8 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
     }
     getTargetSchema(schema) {
         const metadata = this.getOrderedMetadata(schema);
-        return DatabaseSchema_1.DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schema ?? this.platform.getDefaultSchemaName());
+        const schemaName = schema ?? this.config.get('schema') ?? this.platform.getDefaultSchemaName();
+        return DatabaseSchema_1.DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schemaName);
     }
     async getCreateSchemaSQL(options = {}) {
         const wrap = options.wrap ?? this.options.disableForeignKeys;
@@ -69,7 +73,6 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         return this.wrapSchema(ret, { wrap });
     }
     async dropSchema(options = {}) {
-        options.wrap ?? (options.wrap = true);
         if (options.dropDb) {
             const name = this.config.get('dbName');
             return this.dropDatabase(name);
@@ -77,10 +80,44 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         const sql = await this.getDropSchemaSQL(options);
         await this.execute(sql);
     }
+    async clearDatabase(options) {
+        // truncate by default, so no value is considered as true
+        /* istanbul ignore if */
+        if (options?.truncate === false) {
+            return super.clearDatabase(options);
+        }
+        await this.execute(this.helper.disableForeignKeysSQL());
+        for (const meta of this.getOrderedMetadata(options?.schema).reverse()) {
+            await this.driver.createQueryBuilder(meta.className, this.em?.getTransactionContext(), 'write', false)
+                .withSchema(options?.schema)
+                .truncate();
+        }
+        await this.execute(this.helper.enableForeignKeysSQL());
+        if (this.em) {
+            const allowGlobalContext = this.config.get('allowGlobalContext');
+            this.config.set('allowGlobalContext', true);
+            this.em.clear();
+            this.config.set('allowGlobalContext', allowGlobalContext);
+        }
+    }
     async getDropSchemaSQL(options = {}) {
+        await this.ensureDatabase();
         const wrap = options.wrap ?? this.options.disableForeignKeys;
         const metadata = this.getOrderedMetadata(options.schema).reverse();
+        const schema = await DatabaseSchema_1.DatabaseSchema.create(this.connection, this.platform, this.config, options.schema);
         let ret = '';
+        // remove FKs explicitly if we can't use cascading statement and we don't disable FK checks (we need this for circular relations)
+        for (const meta of metadata) {
+            const table = schema.getTable(meta.tableName);
+            if (!this.platform.usesCascadeStatement() && table && !wrap) {
+                for (const fk of Object.values(table.getForeignKeys())) {
+                    const builder = this.createSchemaBuilder(table.schema).alterTable(table.name, tbl => {
+                        tbl.dropForeign(fk.columnNames, fk.constraintName);
+                    });
+                    ret += await this.dump(builder, '\n');
+                }
+            }
+        }
         for (const meta of metadata) {
             ret += await this.dump(this.dropTable(meta.collection, this.getSchemaName(meta, options)), '\n');
         }
@@ -90,20 +127,23 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         return this.wrapSchema(ret + '\n', { wrap });
     }
     getSchemaName(meta, options) {
+        const schemaName = options.schema ?? this.config.get('schema');
         /* istanbul ignore next */
-        return meta.schema === '*' ? options.schema : meta.schema;
+        return meta.schema && meta.schema === '*' ? schemaName : (meta.schema ?? schemaName);
     }
     async updateSchema(options = {}) {
         const sql = await this.getUpdateSchemaSQL(options);
         await this.execute(sql);
     }
     async getUpdateSchemaSQL(options = {}) {
+        await this.ensureDatabase();
         const { fromSchema, toSchema } = await this.prepareSchemaForComparison(options);
         const comparator = new SchemaComparator_1.SchemaComparator(this.platform);
         const diffUp = comparator.compare(fromSchema, toSchema);
         return this.diffToSQL(diffUp, options);
     }
     async getUpdateSchemaMigrationSQL(options = {}) {
+        await this.ensureDatabase();
         const { fromSchema, toSchema } = await this.prepareSchemaForComparison(options);
         const comparator = new SchemaComparator_1.SchemaComparator(this.platform);
         const diffUp = comparator.compare(fromSchema, toSchema);
@@ -240,7 +280,7 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
             }
             for (const column of Object.values(diff.addedColumns)) {
                 const col = this.helper.createTableColumn(table, column, diff.fromTable);
-                this.configureColumn(column, col);
+                this.helper.configureColumn(column, col, this.knex);
                 const foreignKey = Object.values(diff.addedForeignKeys).find(fk => fk.columnNames.length === 1 && fk.columnNames[0] === column.name);
                 if (foreignKey && this.options.createForeignKeyConstraints) {
                     delete diff.addedForeignKeys[foreignKey.constraintName];
@@ -262,7 +302,7 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
                     continue;
                 }
                 const col = this.helper.createTableColumn(table, column, diff.fromTable, changedProperties).alter();
-                this.configureColumn(column, col, changedProperties);
+                this.helper.configureColumn(column, col, this.knex, changedProperties);
             }
             for (const { column } of Object.values(diff.changedColumns).filter(diff => diff.changedProperties.has('autoincrement'))) {
                 this.helper.pushTableQuery(table, this.helper.getAlterColumnAutoincrement(tableName, column));
@@ -274,7 +314,7 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
                 this.helper.pushTableQuery(table, this.helper.getChangeColumnCommentSQL(tableName, column));
             }
             for (const [oldColumnName, column] of Object.entries(diff.renamedColumns)) {
-                this.helper.pushTableQuery(table, this.helper.getRenameColumnSQL(tableName, oldColumnName, column));
+                this.helper.pushTableQuery(table, this.helper.getRenameColumnSQL(tableName, oldColumnName, column, schemaName));
             }
             for (const foreignKey of Object.values(diff.addedForeignKeys)) {
                 this.createForeignKey(table, foreignKey);
@@ -283,15 +323,15 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
                 this.createForeignKey(table, foreignKey);
             }
             for (const index of Object.values(diff.addedIndexes)) {
-                this.createIndex(table, index, diff.name);
+                this.createIndex(table, index, diff.toTable);
             }
             for (const index of Object.values(diff.changedIndexes)) {
-                this.createIndex(table, index, diff.name, true);
+                this.createIndex(table, index, diff.toTable, true);
             }
             for (const [oldIndexName, index] of Object.entries(diff.renamedIndexes)) {
                 if (index.unique) {
                     this.dropIndex(table, index, oldIndexName);
-                    this.createIndex(table, index, diff.name);
+                    this.createIndex(table, index, diff.toTable);
                 }
                 else {
                     this.helper.pushTableQuery(table, this.helper.getRenameIndexSQL(diff.name, index, oldIndexName));
@@ -304,7 +344,8 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
                 this.createCheck(table, check);
             }
             if ('changedComment' in diff) {
-                table.comment(diff.changedComment ?? '');
+                const comment = diff.changedComment ? this.platform.quoteValue(diff.changedComment).replace(/^'|'$/g, '') : '';
+                table.comment(comment);
             }
         }));
         return ret;
@@ -325,9 +366,14 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
     async execute(sql, options = {}) {
         options.wrap ?? (options.wrap = false);
         const lines = this.wrapSchema(sql, options).split('\n').filter(i => i.trim());
-        for (const line of lines) {
-            await this.driver.execute(line);
+        if (lines.length === 0) {
+            return;
         }
+        if (this.platform.supportsMultipleStatements()) {
+            const query = lines.join('\n');
+            return void await this.driver.execute(query);
+        }
+        await core_1.Utils.runSerial(lines, line => this.driver.execute(line));
     }
     wrapSchema(sql, options = {}) {
         options.wrap ?? (options.wrap = this.options.disableForeignKeys);
@@ -350,16 +396,18 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         return this.createSchemaBuilder(tableDef.schema).createTable(tableDef.name, table => {
             tableDef.getColumns().forEach(column => {
                 const col = this.helper.createTableColumn(table, column, tableDef);
-                this.configureColumn(column, col);
+                this.helper.configureColumn(column, col, this.knex);
             });
             for (const index of tableDef.getIndexes()) {
-                this.createIndex(table, index, tableDef.name, !tableDef.getColumns().some(c => c.autoincrement));
+                const createPrimary = !tableDef.getColumns().some(c => c.autoincrement && c.primary) || this.helper.hasNonDefaultPrimaryKeyName(tableDef);
+                this.createIndex(table, index, tableDef, createPrimary);
             }
             for (const check of tableDef.getChecks()) {
                 this.createCheck(table, check);
             }
             if (tableDef.comment) {
-                table.comment(tableDef.comment);
+                const comment = this.platform.quoteValue(tableDef.comment).replace(/^'|'$/g, '');
+                table.comment(comment);
             }
             if (!this.helper.supportsSchemaConstraints()) {
                 for (const fk of Object.values(tableDef.getForeignKeys())) {
@@ -369,13 +417,12 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
             this.helper.finalizeTable(table, this.config.get('charset'), this.config.get('collate'));
         });
     }
-    createIndex(table, index, tableName, createPrimary = false) {
+    createIndex(table, index, tableDef, createPrimary = false) {
         if (index.primary && !createPrimary) {
             return;
         }
         if (index.primary) {
-            /* istanbul ignore next */
-            const keyName = tableName.includes('.') ? tableName.split('.').pop() + '_pkey' : undefined;
+            const keyName = this.helper.hasNonDefaultPrimaryKeyName(tableDef) ? index.keyName : undefined;
             table.primary(index.columnNames, keyName);
         }
         else if (index.unique) {
@@ -384,6 +431,12 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         else if (index.expression) {
             this.helper.pushTableQuery(table, index.expression);
         }
+        else if (index.type === 'fulltext') {
+            const columns = index.columnNames.map(name => ({ name, type: tableDef.getColumn(name).type }));
+            if (this.platform.supportsCreatingFullTextIndex()) {
+                this.helper.pushTableQuery(table, this.platform.getFullTextIndexExpression(index.keyName, tableDef.schema, tableDef.name, columns));
+            }
+        }
         else {
             table.index(index.columnNames, index.keyName, index.type);
         }
@@ -412,9 +465,6 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         }
         return builder;
     }
-    configureColumn(column, col, changedProperties) {
-        return this.helper.configureColumn(column, col, this.knex, changedProperties);
-    }
     createForeignKeys(table, tableDef, schema) {
         if (!this.helper.supportsSchemaConstraints()) {
             return;
@@ -433,5 +483,8 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         const tmp = dump.replace(/pragma table_.+/ig, '').replace(/\n\n+/g, '\n').trim();
         return tmp ? tmp + append : '';
     }
+    get knex() {
+        return this.connection.getKnex();
+    }
 }
 exports.SchemaGenerator = SchemaGenerator;

package/{dist/schema → schema}/SchemaHelper.d.ts

@@ -2,8 +2,9 @@ import type { Knex } from 'knex';
 import type { Connection, Dictionary } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
-import type { Check, Column, Index, TableDifference } from '../typings';
+import type { Check, Column, Index, Table, TableDifference } from '../typings';
 import type { DatabaseTable } from './DatabaseTable';
+import type { DatabaseSchema } from './DatabaseSchema';
 export declare abstract class SchemaHelper {
     protected readonly platform: AbstractSqlPlatform;
     constructor(platform: AbstractSqlPlatform);
@@ -13,23 +14,27 @@ export declare abstract class SchemaHelper {
     getSchemaEnd(): string;
     finalizeTable(table: Knex.TableBuilder, charset: string, collate?: string): void;
     supportsSchemaConstraints(): boolean;
-    getPrimaryKeys(connection: AbstractSqlConnection, indexes: Index[], tableName: string, schemaName?: string): Promise<string[]>;
+    getPrimaryKeys(connection: AbstractSqlConnection, indexes: Index[] | undefined, tableName: string, schemaName?: string): Promise<string[]>;
     getForeignKeys(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Dictionary>;
+    protected getTableKey(t: Table): string;
     getEnumDefinitions(connection: AbstractSqlConnection, checks: Check[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[]): Promise<void>;
     getListTablesSQL(schemaName?: string): string;
-    getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column): string;
+    getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
     getCreateIndexSQL(tableName: string, index: Index): string;
     getDropIndexSQL(tableName: string, index: Index): string;
     getRenameIndexSQL(tableName: string, index: Index, oldIndexName: string): string;
+    hasNonDefaultPrimaryKeyName(table: DatabaseTable): boolean;
     createTableColumn(table: Knex.TableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>): Knex.ColumnBuilder;
     configureColumn(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
     configureColumnDefault(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string;
     getAlterColumnAutoincrement(tableName: string, column: Column): string;
     getChangeColumnCommentSQL(tableName: string, to: Column): string;
+    getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
     getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Column[]>;
     getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Index[]>;
-    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Check[]>;
+    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName?: string, columns?: Column[]): Promise<Check[]>;
     protected mapIndexes(indexes: Index[]): Promise<Index[]>;
     getForeignKeysSQL(tableName: string, schemaName?: string): string;
     mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;