@sqb/connect 4.2.1 → 4.5.0

package/esm/orm/commands/command.helper.js

@@ -0,0 +1,135 @@
+import { And, Eq, Exists, Field, InnerJoin, isCompOperator, isLogicalOperator, LeftOuterJoin, Raw, Select } from '@sqb/builder';
+import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
+import { EntityMetadata } from '../model/entity-metadata.js';
+import { isAssociationField, isColumnField, isEmbeddedField } from '../util/orm.helper.js';
+export async function joinAssociationGetFirst(joinInfos, association, parentAlias, innerJoin) {
+    const joins = await joinAssociation(joinInfos, association, parentAlias, innerJoin);
+    return joins[0];
+}
+export async function joinAssociationGetLast(joinInfos, association, parentAlias, innerJoin) {
+    const joins = await joinAssociation(joinInfos, association, parentAlias, innerJoin);
+    return joins[joins.length - 1];
+}
+export async function joinAssociation(joinInfos, association, parentAlias, innerJoin) {
+    let joinInfo;
+    let node = association;
+    const result = [];
+    while (node) {
+        joinInfo = joinInfos.find(j => j.association === node);
+        if (!joinInfo) {
+            const targetEntity = await node.resolveTarget();
+            const sourceEntity = await node.resolveSource();
+            const keyCol = await node.resolveSourceProperty();
+            const targetCol = await node.resolveTargetProperty();
+            const joinAlias = 'J' + (joinInfos.length + 1);
+            const join = innerJoin ? InnerJoin(targetEntity.tableName + ' as ' + joinAlias) :
+                LeftOuterJoin(targetEntity.tableName + ' as ' + joinAlias);
+            join.on(Eq(Field(joinAlias + '.' + targetCol.fieldName, targetCol.dataType, targetCol.isArray), Field(parentAlias + '.' + keyCol.fieldName, keyCol.dataType, keyCol.isArray)));
+            if (node.conditions)
+                await prepareFilter(targetEntity, node.conditions, join._conditions, joinAlias);
+            joinInfo = {
+                association: node,
+                sourceEntity,
+                targetEntity,
+                joinAlias,
+                join
+            };
+            joinInfos.push(joinInfo);
+        }
+        result.push(joinInfo);
+        if (!node.next)
+            break;
+        parentAlias = joinInfo.joinAlias;
+        node = node.next;
+    }
+    return result;
+}
+export async function prepareFilter(entityDef, filter, trgOp, tableAlias = 'T') {
+    let srcOp;
+    if (isLogicalOperator(filter))
+        srcOp = filter;
+    else {
+        srcOp = And();
+        if (Array.isArray(filter))
+            srcOp.add(...filter);
+        else
+            srcOp.add(filter);
+    }
+    for (const item of srcOp._items) {
+        if (isLogicalOperator(item)) {
+            const ctor = Object.getPrototypeOf(item).constructor;
+            const logOp = new ctor();
+            await prepareFilter(entityDef, item, logOp, tableAlias);
+            trgOp.add(logOp);
+            continue;
+        }
+        if (isCompOperator(item)) {
+            if (typeof item._left === 'string') {
+                const itemPath = item._left.split('.');
+                const l = itemPath.length;
+                let pt;
+                let _curEntity = entityDef;
+                let _curAlias = tableAlias;
+                let _curPrefix = '';
+                let _curSuffix = '';
+                let subSelect;
+                for (let i = 0; i < l; i++) {
+                    pt = itemPath[i];
+                    const col = EntityMetadata.getField(_curEntity, pt);
+                    if (!col)
+                        throw new Error(`Unknown property (${item._left}) defined in filter`);
+                    // if last item on path
+                    if (i === l - 1) {
+                        if (!isColumnField(col))
+                            throw new Error(`Invalid column expression (${item._left}) defined in filter`);
+                        const ctor = Object.getPrototypeOf(item).constructor;
+                        trgOp.add(new ctor(Field(_curAlias + '.' + _curPrefix + col.fieldName + _curSuffix, col.dataType, col.isArray), item._right));
+                    }
+                    else {
+                        if (isColumnField(col))
+                            throw new Error(`Invalid column (${item._left}) defined in filter`);
+                        if (isEmbeddedField(col)) {
+                            _curEntity = await EmbeddedFieldMetadata.resolveType(col);
+                            _curPrefix = _curPrefix + (col.fieldNamePrefix || '');
+                            _curSuffix = (col.fieldNameSuffix || '') + _curSuffix;
+                            continue;
+                        }
+                        if (!isAssociationField(col))
+                            throw new Error(`Invalid column (${item._left}) defined in filter`);
+                        let node;
+                        _curEntity = await col.association.resolveTarget();
+                        if (!subSelect) {
+                            const keyCol = await col.association.resolveSourceProperty();
+                            const targetCol = await col.association.resolveTargetProperty();
+                            subSelect = Select(Raw('1'))
+                                .from(_curEntity.tableName + ' K');
+                            subSelect.where(Eq(Field('K.' + targetCol.fieldName, targetCol.dataType, targetCol.isArray), Field(tableAlias + '.' + keyCol.fieldName, keyCol.dataType, keyCol.isArray)));
+                            trgOp.add(Exists(subSelect));
+                            trgOp = subSelect._where;
+                            if (col.association.conditions) {
+                                await prepareFilter(_curEntity, col.association.conditions, trgOp, 'K');
+                            }
+                            node = col.association.next;
+                            _curAlias = 'K';
+                        }
+                        else
+                            node = col.association;
+                        while (node) {
+                            const targetEntity = await node.resolveTarget();
+                            const sourceColumn = await node.resolveSourceProperty();
+                            const targetColumn = await node.resolveTargetProperty();
+                            const joinAlias = 'J' + (((subSelect?._joins?.length) || 0) + 1);
+                            subSelect.join(InnerJoin(targetEntity.tableName + ' ' + joinAlias)
+                                .on(Eq(Field(joinAlias + '.' + targetColumn.fieldName, targetColumn.dataType, targetColumn.isArray), Field(_curAlias + '.' + sourceColumn.fieldName, sourceColumn.dataType, sourceColumn.isArray))));
+                            _curEntity = targetEntity;
+                            _curAlias = joinAlias;
+                            node = node.next;
+                        }
+                    }
+                }
+                continue;
+            }
+        }
+        trgOp.add(item);
+    }
+}

