@mikro-orm/sql 7.0.0-dev.246 → 7.0.0-dev.248

package/AbstractSqlDriver.d.ts

@@ -19,6 +19,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     private getTableProps;
     /** Creates a FormulaTable object for use in formula callbacks. */
     private createFormulaTable;
+    private validateSqlOptions;
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
     private createQueryBuilderFromOptions;
     find<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: EntityName<T>, where: ObjectQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;

package/AbstractSqlDriver.js

@@ -32,6 +32,14 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const qualifiedName = effectiveSchema ? `${effectiveSchema}.${meta.tableName}` : meta.tableName;
         return { alias, name: meta.tableName, schema: effectiveSchema, qualifiedName, toString: () => alias };
     }
+    validateSqlOptions(options) {
+        if (options.collation != null && typeof options.collation !== 'string') {
+            throw new Error('Collation option for SQL drivers must be a string (collation name). Use a CollationOptions object only with MongoDB.');
+        }
+        if (options.indexHint != null && typeof options.indexHint !== 'string') {
+            throw new Error('indexHint for SQL drivers must be a string (e.g. \'force index(my_index)\'). Use an object only with MongoDB.');
+        }
+    }
     createEntityManager(useContext) {
         const EntityManagerClass = this.config.get('entityManager', SqlEntityManager);
         return new EntityManagerClass(this.config, this, this.metadata, useContext);
@@ -49,6 +57,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (Utils.isPrimaryKey(where, meta.compositePK)) {
             where = { [Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
         }
+        this.validateSqlOptions(options);
         const { first, last, before, after } = options;
         const isCursorPagination = [first, last, before, after].some(v => v != null);
         qb.__populateWhere = options._populateWhere;
@@ -59,6 +68,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             .groupBy(options.groupBy)
             .having(options.having)
             .indexHint(options.indexHint)
+            .collation(options.collation)
             .comment(options.comments)
             .hintComment(options.hintComments);
         if (isCursorPagination) {
@@ -474,8 +484,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (meta && !Utils.isEmpty(populate)) {
             this.buildFields(meta, populate, joinedProps, qb, qb.alias, options, schema);
         }
+        this.validateSqlOptions(options);
         qb.__populateWhere = options._populateWhere;
         qb.indexHint(options.indexHint)
+            .collation(options.collation)
             .comment(options.comments)
             .hintComment(options.hintComments)
             .groupBy(options.groupBy)
@@ -1486,7 +1498,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             return [raw(`${this.evaluateFormula(prop.formula, columns, table)} as ${aliased}`)];
         }
         return prop.fieldNames.map(fieldName => {
-            return `${tableAlias}.${fieldName} as ${tableAlias}__${fieldName}`;
+            return raw('?? as ??', [`${tableAlias}.${fieldName}`, `${tableAlias}__${fieldName}`]);
         });
     }
     /** @internal */

package/AbstractSqlPlatform.d.ts

@@ -33,5 +33,12 @@ export declare abstract class AbstractSqlPlatform extends Platform {
     /**
      * @internal
      */
-    getOrderByExpression(column: string, direction: string): string[];
+    getOrderByExpression(column: string, direction: string, collation?: string): string[];
+    /**
+     * Quotes a collation name for use in COLLATE clauses.
+     * @internal
+     */
+    quoteCollation(collation: string): string;
+    /** @internal */
+    protected validateCollationName(collation: string): void;
 }

package/AbstractSqlPlatform.js

@@ -94,7 +94,24 @@ export class AbstractSqlPlatform extends Platform {
     /**
      * @internal
      */
-    getOrderByExpression(column, direction) {
+    getOrderByExpression(column, direction, collation) {
+        if (collation) {
+            return [`${column} collate ${this.quoteCollation(collation)} ${direction.toLowerCase()}`];
+        }
         return [`${column} ${direction.toLowerCase()}`];
     }
+    /**
+     * Quotes a collation name for use in COLLATE clauses.
+     * @internal
+     */
+    quoteCollation(collation) {
+        this.validateCollationName(collation);
+        return this.quoteIdentifier(collation);
+    }
+    /** @internal */
+    validateCollationName(collation) {
+        if (!/^[\w]+$/.test(collation)) {
+            throw new Error(`Invalid collation name: '${collation}'. Collation names must contain only word characters.`);
+        }
+    }
 }

package/dialects/mysql/BaseMySqlPlatform.d.ts

@@ -41,6 +41,6 @@ export declare class BaseMySqlPlatform extends AbstractSqlPlatform {
     supportsCreatingFullTextIndex(): boolean;
     getFullTextWhereClause(): string;
     getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
-    getOrderByExpression(column: string, direction: string): string[];
+    getOrderByExpression(column: string, direction: string, collation?: string): string[];
     getDefaultClientUrl(): string;
 }

package/dialects/mysql/BaseMySqlPlatform.js

@@ -105,13 +105,14 @@ export class BaseMySqlPlatform extends AbstractSqlPlatform {
         const quotedIndexName = this.quoteIdentifier(indexName);
         return `alter table ${quotedTableName} add fulltext index ${quotedIndexName}(${quotedColumnNames.join(',')})`;
     }
-    getOrderByExpression(column, direction) {
+    getOrderByExpression(column, direction, collation) {
         const ret = [];
         const dir = direction.toLowerCase();
+        const col = collation ? `${column} collate ${this.quoteCollation(collation)}` : column;
         if (dir in this.ORDER_BY_NULLS_TRANSLATE) {
-            ret.push(`${column} ${this.ORDER_BY_NULLS_TRANSLATE[dir]}`);
+            ret.push(`${col} ${this.ORDER_BY_NULLS_TRANSLATE[dir]}`);
         }
-        ret.push(`${column} ${dir.replace(/(\s|nulls|first|last)*/gi, '')}`);
+        ret.push(`${col} ${dir.replace(/(\s|nulls|first|last)*/gi, '')}`);
         return ret;
     }
     getDefaultClientUrl() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.246",
+  "version": "7.0.0-dev.248",
   "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.",
   "type": "module",
   "exports": {
@@ -56,6 +56,6 @@
     "@mikro-orm/core": "^6.6.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.246"
+    "@mikro-orm/core": "7.0.0-dev.248"
   }
 }

package/query/QueryBuilder.d.ts

@@ -57,7 +57,8 @@ type AddToHint<RootAlias, Context, Field extends string, Select extends boolean
 export type ModifyHint<RootAlias, Context, Hint extends string, Field extends string, Select extends boolean = false> = Hint | AddToHint<RootAlias, Context, Field, Select>;
 export type ModifyContext<Entity extends object, Context, Field extends string, Alias extends string, Select extends boolean = false> = IsNever<Context> extends true ? AddToContext<GetType<Entity, object, Field>, object, Field, Alias, Select> : Context & AddToContext<GetType<Entity, Context, Field>, Context, Field, Alias, Select>;
 type StripRootAlias<F extends string, RootAlias extends string, Context = never> = F extends `${RootAlias}.${infer Field}` ? Field : F extends `${infer Alias}.${string}` ? Alias extends AliasNames<Context> ? never : F : F;
-type ExtractRootFields<Fields, RootAlias extends string, Context = never> = [Fields] extends ['*'] ? '*' : Fields extends `${RootAlias}.*` ? '*' : Fields extends string ? StripRootAlias<Fields, RootAlias, Context> : never;
+type StripFieldAlias<F extends string> = F extends `${infer Path} as ${string}` ? Path : F;
+type ExtractRootFields<Fields, RootAlias extends string, Context = never> = [Fields] extends ['*'] ? '*' : Fields extends `${RootAlias}.*` ? '*' : Fields extends string ? StripRootAlias<StripFieldAlias<Fields>, RootAlias, Context> : never;
 type PrefixWithPath<Path extends string, Field extends string> = `${Path}.${Field}`;
 type StripJoinAlias<F extends string, Alias extends string> = F extends `${Alias}.${infer Field}` ? Field : F;
 type AddJoinFields<RootAlias, Context, Field extends string, Alias extends string, JoinFields extends readonly string[]> = JoinFields extends readonly (infer F)[] ? F extends string ? PrefixWithPath<AddToHint<RootAlias, Context, Field, true> & string, StripJoinAlias<F, Alias>> : never : never;
@@ -68,17 +69,21 @@ type AliasNames<Context> = Context[keyof Context] extends infer Join ? Join exte
 type ContextRelationKeys<Context> = Context[keyof Context] extends infer Join ? Join extends any ? Join extends [string, infer Alias, infer Type, any] ? `${Alias & string}.${EntityRelations<Type & object>}` : never : never : never;
 export type QBField<Entity, RootAlias extends string, Context> = EntityRelations<Entity> | `${RootAlias}.${EntityRelations<Entity>}` | ([Context] extends [never] ? never : ContextRelationKeys<Context>);
 type ContextFieldKeys<Context> = Context[keyof Context] extends infer Join ? Join extends any ? Join extends [string, infer Alias, infer Type, any] ? `${Alias & string}.${keyof Type & string}` : never : never : never;
-export type Field<Entity, RootAlias extends string = never, Context = never> = EntityKey<Entity> | (IsNever<RootAlias> extends true ? never : `${RootAlias}.${EntityKey<Entity>}` | `${RootAlias}.*`) | ([Context] extends [never] ? never : ContextFieldKeys<Context> | `${AliasNames<Context>}.*`) | '*' | QueryBuilder<any> | NativeQueryBuilder | RawQueryFragment<any> | (RawQueryFragment & symbol);
+type WithAlias<T extends string> = T | `${T} as ${string}`;
+export type Field<Entity, RootAlias extends string = never, Context = never> = WithAlias<EntityKey<Entity>> | (IsNever<RootAlias> extends true ? never : WithAlias<`${RootAlias}.${EntityKey<Entity>}`> | `${RootAlias}.*`) | ([Context] extends [never] ? never : WithAlias<ContextFieldKeys<Context>> | `${AliasNames<Context>}.*`) | '*' | QueryBuilder<any> | NativeQueryBuilder | RawQueryFragment<any> | (RawQueryFragment & symbol);
 type RootAliasOrderKeys<RootAlias extends string, Entity> = {
     [K in `${RootAlias}.${EntityKey<Entity>}`]?: QueryOrderKeysFlat;
 };
 type ContextOrderKeys<Context> = {
     [K in ContextFieldKeys<Context>]?: QueryOrderKeysFlat;
 };
-export type ContextOrderByMap<Entity, RootAlias extends string = never, Context = never> = QueryOrderMap<Entity> | ((IsNever<RootAlias> extends true ? {} : RootAliasOrderKeys<RootAlias, Entity>) & ([Context] extends [never] ? {} : ContextOrderKeys<Context>));
+type RawOrderKeys<RawAliases extends string> = {
+    [K in RawAliases]?: QueryOrderKeysFlat;
+};
+export type ContextOrderByMap<Entity, RootAlias extends string = never, Context = never, RawAliases extends string = never> = QueryOrderMap<Entity> | ((IsNever<RootAlias> extends true ? {} : RootAliasOrderKeys<RootAlias, Entity>) & ([Context] extends [never] ? {} : ContextOrderKeys<Context>) & (IsNever<RawAliases> extends true ? {} : string extends RawAliases ? {} : RawOrderKeys<RawAliases>));
 type AliasedPath<Alias extends string, Type, P extends string> = P extends `${Alias}.*` ? P : P extends `${Alias}.${infer Rest}` ? `${Alias}.${AutoPath<Type & object, Rest, `${PopulatePath.ALL}`>}` : never;
 type ContextAliasedPath<Context, P extends string> = Context[keyof Context] extends infer Join ? Join extends any ? Join extends [string, infer Alias, infer Type, any] ? AliasedPath<Alias & string, Type, P> : never : never : never;
-type NestedAutoPath<Entity, RootAlias extends string, Context, P extends string> = P extends `${string}:ref` ? never : AliasedPath<RootAlias, Entity, P> | ContextAliasedPath<Context, P> | AutoPath<Entity, P, `${PopulatePath.ALL}`>;
+type NestedAutoPath<Entity, RootAlias extends string, Context, P extends string> = P extends `${string}:ref` ? never : P extends `${infer Path} as ${string}` ? (AliasedPath<RootAlias, Entity, Path> | ContextAliasedPath<Context, Path> | AutoPath<Entity, Path, `${PopulatePath.ALL}`>) extends never ? never : P : AliasedPath<RootAlias, Entity, P> | ContextAliasedPath<Context, P> | AutoPath<Entity, P, `${PopulatePath.ALL}`>;
 type AliasedObjectQuery<Entity extends object, Alias extends string> = {
     [K in EntityKey<Entity> as `${Alias}.${K}`]?: ObjectQuery<Entity>[K];
 };
@@ -86,7 +91,7 @@ type JoinCondition<JoinedEntity extends object, Alias extends string> = ObjectQu
 type RawJoinCondition = {
     [key: string]: FilterValue<Scalar> | RawQueryFragment;
 };
-type ExtractRawAliasFromField<F> = F extends RawQueryFragment<infer A> ? (A extends string ? A : never) : never;
+type ExtractRawAliasFromField<F> = F extends RawQueryFragment<infer A> ? (A extends string ? A : never) : F extends `${string} as ${infer A}` ? A : never;
 type ExtractRawAliasesFromTuple<T extends readonly unknown[]> = T extends readonly [infer Head, ...infer Tail] ? ExtractRawAliasFromField<Head> | ExtractRawAliasesFromTuple<Tail> : never;
 type ExtractRawAliases<Fields> = Fields extends readonly unknown[] ? ExtractRawAliasesFromTuple<Fields> : ExtractRawAliasFromField<Fields>;
 type FlatOperatorMap = {
@@ -194,6 +199,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     protected _joinedProps: Map<string, PopulateOptions<any>>;
     protected _cache?: boolean | number | [string, number];
     protected _indexHint?: string;
+    protected _collation?: string;
     protected _comments: string[];
     protected _hintComments: string[];
     protected flushMode?: FlushMode;
@@ -228,6 +234,10 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * // Select with raw expressions
      * qb.select([raw('count(*) as total')]);
      *
+     * // Select with aliases (works for regular and formula properties)
+     * qb.select(['id', 'fullName as displayName']);
+     * qb.select(['id', sql.ref('fullName').as('displayName')]);
+     *
      * // Select with distinct
      * qb.select('*', true);
      * ```
@@ -503,7 +513,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * qb.orderBy({ 'profile.bio': 'asc' }); // nested via dot notation
      * ```
      */
-    orderBy(orderBy: ContextOrderByMap<Entity, RootAlias, Context> | ContextOrderByMap<Entity, RootAlias, Context>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields>;
+    orderBy(orderBy: ContextOrderByMap<Entity, RootAlias, Context, RawAliases> | ContextOrderByMap<Entity, RootAlias, Context, RawAliases>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields>;
     /**
      * Adds an ORDER BY clause to the query, replacing any existing order.
      *
@@ -516,19 +526,21 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * ```
      */
     orderBy<const T extends Record<string, QueryOrderKeysFlat>>(orderBy: T & {
-        [K in keyof T]: K extends NestedAutoPath<Entity, RootAlias, Context, K & string> ? T[K] : never;
+        [K in keyof T]: K extends NestedAutoPath<Entity, RootAlias, Context, K & string> ? T[K] : (K extends RawAliases ? T[K] : never);
     }): SelectQueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields>;
     /**
      * Adds additional ORDER BY clause without replacing existing order.
      */
-    andOrderBy(orderBy: ContextOrderByMap<Entity, RootAlias, Context> | ContextOrderByMap<Entity, RootAlias, Context>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields>;
+    andOrderBy(orderBy: ContextOrderByMap<Entity, RootAlias, Context, RawAliases> | ContextOrderByMap<Entity, RootAlias, Context, RawAliases>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields>;
     /**
      * Adds additional ORDER BY clause without replacing existing order.
      */
     andOrderBy<const T extends Record<string, QueryOrderKeysFlat>>(orderBy: T & {
-        [K in keyof T]: K extends NestedAutoPath<Entity, RootAlias, Context, K & string> ? T[K] : never;
+        [K in keyof T]: K extends NestedAutoPath<Entity, RootAlias, Context, K & string> ? T[K] : (K extends RawAliases ? T[K] : never);
     }): SelectQueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields>;
     private processOrderBy;
+    /** Collect custom aliases from select fields (stored as 'resolved as alias' strings by select()). */
+    private getSelectAliases;
     /**
      * Adds a GROUP BY clause to the query.
      *
@@ -611,6 +623,10 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * Adds index hint to the FROM clause.
      */
     indexHint(sql: string | undefined): this;
+    /**
+     * Adds COLLATE clause to ORDER BY expressions.
+     */
+    collation(collation: string | undefined): this;
     /**
      * Prepend comment to the sql query using the syntax `/* ... *&#8205;/`. Some characters are forbidden such as `/*, *&#8205;/` and `?`.
      */

package/query/QueryBuilder.js

@@ -3,6 +3,8 @@ import { JoinType, QueryType } from './enums.js';
 import { QueryBuilderHelper } from './QueryBuilderHelper.js';
 import { CriteriaNodeFactory } from './CriteriaNodeFactory.js';
 import { NativeQueryBuilder } from './NativeQueryBuilder.js';
+/** Matches 'path as alias' — safe because ORM property names are JS identifiers (no spaces). */
+const FIELD_ALIAS_RE = /^(.+?)\s+as\s+(\w+)$/i;
 /**
  * SQL query builder with fluent interface.
  *
@@ -67,6 +69,7 @@ export class QueryBuilder {
     _joinedProps = new Map();
     _cache;
     _indexHint;
+    _collation;
     _comments = [];
     _hintComments = [];
     flushMode;
@@ -103,8 +106,19 @@ export class QueryBuilder {
         this.ensureNotFinalized();
         this._fields = Utils.asArray(fields).flatMap(f => {
             if (typeof f !== 'string') {
+                // Normalize sql.ref('prop') and sql.ref('prop').as('alias') to string form
+                if (isRaw(f) && f.sql === '??' && f.params.length === 1) {
+                    return this.resolveNestedPath(String(f.params[0]));
+                }
+                if (isRaw(f) && f.sql === '?? as ??' && f.params.length === 2) {
+                    return `${this.resolveNestedPath(String(f.params[0]))} as ${String(f.params[1])}`;
+                }
                 return f;
             }
+            const asMatch = f.match(FIELD_ALIAS_RE);
+            if (asMatch) {
+                return `${this.resolveNestedPath(asMatch[1].trim())} as ${asMatch[2]}`;
+            }
             return this.resolveNestedPath(f);
         });
         if (distinct) {
@@ -457,7 +471,18 @@ export class QueryBuilder {
         if (reset) {
             this._orderBy = [];
         }
-        Utils.asArray(orderBy).forEach(o => {
+        const selectAliases = this.getSelectAliases();
+        Utils.asArray(orderBy).forEach(orig => {
+            // Shallow clone to avoid mutating the caller's object — safe because the clone
+            // is only used within this loop iteration and `orig` is not referenced afterward.
+            const o = { ...orig };
+            // Wrap known select aliases in raw() so they bypass property validation and alias prefixing
+            for (const key of Object.keys(o)) {
+                if (selectAliases.has(key)) {
+                    o[raw('??', [key])] = o[key];
+                    delete o[key];
+                }
+            }
             this.helper.validateQueryOrder(o);
             const processed = QueryHelper.processWhere({
                 where: o,
@@ -476,10 +501,27 @@ export class QueryBuilder {
         });
         return this;
     }
+    /** Collect custom aliases from select fields (stored as 'resolved as alias' strings by select()). */
+    getSelectAliases() {
+        const aliases = new Set();
+        for (const field of this._fields ?? []) {
+            if (typeof field === 'string') {
+                const m = field.match(FIELD_ALIAS_RE);
+                if (m) {
+                    aliases.add(m[2]);
+                }
+            }
+        }
+        return aliases;
+    }
     groupBy(fields) {
         this.ensureNotFinalized();
         this._groupBy = Utils.asArray(fields).flatMap(f => {
             if (typeof f !== 'string') {
+                // Normalize sql.ref('prop') to string for proper formula resolution
+                if (isRaw(f) && f.sql === '??' && f.params.length === 1) {
+                    return this.resolveNestedPath(String(f.params[0]));
+                }
                 return f;
             }
             return this.resolveNestedPath(f);
@@ -638,6 +680,14 @@ export class QueryBuilder {
         this._indexHint = sql;
         return this;
     }
+    /**
+     * Adds COLLATE clause to ORDER BY expressions.
+     */
+    collation(collation) {
+        this.ensureNotFinalized();
+        this._collation = collation;
+        return this;
+    }
     /**
      * Prepend comment to the sql query using the syntax `/* ... *‍/`. Some characters are forbidden such as `/*, *‍/` and `?`.
      */
@@ -682,7 +732,7 @@ export class QueryBuilder {
         Utils.runIfNotEmpty(() => qb.groupBy(this.prepareFields(this._groupBy, 'groupBy', schema)), isNotEmptyObject(this._groupBy));
         Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this._having, qb, undefined, 'having'), isNotEmptyObject(this._having));
         Utils.runIfNotEmpty(() => {
-            const queryOrder = this.helper.getQueryOrder(this.type, this._orderBy, this._populateMap);
+            const queryOrder = this.helper.getQueryOrder(this.type, this._orderBy, this._populateMap, this._collation);
             if (queryOrder.length > 0) {
                 const sql = Utils.unique(queryOrder).join(', ');
                 qb.orderBy(sql);
@@ -1015,7 +1065,7 @@ export class QueryBuilder {
         // clone array/object properties
         const properties = [
             'flags', '_populate', '_populateWhere', '_populateFilter', '__populateWhere', '_populateMap', '_joins', '_joinedProps', '_cond', '_data', '_orderBy',
-            '_schema', '_indexHint', '_cache', 'subQueries', 'lockMode', 'lockTables', '_groupBy', '_having', '_returning',
+            '_schema', '_indexHint', '_collation', '_cache', 'subQueries', 'lockMode', 'lockTables', '_groupBy', '_having', '_returning',
             '_comments', '_hintComments', 'aliasCounter',
         ];
         for (const prop of Object.keys(this)) {
@@ -1167,14 +1217,23 @@ export class QueryBuilder {
     }
     prepareFields(fields, type = 'where', schema) {
         const ret = [];
-        const getFieldName = (name) => {
-            return this.helper.mapper(name, this.type, undefined, type === 'groupBy' ? null : undefined, schema);
+        const getFieldName = (name, customAlias) => {
+            const alias = customAlias ?? (type === 'groupBy' ? null : undefined);
+            return this.helper.mapper(name, this.type, undefined, alias, schema);
         };
-        fields.forEach(field => {
-            if (typeof field !== 'string') {
-                ret.push(field);
+        fields.forEach(originalField => {
+            if (typeof originalField !== 'string') {
+                ret.push(originalField);
                 return;
             }
+            // Strip 'as alias' suffix if present — the alias is passed to mapper at the end
+            let field = originalField;
+            let customAlias;
+            const asMatch = originalField.match(FIELD_ALIAS_RE);
+            if (asMatch) {
+                field = asMatch[1].trim();
+                customAlias = asMatch[2];
+            }
             const join = Object.keys(this._joins).find(k => field === k.substring(0, k.indexOf('#')));
             if (join && type === 'where') {
                 ret.push(...this.helper.mapJoinColumns(this.type, this._joins[join]));
@@ -1192,10 +1251,13 @@ export class QueryBuilder {
             if (prop?.embedded || (prop?.kind === ReferenceKind.EMBEDDED && prop.object)) {
                 const name = prop.embeddedPath?.join('.') ?? prop.fieldNames[0];
                 const aliased = this._aliases[a] ? `${a}.${name}` : name;
-                ret.push(getFieldName(aliased));
+                ret.push(getFieldName(aliased, customAlias));
                 return;
             }
             if (prop?.kind === ReferenceKind.EMBEDDED) {
+                if (customAlias) {
+                    throw new Error(`Cannot use 'as ${customAlias}' alias on embedded property '${field}' because it expands to multiple columns. Alias individual fields instead (e.g. '${field}.propertyName as ${customAlias}').`);
+                }
                 const nest = (prop) => {
                     for (const childProp of Object.values(prop.embeddedProps)) {
                         if (childProp.fieldNames && (childProp.kind !== ReferenceKind.EMBEDDED || childProp.object) && childProp.persist !== false) {
@@ -1209,11 +1271,14 @@ export class QueryBuilder {
                 nest(prop);
                 return;
             }
-            if (prop && prop.fieldNames.length > 1) {
+            if (prop && prop.fieldNames.length > 1 && !prop.fieldNames.includes(f)) {
+                if (customAlias) {
+                    throw new Error(`Cannot use 'as ${customAlias}' alias on '${field}' because it expands to multiple columns (${prop.fieldNames.join(', ')}).`);
+                }
                 ret.push(...prop.fieldNames.map(f => getFieldName(f)));
                 return;
             }
-            ret.push(getFieldName(field));
+            ret.push(getFieldName(field, customAlias));
         });
         const requiresSQLConversion = this.mainAlias.meta.props.filter(p => p.hasConvertToJSValueSQL && p.persist !== false);
         if (this.flags.has(QueryFlag.CONVERT_CUSTOM_TYPES) &&

package/query/QueryBuilderHelper.d.ts

@@ -52,8 +52,8 @@ export declare class QueryBuilderHelper {
     private getValueReplacement;
     private getOperatorReplacement;
     validateQueryOrder<T>(orderBy: QueryOrderMap<T>): void;
-    getQueryOrder(type: QueryType, orderBy: FlatQueryOrderMap | FlatQueryOrderMap[], populate: Dictionary<string>): string[];
-    getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>): string[];
+    getQueryOrder(type: QueryType, orderBy: FlatQueryOrderMap | FlatQueryOrderMap[], populate: Dictionary<string>, collation?: string): string[];
+    getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>, collation?: string): string[];
     finalize(type: QueryType, qb: NativeQueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: InternalField<any>[]): void;
     splitField<T>(field: EntityKey<T>, greedyAlias?: boolean): [string, EntityKey<T>, string | undefined];
     getLockSQL(qb: NativeQueryBuilder, lockMode: LockMode, lockTables?: string[], joinsMap?: Dictionary<JoinOptions>): void;

package/query/QueryBuilderHelper.js

@@ -110,8 +110,8 @@ export class QueryBuilderHelper {
         }
         if (prop?.formula) {
             const alias2 = this.platform.quoteIdentifier(a).toString();
-            const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]).toString();
-            const as = alias === null ? '' : ` as ${aliased}`;
+            const aliasName = alias === undefined ? prop.fieldNames[0] : alias;
+            const as = aliasName === null ? '' : ` as ${this.platform.quoteIdentifier(aliasName)}`;
             const meta = this.aliasMap[a]?.meta ?? this.metadata.get(this.entityName);
             const table = this.createFormulaTable(alias2, meta, schema);
             const columns = meta.createColumnMappingObject(p => this.getTPTAliasForProperty(p.name, a), alias2);
@@ -605,20 +605,20 @@ export class QueryBuilderHelper {
             ].join('\n'));
         }
     }
-    getQueryOrder(type, orderBy, populate) {
+    getQueryOrder(type, orderBy, populate, collation) {
         if (Array.isArray(orderBy)) {
-            return orderBy.flatMap(o => this.getQueryOrder(type, o, populate));
+            return orderBy.flatMap(o => this.getQueryOrder(type, o, populate, collation));
         }
-        return this.getQueryOrderFromObject(type, orderBy, populate);
+        return this.getQueryOrderFromObject(type, orderBy, populate, collation);
     }
-    getQueryOrderFromObject(type, orderBy, populate) {
+    getQueryOrderFromObject(type, orderBy, populate, collation) {
         const ret = [];
         for (const key of Utils.getObjectQueryKeys(orderBy)) {
             const direction = orderBy[key];
             const order = typeof direction === 'number' ? QueryOrderNumeric[direction] : direction;
             if (Raw.isKnownFragmentSymbol(key)) {
                 const raw = Raw.getKnownFragment(key);
-                ret.push(...this.platform.getOrderByExpression(this.platform.formatQuery(raw.sql, raw.params), order));
+                ret.push(...this.platform.getOrderByExpression(this.platform.formatQuery(raw.sql, raw.params), order, collation));
                 continue;
             }
             for (const f of Utils.splitPrimaryKeys(key)) {
@@ -638,10 +638,10 @@ export class QueryBuilderHelper {
                     colPart = this.platform.formatQuery(colPart.sql, colPart.params);
                 }
                 if (Array.isArray(order)) {
-                    order.forEach(part => ret.push(...this.getQueryOrderFromObject(type, part, populate)));
+                    order.forEach(part => ret.push(...this.getQueryOrderFromObject(type, part, populate, collation)));
                 }
                 else {
-                    ret.push(...this.platform.getOrderByExpression(colPart, order));
+                    ret.push(...this.platform.getOrderByExpression(colPart, order, collation));
                 }
             }
         }