@mikro-orm/knex 6.1.13-dev.9 → 6.2.1-dev.0

package/dialects/sqlite/SqliteTableCompiler.d.ts

@@ -0,0 +1,5 @@
+import type { Dictionary } from '@mikro-orm/core';
+import { MonkeyPatchable } from '../../MonkeyPatchable';
+export declare class SqliteTableCompiler extends MonkeyPatchable.Sqlite3DialectTableCompiler {
+    foreign(this: any, foreignInfo: Dictionary): void;
+}

package/dialects/sqlite/SqliteTableCompiler.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteTableCompiler = void 0;
+const MonkeyPatchable_1 = require("../../MonkeyPatchable");
+class SqliteTableCompiler extends MonkeyPatchable_1.MonkeyPatchable.Sqlite3DialectTableCompiler {
+    foreign(foreignInfo) {
+        foreignInfo.column = Array.isArray(foreignInfo.column)
+            ? foreignInfo.column
+            : [foreignInfo.column];
+        foreignInfo.column = foreignInfo.column.map((column) => this.client.customWrapIdentifier(column, (a) => a));
+        foreignInfo.inTable = this.client.customWrapIdentifier(foreignInfo.inTable, (a) => a);
+        foreignInfo.references = Array.isArray(foreignInfo.references)
+            ? foreignInfo.references
+            : [foreignInfo.references];
+        foreignInfo.references = foreignInfo.references.map((column) => this.client.customWrapIdentifier(column, (a) => a));
+        // quoted versions
+        const column = this.formatter.columnize(foreignInfo.column);
+        const inTable = this.formatter.columnize(foreignInfo.inTable);
+        const references = this.formatter.columnize(foreignInfo.references);
+        const keyName = this.formatter.columnize(foreignInfo.keyName);
+        const addColumnQuery = this.sequence.find((query) => query.sql.includes(`add column ${column[0]}`));
+        // no need for temp tables if we just add a column
+        if (addColumnQuery) {
+            /* istanbul ignore next */
+            const onUpdate = foreignInfo.onUpdate ? ` on update ${foreignInfo.onUpdate}` : '';
+            /* istanbul ignore next */
+            const onDelete = foreignInfo.onDelete ? ` on delete ${foreignInfo.onDelete}` : '';
+            addColumnQuery.sql += ` constraint ${keyName} references ${inTable} (${references})${onUpdate}${onDelete}`;
+            return;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const compiler = this;
+        if (this.method !== 'create' && this.method !== 'createIfNot') {
+            this.pushQuery({
+                sql: `PRAGMA table_info(${this.tableName()})`,
+                statementsProducer(pragma, connection) {
+                    return compiler.client
+                        .ddl(compiler, pragma, connection)
+                        .foreign(foreignInfo);
+                },
+            });
+        }
+    }
+}
+exports.SqliteTableCompiler = SqliteTableCompiler;

package/dialects/sqlite/index.d.ts

@@ -0,0 +1,7 @@
+export * from './BaseSqliteConnection';
+export * from './BaseSqlitePlatform';
+export * from './BaseSqliteSchemaHelper';
+export * from './SqliteTableCompiler';
+export * from './BetterSqliteKnexDialect';
+export * from './LibSqlKnexDialect';
+export * from './SqliteKnexDialect';

package/dialects/sqlite/index.js

@@ -0,0 +1,23 @@
+"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("./BaseSqliteConnection"), exports);
+__exportStar(require("./BaseSqlitePlatform"), exports);
+__exportStar(require("./BaseSqliteSchemaHelper"), exports);
+__exportStar(require("./SqliteTableCompiler"), exports);
+__exportStar(require("./BetterSqliteKnexDialect"), exports);
+__exportStar(require("./LibSqlKnexDialect"), exports);
+__exportStar(require("./SqliteKnexDialect"), exports);

package/index.d.ts

@@ -10,6 +10,7 @@ export * from './SqlEntityManager';
 export * from './SqlEntityRepository';
 export * from './query';
 export * from './schema';
+export * from './dialects';
 export * from './typings';
 export { SqlEntityManager as EntityManager } from './SqlEntityManager';
 export { SqlEntityRepository as EntityRepository } from './SqlEntityRepository';

package/index.js

@@ -28,6 +28,7 @@ __exportStar(require("./SqlEntityManager"), exports);
 __exportStar(require("./SqlEntityRepository"), exports);
 __exportStar(require("./query"), exports);
 __exportStar(require("./schema"), exports);
+__exportStar(require("./dialects"), exports);
 __exportStar(require("./typings"), exports);
 var SqlEntityManager_1 = require("./SqlEntityManager");
 Object.defineProperty(exports, "EntityManager", { enumerable: true, get: function () { return SqlEntityManager_1.SqlEntityManager; } });

package/index.mjs

@@ -17,10 +17,14 @@ export const ArrayCollection = mod.ArrayCollection;
 export const ArrayCriteriaNode = mod.ArrayCriteriaNode;
 export const ArrayType = mod.ArrayType;
 export const BaseEntity = mod.BaseEntity;
+export const BaseSqliteConnection = mod.BaseSqliteConnection;
+export const BaseSqlitePlatform = mod.BaseSqlitePlatform;
+export const BaseSqliteSchemaHelper = mod.BaseSqliteSchemaHelper;
 export const BeforeCreate = mod.BeforeCreate;
 export const BeforeDelete = mod.BeforeDelete;
 export const BeforeUpdate = mod.BeforeUpdate;
 export const BeforeUpsert = mod.BeforeUpsert;
+export const BetterSqliteKnexDialect = mod.BetterSqliteKnexDialect;
 export const BigIntType = mod.BigIntType;
 export const BlobType = mod.BlobType;
 export const BooleanType = mod.BooleanType;
@@ -108,11 +112,13 @@ export const JoinType = mod.JoinType;
 export const JsonProperty = mod.JsonProperty;
 export const JsonType = mod.JsonType;
 export const Knex = mod.Knex;
+export const LibSqlKnexDialect = mod.LibSqlKnexDialect;
 export const LoadStrategy = mod.LoadStrategy;
 export const LockMode = mod.LockMode;
 export const LockWaitTimeoutException = mod.LockWaitTimeoutException;
 export const ManyToMany = mod.ManyToMany;
 export const ManyToOne = mod.ManyToOne;
+export const MariaDbKnexDialect = mod.MariaDbKnexDialect;
 export const MediumIntType = mod.MediumIntType;
 export const MemoryCacheAdapter = mod.MemoryCacheAdapter;
 export const MetadataDiscovery = mod.MetadataDiscovery;
@@ -123,6 +129,12 @@ export const MetadataValidator = mod.MetadataValidator;
 export const MikroORM = mod.MikroORM;
 export const MongoNamingStrategy = mod.MongoNamingStrategy;
 export const MonkeyPatchable = mod.MonkeyPatchable;
+export const MsSqlKnexDialect = mod.MsSqlKnexDialect;
+export const MySqlConnection = mod.MySqlConnection;
+export const MySqlExceptionConverter = mod.MySqlExceptionConverter;
+export const MySqlKnexDialect = mod.MySqlKnexDialect;
+export const MySqlPlatform = mod.MySqlPlatform;
+export const MySqlSchemaHelper = mod.MySqlSchemaHelper;
 export const NodeState = mod.NodeState;
 export const NonUniqueFieldNameException = mod.NonUniqueFieldNameException;
 export const NotFoundError = mod.NotFoundError;
@@ -141,6 +153,8 @@ export const OptionalProps = mod.OptionalProps;
 export const PlainObject = mod.PlainObject;
 export const Platform = mod.Platform;
 export const PopulateHint = mod.PopulateHint;
+export const PopulatePath = mod.PopulatePath;
+export const PostgreSqlKnexDialect = mod.PostgreSqlKnexDialect;
 export const PrimaryKey = mod.PrimaryKey;
 export const PrimaryKeyProp = mod.PrimaryKeyProp;
 export const Property = mod.Property;
@@ -173,6 +187,8 @@ export const SmallIntType = mod.SmallIntType;
 export const SqlEntityManager = mod.SqlEntityManager;
 export const SqlEntityRepository = mod.SqlEntityRepository;
 export const SqlSchemaGenerator = mod.SqlSchemaGenerator;
+export const SqliteKnexDialect = mod.SqliteKnexDialect;
+export const SqliteTableCompiler = mod.SqliteTableCompiler;
 export const StringType = mod.StringType;
 export const SyntaxErrorException = mod.SyntaxErrorException;
 export const TableExistsException = mod.TableExistsException;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.1.13-dev.9",
+  "version": "6.2.1-dev.0",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -63,9 +63,9 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.1.12"
+    "@mikro-orm/core": "^6.2.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.1.13-dev.9"
+    "@mikro-orm/core": "6.2.1-dev.0"
   }
 }

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 EntityMetadata, 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,16 +242,24 @@ 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;
+    protected prepareFields<T, U extends string | Knex.Raw>(fields: Field<T>[], type?: 'where' | 'groupBy' | 'sub-query'): U[];
     private init;
     private getQueryBase;
     private applyDiscriminatorCondition;
     private finalize;
     private processPopulateWhere;
     private hasToManyJoins;