package/{dist → esm}/orm/commands/count.command.d.ts

@@ -1,6 +1,6 @@
-import { SqbConnection } from '../../client/SqbConnection';
-import { EntityMetadata } from '../model/entity-metadata';
-import { Repository } from '../repository.class';
+import { SqbConnection } from '../../client/sqb-connection.js';
+import { EntityMetadata } from '../model/entity-metadata.js';
+import { Repository } from '../repository.class.js';
 export declare type CountCommandArgs = {
     entity: EntityMetadata;
     connection: SqbConnection;

package/esm/orm/commands/count.command.js

@@ -0,0 +1,26 @@
+import { And, Count, Select } from '@sqb/builder';
+import { prepareFilter } from './command.helper.js';
+export class CountCommand {
+    // istanbul ignore next
+    constructor() {
+        throw new Error('This class is abstract');
+    }
+    static async execute(args) {
+        const { connection, entity, filter, params } = args;
+        let where;
+        if (filter) {
+            where = And();
+            await prepareFilter(entity, filter, where, 'T');
+        }
+        const query = Select(Count()).from(entity.tableName + ' T');
+        if (where)
+            query.where(where);
+        // Execute query
+        const resp = await connection.execute(query, {
+            params,
+            objectRows: false,
+            cursor: false,
+        });
+        return (resp && resp.rows && resp.rows[0][0]) || 0;
+    }
+}

package/{dist → esm}/orm/commands/create.command.d.ts

@@ -1,5 +1,5 @@
-import { SqbConnection } from '../../client/SqbConnection';
-import { EntityMetadata } from '../model/entity-metadata';
+import { SqbConnection } from '../../client/sqb-connection.js';
+import { EntityMetadata } from '../model/entity-metadata.js';
 export declare type CreateCommandArgs = {
     entity: EntityMetadata;
     connection: SqbConnection;

package/esm/orm/commands/create.command.js

@@ -0,0 +1,85 @@
+import { Insert, Param } from '@sqb/builder';
+import { ColumnFieldMetadata } from '../model/column-field-metadata.js';
+import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
+import { EntityMetadata } from '../model/entity-metadata.js';
+import { isColumnField, isEmbeddedField } from '../util/orm.helper.js';
+export class CreateCommand {
+    // istanbul ignore next
+    constructor() {
+        throw new Error('This class is abstract');
+    }
+    static async execute(args) {
+        const { entity } = args;
+        const tableName = entity.tableName;
+        if (!tableName)
+            throw new Error(`${entity.ctor.name} is not decorated with @Entity decorator`);
+        // Create a context
+        const ctx = {
+            entity,
+            queryParams: {},
+            queryValues: {},
+            colCount: 0
+        };
+        // Prepare
+        await this._prepareParams(ctx, entity, args.values);
+        if (!ctx.colCount)
+            throw new Error('No field given to create new entity instance');
+        const query = Insert(tableName, ctx.queryValues);
+        if (args.returning) {
+            const primaryIndexColumns = EntityMetadata.getPrimaryIndexColumns(entity);
+            if (primaryIndexColumns.length)
+                query.returning(...primaryIndexColumns.map(col => col.fieldName));
+        }
+        const qr = await args.connection.execute(query, {
+            params: ctx.queryParams,
+            objectRows: false,
+            cursor: false
+        });
+        if (args.returning && qr.fields && qr.rows?.length) {
+            const keyValues = {};
+            for (const f of qr.fields.values()) {
+                const el = EntityMetadata.getColumnFieldByFieldName(entity, f.fieldName);
+                if (el)
+                    keyValues[el.name] = qr.rows[0][f.index];
+            }
+            return keyValues;
+        }
+    }
+    static async _prepareParams(ctx, entity, values, prefix, suffix) {
+        let v;
+        prefix = prefix || '';
+        suffix = suffix || '';
+        for (const col of Object.values(entity.fields)) {
+            v = values[col.name];
+            if (isColumnField(col)) {
+                if (col.noInsert)
+                    continue;
+                if (v == null && col.default !== undefined) {
+                    v = typeof col.default === 'function' ?
+                        col.default(values) : col.default;
+                }
+                if (typeof col.serialize === 'function')
+                    v = col.serialize(v, col.name);
+                if (v == null) {
+                    if (col.notNull && !col.autoGenerated)
+                        throw new Error(`${entity.name}.${col.name} is required and can't be null`);
+                    continue;
+                }
+                ColumnFieldMetadata.checkEnumValue(col, v);
+                const fieldName = prefix + col.fieldName + suffix;
+                const k = '$input_' + fieldName;
+                ctx.queryValues[fieldName] = Param({
+                    name: k,
+                    dataType: col.dataType,
+                    isArray: col.isArray
+                });
+                ctx.queryParams[k] = v;
+                ctx.colCount++;
+            }
+            else if (v != null && isEmbeddedField(col)) {
+                const type = await EmbeddedFieldMetadata.resolveType(col);
+                await this._prepareParams(ctx, type, v, col.fieldNamePrefix, col.fieldNameSuffix);
+            }
+        }
+    }
+}

package/{dist → esm}/orm/commands/destroy.command.d.ts

@@ -1,6 +1,6 @@
-import { SqbConnection } from '../../client/SqbConnection';
-import { EntityMetadata } from '../model/entity-metadata';
-import { Repository } from '../repository.class';
+import { SqbConnection } from '../../client/sqb-connection.js';
+import { EntityMetadata } from '../model/entity-metadata.js';
+import { Repository } from '../repository.class.js';
 export declare type DestroyCommandArgs = {
     entity: EntityMetadata;
     connection: SqbConnection;

package/esm/orm/commands/destroy.command.js

@@ -0,0 +1,26 @@
+import { And, Delete } from '@sqb/builder';
+import { prepareFilter } from './command.helper.js';
+export class DestroyCommand {
+    // istanbul ignore next
+    constructor() {
+        throw new Error('This class is abstract');
+    }
+    static async execute(args) {
+        const { connection, entity, filter, params } = args;
+        let where;
+        if (filter) {
+            where = And();
+            await prepareFilter(entity, filter, where);
+        }
+        const query = Delete(entity.tableName + ' T');
+        if (where)
+            query.where(...where._items);
+        // Execute query
+        const resp = await connection.execute(query, {
+            params,
+            objectRows: false,
+            cursor: false,
+        });
+        return (resp && resp.rowsAffected) || 0;
+    }
+}

package/{dist → esm}/orm/commands/find.command.d.ts

@@ -1,8 +1,8 @@
-import { SqbConnection } from '../../client/SqbConnection';
-import { AssociationNode } from '../model/association-node';
-import { EntityMetadata } from '../model/entity-metadata';
-import type { Repository } from '../repository.class';
-import { RowConverter } from './row-converter';
+import { SqbConnection } from '../../client/sqb-connection.js';
+import { AssociationNode } from '../model/association-node.js';
+import { EntityMetadata } from '../model/entity-metadata.js';
+import { Repository } from '../repository.class.js';
+import { RowConverter } from './row-converter.js';
 export declare type FindCommandArgs = {
     entity: EntityMetadata;
     connection: SqbConnection;
@@ -25,20 +25,20 @@ export declare class FindCommand {
         maxEagerFetch?: number;
     }): Promise<FindCommand>;
     static execute(args: FindCommandArgs): Promise<any[]>;
-    addElements(opts?: {
+    addFields(opts?: {
         tableAlias?: string;
         converter?: RowConverter;
         entity?: EntityMetadata;
-        elements?: string[];
+        pick?: string[];
+        omit?: string[];
         include?: string[];
-        exclude?: string[];
         sort?: string[];
         prefix?: string;
         suffix?: string;
     }): Promise<void>;
     private _selectColumn;
     filter(filter: any): Promise<void>;
-    sort(sortElements: string[]): Promise<void>;
+    sort(sortFields: string[]): Promise<void>;
     execute(args: Pick<FindCommandArgs, 'connection' | 'distinct' | 'offset' | 'limit' | 'params' | 'onTransformRow'>): Promise<any[]>;
     private _getEntityFromAlias;
 }

package/esm/orm/commands/find.command.js

@@ -0,0 +1,318 @@
+import { And, In, Param, Select } from '@sqb/builder';
+import { Entity } from '../decorators/entity.decorator.js';
+import { AssociationNode } from '../model/association-node.js';
+import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
+import { EntityMetadata } from '../model/entity-metadata.js';
+import { isAssociationField, isColumnField, isEmbeddedField } from '../util/orm.helper.js';
+import { joinAssociationGetLast, prepareFilter } from './command.helper.js';
+import { RowConverter } from './row-converter.js';
+const SORT_ORDER_PATTERN = /^([-+])?(.*)$/;
+export class FindCommand {
+    maxEagerFetch = 100000;
+    maxSubQueries = 5;
+    mainEntity;
+    resultEntity;
+    converter;
+    mainAlias = 'T';
+    resultAlias = 'T';
+    _joins = [];
+    _selectColumns = {};
+    _filter = And();
+    _sort;
+    constructor(selectEntity, outputEntity) {
+        this.mainEntity = selectEntity;
+        this.resultEntity = outputEntity;
+        this.converter = new RowConverter(outputEntity.ctor);
+    }
+    static async create(source, opts = {}) {
+        let command;
+        let listingEntity;
+        if (source instanceof AssociationNode) {
+            const node = source;
+            listingEntity = await node.resolveTarget();
+            const resultEntity = await node.getLast().resolveTarget();
+            command = new FindCommand(listingEntity, resultEntity);
+            if (node.conditions)
+                await command.filter(node.conditions);
+            if (node.next) {
+                const join = await joinAssociationGetLast(command._joins, node.next, command.mainAlias);
+                command.resultAlias = join.joinAlias;
+            }
+        }
+        else {
+            listingEntity = source;
+            command = new FindCommand(listingEntity, listingEntity);
+        }
+        if (!listingEntity.tableName)
+            throw new Error(`${listingEntity.ctor.name} is not decorated with @Entity decorator`);
+        if (typeof opts.maxSubQueries === 'number')
+            command.maxSubQueries = opts.maxSubQueries;
+        if (typeof opts.maxEagerFetch === 'number')
+            command.maxEagerFetch = opts.maxEagerFetch;
+        return command;
+    }
+    static async execute(args) {
+        const command = await FindCommand.create(args.entity, {
+            maxSubQueries: args.maxSubQueries,
+            maxEagerFetch: args.maxEagerFetch,
+        });
+        await command.addFields({
+            pick: args.pick,
+            include: args.include,
+            omit: args.omit,
+            sort: args.sort
+        });
+        if (args.filter)
+            await command.filter(args.filter);
+        if (args.sort)
+            await command.sort(args.sort);
+        return await command.execute(args);
+    }
+    async addFields(opts = {}) {
+        const tableAlias = opts.tableAlias || this.resultAlias;
+        const entity = opts.entity || this._getEntityFromAlias(tableAlias);
+        const converter = opts.converter || this.converter;
+        const _pick = opts.pick ?
+            opts.pick.map(x => x.toLowerCase()) : undefined;
+        const _omit = opts.omit ?
+            opts.omit.map(x => x.toLowerCase()) : undefined;
+        const _include = opts.include ?
+            opts.include.map(x => x.toLowerCase()) : undefined;
+        let requestedFields;
+        if (_pick)
+            requestedFields = [..._pick];
+        else {
+            requestedFields = Entity.getFieldNames(entity.ctor).reduce((a, x) => {
+                const f = Entity.getField(entity.ctor, x);
+                if (f && !f.exclusive)
+                    a.push(x.toLowerCase());
+                return a;
+            }, []);
+        }
+        if (_include)
+            requestedFields.push(..._include);
+        const sortFields = opts.sort && opts.sort.length ?
+            opts.sort.map(x => x.toLowerCase()) : undefined;
+        const prefix = opts.prefix || '';
+        const suffix = opts.suffix || '';
+        for (const key of Object.keys(entity.fields)) {
+            const col = EntityMetadata.getField(entity, key);
+            if (!col || col.hidden)
+                continue;
+            const colNameLower = col.name.toLowerCase();
+            // Ignore field if in excluded list
+            if (_omit && _omit.includes(colNameLower))
+                continue;
+            // Check if field request list
+            if (!requestedFields.find((x) => x === colNameLower || x.startsWith(colNameLower + '.')))
+                continue;
+            // Add field to select list if field is a column
+            if (isColumnField(col)) {
+                const fieldAlias = this._selectColumn(tableAlias, col, prefix, suffix);
+                // Add column to converter
+                converter.addValueProperty({
+                    name: col.name,
+                    fieldAlias,
+                    dataType: col.dataType,
+                    parse: col.parse
+                });
+                continue;
+            }
+            if (isEmbeddedField(col)) {
+                const typ = await EmbeddedFieldMetadata.resolveType(col);
+                const subConverter = converter.addObjectProperty({
+                    name: col.name,
+                    type: typ.ctor
+                }).converter;
+                await this.addFields({
+                    tableAlias,
+                    converter: subConverter,
+                    entity: typ,
+                    prefix: col.fieldNamePrefix,
+                    suffix: col.fieldNameSuffix,
+                    pick: _pick?.includes(colNameLower) ? undefined :
+                        extractSubFields(colNameLower, _pick),
+                    include: extractSubFields(colNameLower, _include),
+                    omit: extractSubFields(colNameLower, _omit),
+                    sort: extractSubFields(colNameLower, sortFields),
+                });
+                continue;
+            }
+            if (isAssociationField(col)) {
+                // OtO relation
+                if (!col.association.returnsMany()) {
+                    const joinInfo = await joinAssociationGetLast(this._joins, col.association, tableAlias);
+                    const subConverter = converter.addObjectProperty({
+                        name: col.name,
+                        type: joinInfo.targetEntity.ctor
+                    }).converter;
+                    // Add join fields to select columns list
+                    await this.addFields({
+                        tableAlias: joinInfo.joinAlias,
+                        converter: subConverter,
+                        entity: joinInfo.targetEntity,
+                        pick: _pick?.includes(colNameLower) ? undefined :
+                            extractSubFields(colNameLower, _pick),
+                        include: extractSubFields(colNameLower, _include),
+                        omit: extractSubFields(colNameLower, _omit),
+                        sort: extractSubFields(colNameLower, sortFields),
+                    });
+                    continue;
+                }
+                // One-2-Many Eager relation
+                if (this.maxSubQueries > 0) {
+                    const targetCol = await col.association.resolveTargetProperty();
+                    const sourceCol = await col.association.resolveSourceProperty();
+                    // We need to know key value to filter sub query.
+                    // So add key field into select columns
+                    const parentField = this._selectColumn(tableAlias, sourceCol);
+                    const findCommand = await FindCommand.create(col.association, {
+                        maxSubQueries: this.maxSubQueries - 1,
+                        maxEagerFetch: this.maxEagerFetch
+                    });
+                    findCommand.converter.parent = this.converter;
+                    await findCommand.filter(In(targetCol.name, Param(parentField)));
+                    const sort = sortFields && extractSubFields(colNameLower, sortFields);
+                    await findCommand.addFields({
+                        pick: _pick?.includes(colNameLower) ? undefined :
+                            extractSubFields(colNameLower, _pick),
+                        include: extractSubFields(colNameLower, _include),
+                        omit: extractSubFields(colNameLower, _omit),
+                        sort,
+                    });
+                    if (sort)
+                        await findCommand.sort(sort);
+                    const keyField = findCommand._selectColumn(findCommand.mainAlias, targetCol);
+                    const resultType = await col.association.getLast().resolveTarget();
+                    converter.addNestedProperty({
+                        name: col.name,
+                        type: resultType.ctor,
+                        findCommand,
+                        parentField,
+                        keyField,
+                        sort: extractSubFields(colNameLower, sortFields)
+                    });
+                }
+            }
+        }
+    }
+    _selectColumn(tableAlias, el, prefix, suffix) {
+        const fieldName = (prefix || '').toLowerCase() +
+            el.fieldName.toUpperCase() +
+            (suffix || '').toLowerCase();
+        const fieldAlias = tableAlias + '_' + fieldName;
+        this._selectColumns[fieldAlias] = {
+            field: el,
+            statement: tableAlias + '.' + fieldName + ' as ' + fieldAlias
+        };
+        return fieldAlias;
+    }
+    async filter(filter) {
+        await prepareFilter(this.mainEntity, filter, this._filter);
+    }
+    async sort(sortFields) {
+        const out = [];
+        for (const item of sortFields) {
+            const m = item.match(SORT_ORDER_PATTERN);
+            if (!m)
+                throw new Error(`"${item}" is not a valid order expression`);
+            let elName = m[2];
+            let prefix = '';
+            let suffix = '';
+            let _entityDef = this.resultEntity;
+            let tableAlias = this.resultAlias;
+            if (elName.includes('.')) {
+                const a = elName.split('.');
+                while (a.length > 1) {
+                    const col = EntityMetadata.getField(_entityDef, a.shift() || '');
+                    if (isEmbeddedField(col)) {
+                        _entityDef = await EmbeddedFieldMetadata.resolveType(col);
+                        if (col.fieldNamePrefix)
+                            prefix += col.fieldNamePrefix;
+                        if (col.fieldNameSuffix)
+                            suffix = col.fieldNameSuffix + suffix;
+                    }
+                    else if (isAssociationField(col)) {
+                        if (col.association.returnsMany()) {
+                            elName = '';
+                            break;
+                        }
+                        const joinInfo = await joinAssociationGetLast(this._joins, col.association, tableAlias);
+                        tableAlias = joinInfo.joinAlias;
+                        _entityDef = joinInfo.targetEntity;
+                    }
+                    else
+                        throw new Error(`Invalid column (${elName}) declared in sort property`);
+                }
+                if (!elName)
+                    continue;
+                elName = a.shift() || '';
+            }
+            const col = EntityMetadata.getField(_entityDef, elName);
+            if (!col)
+                throw new Error(`Unknown field (${elName}) declared in sort property`);
+            if (!isColumnField(col))
+                throw new Error(`Can not sort by "${elName}", because it is not a data column`);
+            const dir = m[1] || '+';
+            out.push((dir || '') + tableAlias + '.' + prefix + col.fieldName + suffix);
+        }
+        this._sort = out;
+    }
+    async execute(args) {
+        // Generate select query
+        const columnSqls = Object.keys(this._selectColumns)
+            .map(x => this._selectColumns[x].statement);
+        if (!columnSqls.length)
+            columnSqls.push('1');
+        const query = Select(...columnSqls)
+            .from(this.mainEntity.tableName + ' as ' + this.mainAlias);
+        if (args.distinct)
+            query.distinct();
+        query.where(...this._filter._items);
+        if (this._sort) {
+            query.orderBy(...this._sort);
+        }
+        if (args.offset)
+            query.offset(args.offset);
+        // joins must be added last
+        if (this._joins)
+            for (const j of this._joins) {
+                query.join(j.join);
+            }
+        // Execute query
+        const resp = await args.connection.execute(query, {
+            params: args?.params,
+            fetchRows: args?.limit,
+            objectRows: false,
+            cursor: false
+        });
+        // Create objects
+        if (resp.rows && resp.fields) {
+            return this.converter.transform(args.connection, resp.fields, resp.rows, args.onTransformRow);
+        }
+        return [];
+    }
+    _getEntityFromAlias(tableAlias) {
+        if (tableAlias === this.mainAlias)
+            return this.mainEntity;
+        if (tableAlias === this.resultAlias)
+            return this.resultEntity;
+        if (this._joins) {
+            const join = this._joins.find(j => j.joinAlias === tableAlias);
+            if (join)
+                return join.targetEntity;
+        }
+        throw new Error(`Unknown table alias "${tableAlias}"`);
+    }
+}
+function extractSubFields(colNameLower, fields) {
+    if (!(fields && fields.length))
+        return;
+    if (fields) {
+        return fields.reduce((trg, v) => {
+            if (v.startsWith(colNameLower + '.'))
+                trg.push(v.substring(colNameLower.length + 1).toLowerCase());
+            return trg;
+        }, []);
+    }
+}