@mikro-orm/knex 6.0.0-dev.1 → 6.0.0-dev.100

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

@@ -1,14 +1,19 @@
 "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.
  */
 class SchemaComparator {
+    platform;
+    helper;
+    logger;
     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 +110,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 +133,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 +148,7 @@ class SchemaComparator {
                 column: toTable.getColumn(column.name),
                 changedProperties,
             };
+            this.log(`column ${tableDifferences.name}.${column.name} changed`, { changedProperties });
             changes++;
         }
         this.detectColumnRenamings(tableDifferences);
@@ -149,6 +160,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 +168,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 +178,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 +190,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 +206,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 +219,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 +229,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 +269,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 +303,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 +316,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 +327,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 +391,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 +428,10 @@ class SchemaComparator {
         return index1.primary === index2.primary && index1.unique === index2.unique;
     }
     diffCheck(check1, check2) {
-        return check1.expression !== check2.expression;
+        // check constraint definition might be normalized by the driver,
+        // e.g. quotes might be added (https://github.com/mikro-orm/mikro-orm/issues/3827)
+        const simplify = (str) => str?.replace(/['"`()]/g, '').toLowerCase();
+        return simplify(check1.expression) !== simplify(check2.expression);
     }
     hasSameDefaultValue(from, to) {
         if (from.default == null || from.default.toString().toLowerCase() === 'null' || from.default.toString().startsWith('nextval(')) {
@@ -395,6 +442,11 @@ class SchemaComparator {
             const defaultValueTo = !['0', 'false', 'f', 'n', 'no', 'off'].includes('' + to.default);
             return defaultValueFrom === defaultValueTo;
         }
+        if (to.mappedType instanceof core_1.JsonType) {
+            const defaultValueFrom = (0, core_1.parseJsonSafe)(from.default.replace(/^'(.*)'$/, '$1'));
+            const defaultValueTo = (0, core_1.parseJsonSafe)(to.default?.replace(/^'(.*)'$/, '$1'));
+            return core_1.Utils.equals(defaultValueFrom, defaultValueTo);
+        }
         if (to.mappedType instanceof core_1.DateTimeType && from.default && to.default) {
             // normalize now/current_timestamp defaults, also remove `()` from the end of default expression
             const defaultValueFrom = from.default.toLowerCase().replace('current_timestamp', 'now').replace(/\(\)$/, '');
@@ -423,5 +475,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}/SchemaHelper.d.ts

@@ -1,9 +1,10 @@
 import type { Knex } from 'knex';
-import type { Connection, Dictionary } from '@mikro-orm/core';
+import { type Connection, type 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 { CheckDef, Column, IndexDef, 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,24 +14,30 @@ 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: IndexDef[] | undefined, tableName: string, schemaName?: string): Promise<string[]>;
     getForeignKeys(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Dictionary>;
-    getEnumDefinitions(connection: AbstractSqlConnection, checks: Check[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
+    protected getTableKey(t: Table): string;
+    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
+    getDropNativeEnumSQL(name: string, schema?: string): string;
+    getAlterNativeEnumSQL(name: string, schema?: string, value?: string): string;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
     getListTablesSQL(schemaName?: string): string;
-    getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column): string;
-    getCreateIndexSQL(tableName: string, index: Index): string;
-    getDropIndexSQL(tableName: string, index: Index): string;
-    getRenameIndexSQL(tableName: string, index: Index, oldIndexName: string): string;
+    getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
+    getCreateIndexSQL(tableName: string, index: IndexDef): string;
+    getDropIndexSQL(tableName: string, index: IndexDef): string;
+    getRenameIndexSQL(tableName: string, index: IndexDef, 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;
+    getAlterColumnAutoincrement(tableName: string, column: Column, schemaName?: string): string;
+    getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): 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[]>;
-    protected mapIndexes(indexes: Index[]): Promise<Index[]>;
+    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<IndexDef[]>;
+    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName?: string, columns?: Column[]): Promise<CheckDef[]>;
+    protected mapIndexes(indexes: IndexDef[]): Promise<IndexDef[]>;
     getForeignKeysSQL(tableName: string, schemaName?: string): string;
     mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;
     normalizeDefaultValue(defaultValue: string, length?: number, defaultValues?: Dictionary<string[]>): string | number;

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaHelper = void 0;
 const core_1 = require("@mikro-orm/core");
 class SchemaHelper {
+    platform;
     constructor(platform) {
         this.platform = platform;
     }
@@ -24,25 +25,57 @@ class SchemaHelper {
     supportsSchemaConstraints() {
         return true;
     }
-    async getPrimaryKeys(connection, indexes, tableName, schemaName) {
-        const pk = indexes.find(i => i.primary);
-        return pk ? pk.columnNames : [];
+    async getPrimaryKeys(connection, indexes = [], tableName, schemaName) {
+        const pks = indexes.filter(i => i.primary).map(pk => pk.columnNames);
+        return core_1.Utils.flatten(pks);
     }
     async getForeignKeys(connection, tableName, schemaName) {
         const fks = await connection.execute(this.getForeignKeysSQL(tableName, schemaName));
         return this.mapForeignKeys(fks, tableName, schemaName);
     }
+    getTableKey(t) {
+        const unquote = (str) => str.replace(/['"`]/g, '');
+        const parts = t.table_name.split('.');
+        if (parts.length > 1) {
+            return `${unquote(parts[0])}.${unquote(parts[1])}`;
+        }
+        if (t.schema_name) {
+            return `${unquote(t.schema_name)}.${unquote(t.table_name)}`;
+        }
+        return unquote(t.table_name);
+    }
     async getEnumDefinitions(connection, checks, tableName, schemaName) {
         return {};
     }
+    getDropNativeEnumSQL(name, schema) {
+        throw new Error('Not supported by given driver');
+    }
+    getAlterNativeEnumSQL(name, schema, value) {
+        throw new Error('Not supported by given driver');
+    }
+    async loadInformationSchema(schema, connection, tables, schemas) {
+        for (const t of tables) {
+            const table = schema.addTable(t.table_name, t.schema_name);
+            table.comment = t.table_comment;
+            const cols = await this.getColumns(connection, table.name, table.schema);
+            const indexes = await this.getIndexes(connection, table.name, table.schema);
+            const checks = await this.getChecks(connection, table.name, table.schema, cols);
+            const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema);
+            const fks = await this.getForeignKeys(connection, table.name, table.schema);
+            const enums = await this.getEnumDefinitions(connection, checks, table.name, table.schema);
+            table.init(cols, indexes, checks, pks, fks, enums);
+        }
+    }
     getListTablesSQL(schemaName) {
         throw new Error('Not supported by given driver');
     }
-    getRenameColumnSQL(tableName, oldColumnName, to) {
+    getRenameColumnSQL(tableName, oldColumnName, to, schemaName) {
         tableName = this.platform.quoteIdentifier(tableName);
         oldColumnName = this.platform.quoteIdentifier(oldColumnName);
         const columnName = this.platform.quoteIdentifier(to.name);
-        return `alter table ${tableName} rename column ${oldColumnName} to ${columnName}`;
+        const schemaReference = (schemaName !== undefined && schemaName !== 'public') ? ('"' + schemaName + '".') : '';
+        const tableReference = schemaReference + tableName;
+        return `alter table ${tableReference} rename column ${oldColumnName} to ${columnName}`;
     }
     getCreateIndexSQL(tableName, index) {
         /* istanbul ignore if */
@@ -59,13 +92,22 @@ class SchemaHelper {
     getRenameIndexSQL(tableName, index, oldIndexName) {
         return [this.getDropIndexSQL(tableName, { ...index, keyName: oldIndexName }), this.getCreateIndexSQL(tableName, index)].join(';\n');
     }
+    hasNonDefaultPrimaryKeyName(table) {
+        const pkIndex = table.getPrimaryKey();
+        if (!pkIndex || !this.platform.supportsCustomPrimaryKeyNames()) {
+            return false;
+        }
+        const defaultName = this.platform.getDefaultPrimaryName(table.name, pkIndex.columnNames);
+        return pkIndex?.keyName !== defaultName;
+    }
     createTableColumn(table, column, fromTable, changedProperties) {
         const compositePK = fromTable.getPrimaryKey()?.composite;
         if (column.autoincrement && !compositePK && (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
+            const primaryKey = !changedProperties && !this.hasNonDefaultPrimaryKeyName(fromTable);
             if (column.mappedType instanceof core_1.BigIntType) {
-                return table.bigIncrements(column.name, { primaryKey: !changedProperties });
+                return table.bigIncrements(column.name, { primaryKey });
             }
-            return table.increments(column.name, { primaryKey: !changedProperties });
+            return table.increments(column.name, { primaryKey });
         }
         if (column.mappedType instanceof core_1.EnumType && column.enumItems?.every(item => core_1.Utils.isString(item))) {
             return table.enum(column.name, column.enumItems);
@@ -87,26 +129,29 @@ class SchemaHelper {
             core_1.Utils.runIfNotEmpty(() => col.defaultTo(column.default == null ? null : knex.raw(column.default)), guard('default'));
         }
         else {
-            core_1.Utils.runIfNotEmpty(() => col.defaultTo(column.default == null ? null : knex.raw(column.default)), column.default !== undefined);
+            core_1.Utils.runIfNotEmpty(() => col.defaultTo(knex.raw(column.default)), column.default != null && column.default !== 'null');
         }
         return col;
     }
     getPreAlterTable(tableDiff, safe) {
         return '';
     }
-    getAlterColumnAutoincrement(tableName, column) {
+    getAlterColumnAutoincrement(tableName, column, schemaName) {
         return '';
     }
-    getChangeColumnCommentSQL(tableName, to) {
+    getChangeColumnCommentSQL(tableName, to, schemaName) {
         return '';
     }
+    async getNamespaces(connection) {
+        return [];
+    }
     async getColumns(connection, tableName, schemaName) {
         throw new Error('Not supported by given driver');
     }
     async getIndexes(connection, tableName, schemaName) {
         throw new Error('Not supported by given driver');
     }
-    async getChecks(connection, tableName, schemaName) {
+    async getChecks(connection, tableName, schemaName, columns) {
         throw new Error('Not supported by given driver');
     }
     async mapIndexes(indexes) {

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

@@ -1,20 +1,12 @@
-import { AbstractSchemaGenerator } from '@mikro-orm/core';
+import { AbstractSchemaGenerator, type MikroORM, type ISchemaGenerator } 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> {
+export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<AbstractSqlDriver> implements ISchemaGenerator {
     private readonly helper;
-    private readonly knex;
     private readonly options;
-    /**
-     * @deprecated For back compatibility, we also support EM as the parameter.
-     */
-    constructor(em: SqlEntityManager);
-    generate(): Promise<string>;
+    protected lastEnsuredDatabase?: string;
+    static register(orm: MikroORM): void;
     createSchema(options?: {
         wrap?: boolean;
         schema?: string;
@@ -34,6 +26,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;
@@ -83,7 +79,7 @@ export declare class SchemaGenerator extends AbstractSchemaGenerator<AbstractSql
      * creates new database and connects to it
      */
     createDatabase(name: string): Promise<void>;
-    dropDatabase(name: string): Promise<void>;
+    dropDatabase(name?: string): Promise<void>;
     execute(sql: string, options?: {
         wrap?: boolean;
     }): Promise<void>;
@@ -95,7 +91,8 @@ export declare class SchemaGenerator extends AbstractSchemaGenerator<AbstractSql
     private createCheck;
     private dropCheck;
     private dropTable;
-    private configureColumn;
     private createForeignKeys;
     private dump;
+    private get knex();
 }
+export { SqlSchemaGenerator as SchemaGenerator };