-    private wrapPaginateSubQuery;
+    protected wrapPaginateSubQuery(meta: EntityMetadata): void;
     private wrapModifySubQuery;
     private getSchema;
     private createAlias;

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.
@@ -608,7 +608,8 @@ class QueryBuilder {
         }
         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

@@ -488,7 +488,7 @@ class QueryBuilderHelper {
             const order = core_1.Utils.isNumber(direction) ? core_1.QueryOrderNumeric[direction] : direction;
             const raw = core_1.RawQueryFragment.getKnownFragment(key);
             if (raw) {
-                ret.push(`${this.platform.formatQuery(raw.sql, raw.params)} ${order.toLowerCase()}`);
+                ret.push(...this.platform.getOrderByExpression(this.platform.formatQuery(raw.sql, raw.params), order));
                 continue;
             }
             for (const f of core_1.Utils.splitPrimaryKeys(key)) {
@@ -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
@@ -605,7 +606,11 @@ class QueryBuilderHelper {
         else {
             const [a, ...rest] = field.split('.');
             const f = rest.join('.');
-            ret = a + '.' + this.fieldName(f, a, always, idx);
+            const fieldName = this.fieldName(f, a, always, idx);
+            if (fieldName instanceof core_1.RawQueryFragment) {
+                return fieldName.sql;
+            }
+            ret = a + '.' + fieldName;
         }
         if (quote) {
             return this.platform.quoteIdentifier(ret);

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,19 @@ 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;
             }
@@ -156,8 +169,7 @@ class DatabaseTable {
     }
     getEntityDeclaration(namingStrategy, schemaHelper, scalarPropertiesForRelations) {
         const { fksOnColumnProps, fksOnStandaloneProps, columnFks, fkIndexes, nullableForeignKeys, skippedColumnNames, } = this.foreignKeysToProps(namingStrategy, scalarPropertiesForRelations);
-        let name = namingStrategy.getEntityName(this.name, this.schema);
-        name = name.match(/^\d/) ? 'E' + name : name;
+        const name = namingStrategy.getEntityName(this.name, this.schema);
         const schema = new core_1.EntitySchema({ name, collection: this.name, schema: this.schema });
         const compositeFkIndexes = {};
         const compositeFkUniques = {};
@@ -589,7 +601,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;
@@ -351,6 +358,9 @@ class SchemaComparator {
         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]);
@@ -376,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');
         }
@@ -471,7 +481,7 @@ class SchemaComparator {
     diffExpression(expr1, expr2) {
         // expressions like check constraints 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(/_\w+\\'(.*?)\\'/g, '$1').replace(/['"`()]|::\w+| +/g, '').toLowerCase();
+        const simplify = (str) => str?.replace(/_\w+'(.*?)'/g, '$1').replace(/['"`()]|::\w+| +/g, '').toLowerCase();
         return simplify(expr1) !== simplify(expr2);
     }
     parseJsonDefault(defaultValue) {

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;