@mikro-orm/knex 6.1.13-dev.3 → 6.1.13-dev.30

package/query/QueryBuilder.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { inspect } from 'util';
 import type { Knex } from 'knex';
-import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityName, type EntityProperty, type FlushMode, type GroupOperator, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryResult, type RequiredEntityData } from '@mikro-orm/core';
+import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityName, type EntityProperty, type FlushMode, type GroupOperator, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryOrderMap, type QueryResult, type RequiredEntityData } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
 import { type Alias, QueryBuilderHelper } from './QueryBuilderHelper';
@@ -32,13 +32,12 @@ export interface ExecuteOptions {
  * ```
  */
 export declare class QueryBuilder<T extends object = AnyEntity> {
-    #private;
-    private readonly metadata;
-    private readonly driver;
-    private readonly context?;
-    private connectionType?;
-    private readonly em?;
-    private readonly loggerContext?;
+    protected readonly metadata: MetadataStorage;
+    protected readonly driver: AbstractSqlDriver;
+    protected readonly context?: Knex.Transaction<any, any[]> | undefined;
+    protected connectionType?: ConnectionType | undefined;
+    protected em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection, AbstractSqlPlatform>> | undefined;
+    protected loggerContext?: (LoggingOptions & Dictionary) | undefined;
     get mainAlias(): Alias<T>;
     get alias(): string;
     get helper(): QueryBuilderHelper;
@@ -56,40 +55,51 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     _populateMap: Dictionary<string>;
     /** @internal */
     readonly rawFragments: Set<string>;
-    private aliasCounter;
-    private flags;
-    private finalized;
-    private _joins;
-    private _explicitAlias;
-    private _schema?;
-    private _cond;
-    private _data;
-    private _orderBy;
-    private _groupBy;
-    private _having;
-    private _returning?;
-    private _onConflict?;
-    private _limit?;
-    private _offset?;
-    private _distinctOn?;
-    private _joinedProps;
-    private _cache?;
-    private _indexHint?;
-    private _comments;
-    private _hintComments;
-    private flushMode?;
-    private lockMode?;
-    private lockTables?;
-    private subQueries;
-    private _mainAlias?;
-    private _aliases;
-    private _helper?;
-    private readonly platform;
-    private readonly knex;
+    protected aliasCounter: number;
+    protected flags: Set<QueryFlag>;
+    protected finalized: boolean;
+    protected _joins: Dictionary<JoinOptions>;
+    protected _explicitAlias: boolean;
+    protected _schema?: string;
+    protected _cond: Dictionary;
+    protected _data: Dictionary;
+    protected _orderBy: QueryOrderMap<T>[];
+    protected _groupBy: Field<T>[];
+    protected _having: Dictionary;
+    protected _returning?: Field<T>[];
+    protected _onConflict?: {
+        fields: string[];
+        ignore?: boolean;
+        merge?: EntityData<T> | Field<T>[];
+        where?: QBFilterQuery<T>;
+    }[];
+    protected _limit?: number;
+    protected _offset?: number;
+    protected _distinctOn?: string[];
+    protected _joinedProps: Map<string, PopulateOptions<any>>;
+    protected _cache?: boolean | number | [string, number];
+    protected _indexHint?: string;
+    protected _comments: string[];
+    protected _hintComments: string[];
+    protected flushMode?: FlushMode;
+    protected lockMode?: LockMode;
+    protected lockTables?: string[];
+    protected subQueries: Dictionary<string>;
+    protected _mainAlias?: Alias<T>;
+    protected _aliases: Dictionary<Alias<any>>;
+    protected _helper?: QueryBuilderHelper;
+    protected _query?: {
+        sql?: string;
+        _sql?: Knex.Sql;
+        params?: readonly unknown[];
+        qb: Knex.QueryBuilder<T>;
+    };
+    protected readonly platform: AbstractSqlPlatform;
+    protected readonly knex: Knex;
     /**
      * @internal
      */
-    constructor(entityName: EntityName<T> | QueryBuilder<T>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction<any, any[]> | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection, AbstractSqlPlatform>> | undefined, loggerContext?: LoggingOptions | undefined);
+    constructor(entityName: EntityName<T> | QueryBuilder<T>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction<any, any[]> | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection, AbstractSqlPlatform>> | undefined, loggerContext?: (LoggingOptions & Dictionary) | undefined);
     select(fields: Field<T> | Field<T>[], distinct?: boolean): SelectQueryBuilder<T>;
     addSelect(fields: Field<T> | Field<T>[]): SelectQueryBuilder<T>;
     distinct(): SelectQueryBuilder<T>;
@@ -232,6 +242,14 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     as(alias: string): Knex.QueryBuilder;
     clone(reset?: boolean | string[]): QueryBuilder<T>;
     getKnex(processVirtualEntity?: boolean): Knex.QueryBuilder;
+    /**
+     * Sets logger context for this query builder.
+     */
+    setLoggerContext(context: LoggingOptions & Dictionary): void;
+    /**
+     * Gets logger context for this query builder.
+     */
+    getLoggerContext<T extends Dictionary & LoggingOptions = Dictionary>(): T;
     private fromVirtual;
     private joinReference;
     private prepareFields;

package/query/QueryBuilder.js

@@ -85,6 +85,7 @@ class QueryBuilder {
     _mainAlias;
     _aliases = {};
     _helper;
+    _query;
     platform;
     knex;
     /**
@@ -459,10 +460,10 @@ class QueryBuilder {
         return this;
     }
     getKnexQuery(processVirtualEntity = true) {
-        if (this.#query) {
-            return this.#query.qb;
+        if (this._query?.qb) {
+            return this._query.qb;
         }
-        this.#query = {};
+        this._query = {};
         this.finalize();
         const qb = this.getQueryBase(processVirtualEntity);
         const type = this.type ?? enums_1.QueryType.SELECT;
@@ -484,14 +485,14 @@ class QueryBuilder {
         core_1.Utils.runIfNotEmpty(() => this._hintComments.forEach(comment => qb.hintComment(comment)), this._hintComments);
         core_1.Utils.runIfNotEmpty(() => this.helper.appendOnConflictClause(type, this._onConflict, qb), this._onConflict);
         if (this.type === enums_1.QueryType.TRUNCATE && this.platform.usesCascadeStatement()) {
-            return this.#query.qb = this.knex.raw(qb.toSQL().toNative().sql + ' cascade');
+            return this._query.qb = this.knex.raw(qb.toSQL().toNative().sql + ' cascade');
         }
         if (this.lockMode) {
             this.helper.getLockSQL(qb, this.lockMode, this.lockTables);
         }
         this.helper.finalize(type, qb, this.mainAlias.metadata, this._data, this._returning);
         this.clearRawFragmentsCache();
-        return this.#query.qb = qb;
+        return this._query.qb = qb;
     }
     /**
      * @internal
@@ -506,17 +507,16 @@ class QueryBuilder {
     getQuery() {
         return this.toQuery().sql;
     }
-    #query;
     toQuery() {
-        if (this.#query?.sql) {
-            return { sql: this.#query.sql, _sql: this.#query._sql, params: this.#query.params };
+        if (this._query?.sql) {
+            return { sql: this._query.sql, _sql: this._query._sql, params: this._query.params };
         }
         const sql = this.getKnexQuery().toSQL();
         const query = sql.toNative();
-        this.#query.sql = query.sql;
-        this.#query._sql = sql;
-        this.#query.params = query.bindings ?? [];
-        return { sql: this.#query.sql, _sql: this.#query._sql, params: this.#query.params };
+        this._query.sql = query.sql;
+        this._query._sql = sql;
+        this._query.params = query.bindings ?? [];
+        return { sql: this._query.sql, _sql: this._query._sql, params: this._query.params };
     }
     /**
      * Returns the list of all parameters for this query.
@@ -598,17 +598,18 @@ class QueryBuilder {
         if (!this.connectionType && method !== 'run' && [enums_1.QueryType.INSERT, enums_1.QueryType.UPDATE, enums_1.QueryType.DELETE, enums_1.QueryType.TRUNCATE].includes(this.type ?? enums_1.QueryType.SELECT)) {
             this.connectionType = 'write';
         }
+        if (!this.finalized && method === 'get' && this.type === enums_1.QueryType.SELECT) {
+            this.limit(1);
+        }
         const query = this.toQuery()._sql;
         const cached = await this.em?.tryCache(this.mainAlias.entityName, this._cache, ['qb.execute', query.sql, query.bindings, method]);
         if (cached?.data) {
             return cached.data;
         }
-        if (!this.finalized && method === 'get') {
-            this.limit(1);
-        }
         const write = method === 'run' || !this.platform.getConfig().get('preferReadReplicas');
         const type = this.connectionType || (write ? 'write' : 'read');
-        const res = await this.driver.getConnection(type).execute(query.sql, query.bindings, method, this.context, this.loggerContext);
+        const loggerContext = { id: this.em?.id, ...this.loggerContext };
+        const res = await this.driver.getConnection(type).execute(query.sql, query.bindings, method, this.context, loggerContext);
         const meta = this.mainAlias.metadata;
         if (!options.mapResults || !meta) {
             await this.em?.storeCache(this._cache, cached, res);
@@ -652,8 +653,8 @@ class QueryBuilder {
             (0, core_1.helper)(entity).__serializationContext.populate ??= hint;
             hint.forEach(hint => {
                 const [propName] = hint.field.split(':', 2);
-                const value = entity[propName];
-                if (core_1.Utils.isEntity(value, true)) {
+                const value = core_1.Reference.unwrapReference(entity[propName]);
+                if (core_1.Utils.isEntity(value)) {
                     (0, core_1.helper)(value).populated();
                     propagatePopulateHint(value, hint.children ?? []);
                 }
@@ -794,6 +795,19 @@ class QueryBuilder {
         }
         return qb;
     }
+    /**
+     * Sets logger context for this query builder.
+     */
+    setLoggerContext(context) {
+        this.loggerContext = context;
+    }
+    /**
+     * Gets logger context for this query builder.
+     */
+    getLoggerContext() {
+        this.loggerContext ??= {};
+        return this.loggerContext;
+    }
     fromVirtual(meta) {
         if (typeof meta.expression === 'string') {
             return `(${meta.expression}) as ${this.platform.quoteIdentifier(this.alias)}`;
@@ -954,15 +968,19 @@ class QueryBuilder {
         /* istanbul ignore next */
         const requiresSQLConversion = meta?.props.filter(p => p.hasConvertToJSValueSQL && p.persist !== false) ?? [];
         if (this.flags.has(core_1.QueryFlag.CONVERT_CUSTOM_TYPES) && (fields.includes('*') || fields.includes(`${this.mainAlias.aliasName}.*`)) && requiresSQLConversion.length > 0) {
-            requiresSQLConversion.forEach(p => ret.push(this.helper.mapper(p.name, this.type)));
+            for (const p of requiresSQLConversion) {
+                ret.push(this.helper.mapper(p.name, this.type));
+            }
         }
-        Object.keys(this._populateMap).forEach(f => {
-            if (!fields.includes(f.replace(/#\w+$/, '')) && type === 'where') {
+        for (const f of Object.keys(this._populateMap)) {
+            if (type === 'where' && this._joins[f]) {
                 const cols = this.helper.mapJoinColumns(this.type ?? enums_1.QueryType.SELECT, this._joins[f]);
-                ret.push(...cols);
+                for (const col of cols) {
+                    ret.push(col);
+                }
             }
-        });
-        return ret;
+        }
+        return core_1.Utils.unique(ret);
     }
     init(type, data, cond) {
         this.ensureNotFinalized();
@@ -1204,8 +1222,7 @@ class QueryBuilder {
                         // not perfect, but should work most of the time, ideally we should check only the alias (`... as alias`)
                         return field.sql.includes(prop);
                     }
-                    // not perfect, but should work most of the time, ideally we should check only the alias (`... as alias`)
-                    return field.toString().includes(prop);
+                    return false;
                 });
                 if (field instanceof core_1.RawQueryFragment) {
                     knexQuery.select(this.platform.formatQuery(field.sql, field.params));
@@ -1221,6 +1238,27 @@ class QueryBuilder {
         subSubQuery.__raw = true; // tag it as there is now way to check via `instanceof`
         this._limit = undefined;
         this._offset = undefined;
+        // remove joins that are not used for population or ordering to improve performance
+        const populate = new Set();
+        const orderByAliases = this._orderBy
+            .flatMap(hint => Object.keys(hint))
+            .map(k => k.split('.')[0]);
+        function addPath(hints, prefix = '') {
+            for (const hint of hints) {
+                const field = hint.field.split(':')[0];
+                populate.add((prefix ? prefix + '.' : '') + field);
+                if (hint.children) {
+                    addPath(hint.children, (prefix ? prefix + '.' : '') + field);
+                }
+            }
+        }
+        addPath(this._populate);
+        for (const [key, join] of Object.entries(this._joins)) {
+            const path = join.path?.replace(/\[populate]|\[pivot]|:ref/g, '').replace(new RegExp(`^${meta.className}.`), '');
+            if (!populate.has(path ?? '') && !orderByAliases.includes(join.alias)) {
+                delete this._joins[key];
+            }
+        }
         this.select(this._fields).where({ [core_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: subSubQuery } });
     }
     wrapModifySubQuery(meta) {

package/query/QueryBuilderHelper.js

@@ -518,7 +518,8 @@ class QueryBuilderHelper {
         return ret;
     }
     finalize(type, qb, meta, data, returning) {
-        if (!meta || !data || !this.platform.usesReturningStatement()) {
+        const usesReturningStatement = this.platform.usesReturningStatement() || this.platform.usesOutputStatement();
+        if (!meta || !data || !usesReturningStatement) {
             return;
         }
         // always respect explicit returning hint

package/schema/DatabaseTable.js

@@ -79,6 +79,9 @@ class DatabaseTable {
                     prop.length ??= this.platform.getDefaultDateTimeLength();
                 }
             }
+            if (prop.length == null && prop.columnTypes[idx]) {
+                prop.length = this.platform.getSchemaHelper().inferLengthFromColumnType(prop.columnTypes[idx]);
+            }
             const primary = !meta.compositePK && !!prop.primary && prop.kind === core_1.ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType);
             this.columns[field] = {
                 name: prop.fieldNames[idx],
@@ -120,9 +123,22 @@ class DatabaseTable {
             if (prop.deleteRule || cascade || prop.nullable) {
                 this.foreignKeys[constraintName].deleteRule = prop.deleteRule || (cascade ? 'cascade' : 'set null');
             }
-            if (prop.updateRule || prop.cascade.includes(core_1.Cascade.PERSIST) || prop.cascade.includes(core_1.Cascade.ALL)) {
+            if (prop.updateRule) {
                 this.foreignKeys[constraintName].updateRule = prop.updateRule || 'cascade';
             }
+            if ((prop.cascade.includes(core_1.Cascade.PERSIST) || prop.cascade.includes(core_1.Cascade.ALL))) {
+                const hasCascadePath = Object.values(this.foreignKeys).some(fk => {
+                    return fk.constraintName !== constraintName
+                        && ((fk.updateRule && fk.updateRule !== 'no action') || (fk.deleteRule && fk.deleteRule !== 'no action'))
+                        && fk.referencedTableName === this.foreignKeys[constraintName].referencedTableName;
+                });
+                if (!hasCascadePath || this.platform.supportsMultipleCascadePaths()) {
+                    this.foreignKeys[constraintName].updateRule ??= 'cascade';
+                }
+            }
+            if (prop.deferMode) {
+                this.foreignKeys[constraintName].deferMode = prop.deferMode;
+            }
         }
         if (prop.index) {
             this.indexes.push({
@@ -473,6 +489,7 @@ class DatabaseTable {
         fkOptions.referencedColumnNames = fk.referencedColumnNames;
         fkOptions.updateRule = fk.updateRule?.toLowerCase();
         fkOptions.deleteRule = fk.deleteRule?.toLowerCase();
+        fkOptions.deferMode = fk.deferMode;
         fkOptions.columnTypes = fk.columnNames.map(c => this.getColumn(c).type);
         const columnOptions = {};
         if (fk.columnNames.length === 1) {
@@ -520,6 +537,7 @@ class DatabaseTable {
             fkOptions.referencedColumnNames = fk.referencedColumnNames;
             fkOptions.updateRule = fk.updateRule?.toLowerCase();
             fkOptions.deleteRule = fk.deleteRule?.toLowerCase();
+            fkOptions.deferMode = fk.deferMode;
         }
         return {
             name: prop,
@@ -584,7 +602,7 @@ class DatabaseTable {
             // The enum name will be a concatenation of the table name and the column name.
             return namingStrategy.getClassName(this.name + '_' + column.name, '_');
         }
-        return column.mappedType?.compareAsType() ?? 'unknown';
+        return column.mappedType?.runtimeType ?? 'unknown';
     }
     getPropertyDefaultValue(schemaHelper, column, propType, raw = false) {
         const empty = raw ? 'null' : undefined;

package/schema/SchemaComparator.js

@@ -273,12 +273,19 @@ class SchemaComparator {
      */
     detectColumnRenamings(tableDifferences, inverseTableDiff) {
         const renameCandidates = {};
+        const oldFKs = Object.values(tableDifferences.fromTable.getForeignKeys());
+        const newFKs = Object.values(tableDifferences.toTable.getForeignKeys());
         for (const addedColumn of Object.values(tableDifferences.addedColumns)) {
             for (const removedColumn of Object.values(tableDifferences.removedColumns)) {
                 const diff = this.diffColumn(addedColumn, removedColumn);
                 if (diff.size !== 0) {
                     continue;
                 }
+                const wasFK = oldFKs.some(fk => fk.columnNames.includes(removedColumn.name));
+                const isFK = newFKs.some(fk => fk.columnNames.includes(addedColumn.name));
+                if (wasFK !== isFK) {
+                    continue;
+                }
                 const renamedColumn = inverseTableDiff?.renamedColumns[addedColumn.name];
                 if (renamedColumn && renamedColumn?.name !== removedColumn.name) {
                     continue;
@@ -348,6 +355,12 @@ class SchemaComparator {
         if (key1.referencedTableName !== key2.referencedTableName) {
             return true;
         }
+        if (key1.deferMode !== key2.deferMode) {
+            return true;
+        }
+        if (key1.localTableName === key1.referencedTableName && !this.platform.supportsMultipleCascadePaths()) {
+            return false;
+        }
         const defaultRule = ['restrict', 'no action'];
         const rule = (key, method) => {
             return (key[method] ?? defaultRule[0]).toLowerCase().replace(defaultRule[1], defaultRule[0]);
@@ -373,8 +386,8 @@ class SchemaComparator {
             }
         };
         if (fromColumnType !== toColumnType &&
-            !(fromColumn.ignoreSchemaChanges?.includes('type') ||
-                toColumn.ignoreSchemaChanges?.includes('type'))) {
+            !(fromColumn.ignoreSchemaChanges?.includes('type') || toColumn.ignoreSchemaChanges?.includes('type')) &&
+            !fromColumn.generated && !toColumn.generated) {
             log(`'type' changed for column ${tableName}.${fromColumn.name}`, { fromColumnType, toColumnType });
             changedProperties.add('type');
         }

package/schema/SchemaHelper.d.ts

@@ -15,6 +15,7 @@ export declare abstract class SchemaHelper {
     finalizeTable(table: Knex.TableBuilder, charset: string, collate?: string): void;
     supportsSchemaConstraints(): boolean;
     getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[] | undefined, tableName: string, schemaName?: string): Promise<string[]>;
+    inferLengthFromColumnType(type: string): number | undefined;
     getForeignKeys(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Dictionary>;
     protected getTableKey(t: Table): string;
     getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
@@ -27,8 +28,9 @@ export declare abstract class SchemaHelper {
     getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
     getDropIndexSQL(tableName: string, index: IndexDef): string;
     getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string;
+    getDropColumnsSQL(tableName: string, columns: Column[], schemaName?: string): string;
     hasNonDefaultPrimaryKeyName(table: DatabaseTable): boolean;
-    createTableColumn(table: Knex.TableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>, alter?: boolean): Knex.ColumnBuilder;
+    createTableColumn(table: Knex.TableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>, alter?: boolean): Knex.ColumnBuilder | undefined;
     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;
@@ -45,6 +47,8 @@ export declare abstract class SchemaHelper {
     normalizeDefaultValue(defaultValue: string, length?: number, defaultValues?: Dictionary<string[]>): string | number;
     getCreateDatabaseSQL(name: string): string;
     getDropDatabaseSQL(name: string): string;
+    getCreateNamespaceSQL(name: string): string;
+    getDropNamespaceSQL(name: string): string;
     getDatabaseExistsSQL(name: string): string;
     getDatabaseNotExistsError(dbName: string): string;
     getManagementDbName(): string;

package/schema/SchemaHelper.js

@@ -29,6 +29,9 @@ class SchemaHelper {
         const pks = indexes.filter(i => i.primary).map(pk => pk.columnNames);
         return core_1.Utils.flatten(pks);
     }
+    inferLengthFromColumnType(type) {
+        return undefined;
+    }
     async getForeignKeys(connection, tableName, schemaName) {
         const fks = await connection.execute(this.getForeignKeysSQL(tableName, schemaName));
         return this.mapForeignKeys(fks, tableName, schemaName);
@@ -99,6 +102,11 @@ class SchemaHelper {
     getRenameIndexSQL(tableName, index, oldIndexName) {
         return [this.getDropIndexSQL(tableName, { ...index, keyName: oldIndexName }), this.getCreateIndexSQL(tableName, index)].join(';\n');
     }
+    getDropColumnsSQL(tableName, columns, schemaName) {
+        const name = this.platform.quoteIdentifier((schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName);
+        const drops = columns.map(column => `drop column ${this.platform.quoteIdentifier(column.name)}`).join(', ');
+        return `alter table ${name} ${drops}`;
+    }
     hasNonDefaultPrimaryKeyName(table) {
         const pkIndex = table.getPrimaryKey();
         if (!pkIndex || !this.platform.supportsCustomPrimaryKeyNames()) {
@@ -199,6 +207,7 @@ class SchemaHelper {
                     referencedColumnNames: [fk.referenced_column_name],
                     updateRule: fk.update_rule.toLowerCase(),
                     deleteRule: fk.delete_rule.toLowerCase(),
+                    deferMode: fk.defer_mode,
                 };
             }
             return ret;
@@ -220,10 +229,19 @@ class SchemaHelper {
         return norm[0].replace('(?)', length != null ? `(${length})` : '');
     }
     getCreateDatabaseSQL(name) {
-        return `create database ${name}`;
+        // two line breaks to force separate execution
+        return `create database ${name};\n\nuse ${name}`;
     }
     getDropDatabaseSQL(name) {
-        return `drop database if exists ${name}`;
+        return `drop database if exists ${this.platform.quoteIdentifier(name)}`;
+    }
+    /* istanbul ignore next */
+    getCreateNamespaceSQL(name) {
+        return `create schema if not exists ${this.platform.quoteIdentifier(name)}`;
+    }
+    /* istanbul ignore next */
+    getDropNamespaceSQL(name) {
+        return `drop schema if exists ${this.platform.quoteIdentifier(name)}`;
     }
     getDatabaseExistsSQL(name) {
         return `select 1 from information_schema.schemata where schema_name = '${name}'`;

package/schema/SqlSchemaGenerator.d.ts

@@ -1,10 +1,15 @@
-import { AbstractSchemaGenerator, type MikroORM, type ISchemaGenerator, type ClearDatabaseOptions, type CreateSchemaOptions, type EnsureDatabaseOptions, type DropSchemaOptions, type UpdateSchemaOptions } from '@mikro-orm/core';
+import { AbstractSchemaGenerator, type ClearDatabaseOptions, type CreateSchemaOptions, type DropSchemaOptions, type EnsureDatabaseOptions, type ISchemaGenerator, type MikroORM, type Transaction, type UpdateSchemaOptions } from '@mikro-orm/core';
 import type { SchemaDifference } from '../typings';
 import { DatabaseSchema } from './DatabaseSchema';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
 export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<AbstractSqlDriver> implements ISchemaGenerator {
-    private readonly helper;
-    private readonly options;
+    protected readonly helper: import("./SchemaHelper").SchemaHelper;
+    protected readonly options: {
+        disableForeignKeys?: boolean | undefined;
+        createForeignKeyConstraints?: boolean | undefined;
+        ignoreSchema?: string[] | undefined;
+        managementDbName?: string | undefined;
+    };
     protected lastEnsuredDatabase?: string;
     static register(orm: MikroORM): void;
     createSchema(options?: CreateSchemaOptions): Promise<void>;
@@ -15,6 +20,8 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     getTargetSchema(schema?: string): DatabaseSchema;
     getCreateSchemaSQL(options?: CreateSchemaOptions): Promise<string>;
     dropSchema(options?: DropSchemaOptions): Promise<void>;
+    createNamespace(name: string): Promise<void>;
+    dropNamespace(name: string): Promise<void>;
     clearDatabase(options?: ClearDatabaseOptions): Promise<void>;
     getDropSchemaSQL(options?: Omit<DropSchemaOptions, 'dropDb'>): Promise<string>;
     private getSchemaName;
@@ -43,10 +50,11 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     /**
      * creates new database and connects to it
      */
-    createDatabase(name: string): Promise<void>;
+    createDatabase(name?: string): Promise<void>;
     dropDatabase(name?: string): Promise<void>;
     execute(sql: string, options?: {
         wrap?: boolean;
+        ctx?: Transaction;
     }): Promise<void>;
     private wrapSchema;
     private createSchemaBuilder;