@mikro-orm/sql 7.0.0-dev.97 → 7.0.0-dev.99

package/query/QueryBuilderHelper.d.ts

@@ -0,0 +1,73 @@
+import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityProperty, type FlatQueryOrderMap, LockMode, type QBFilterQuery, RawQueryFragment } from '@mikro-orm/core';
+import { JoinType, QueryType } from './enums.js';
+import type { Field, JoinOptions } from '../typings.js';
+import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
+import { NativeQueryBuilder } from './NativeQueryBuilder.js';
+/**
+ * @internal
+ */
+export declare class QueryBuilderHelper {
+    private readonly entityName;
+    private alias;
+    private readonly aliasMap;
+    private readonly subQueries;
+    private readonly driver;
+    private readonly platform;
+    private readonly metadata;
+    constructor(entityName: string, alias: string, aliasMap: Dictionary<Alias<any>>, subQueries: Dictionary<string>, driver: AbstractSqlDriver);
+    mapper(field: string | RawQueryFragment, type?: QueryType): string;
+    mapper(field: string | RawQueryFragment, type?: QueryType, value?: any, alias?: string | null): string;
+    processData(data: Dictionary, convertCustomTypes: boolean, multi?: boolean): any;
+    joinOneToReference(prop: EntityProperty, ownerAlias: string, alias: string, type: JoinType, cond?: Dictionary, schema?: string): JoinOptions;
+    joinManyToOneReference(prop: EntityProperty, ownerAlias: string, alias: string, type: JoinType, cond?: Dictionary, schema?: string): JoinOptions;
+    joinManyToManyReference(prop: EntityProperty, ownerAlias: string, alias: string, pivotAlias: string, type: JoinType, cond: Dictionary, path: string, schema?: string): Dictionary<JoinOptions>;
+    processJoins(qb: NativeQueryBuilder, joins: Dictionary<JoinOptions>, schema?: string): void;
+    createJoinExpression(join: JoinOptions, joins: Dictionary<JoinOptions>, schema?: string): {
+        sql: string;
+        params: unknown[];
+    };
+    mapJoinColumns(type: QueryType, join: JoinOptions): (string | RawQueryFragment)[];
+    isOneToOneInverse(field: string, meta?: EntityMetadata): boolean;
+    getTableName(entityName: string): string;
+    /**
+     * Checks whether the RE can be rewritten to simple LIKE query
+     */
+    isSimpleRegExp(re: any): re is RegExp;
+    getRegExpParam(re: RegExp): string;
+    appendOnConflictClause<T>(type: QueryType, onConflict: OnConflictClause<T>[], qb: NativeQueryBuilder): void;
+    appendQueryCondition(type: QueryType, cond: any, qb: NativeQueryBuilder, operator?: '$and' | '$or', method?: 'where' | 'having'): void;
+    _appendQueryCondition(type: QueryType, cond: any, operator?: '$and' | '$or'): {
+        sql: string;
+        params: unknown[];
+    };
+    private append;
+    private appendQuerySubCondition;
+    private processObjectSubCondition;
+    private getValueReplacement;
+    private getOperatorReplacement;
+    getQueryOrder(type: QueryType, orderBy: FlatQueryOrderMap | FlatQueryOrderMap[], populate: Dictionary<string>): string[];
+    getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>): string[];
+    finalize(type: QueryType, qb: NativeQueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: Field<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;
+    updateVersionProperty(qb: NativeQueryBuilder, data: Dictionary): void;
+    private prefix;
+    private appendGroupCondition;
+    private isPrefixed;
+    private fieldName;
+    getProperty(field: string, alias?: string): EntityProperty | undefined;
+    isTableNameAliasRequired(type: QueryType): boolean;
+    processOnConflictCondition(cond: QBFilterQuery, schema?: string): QBFilterQuery;
+}
+export interface Alias<T> {
+    aliasName: string;
+    entityName: string;
+    metadata?: EntityMetadata<T>;
+    subQuery?: NativeQueryBuilder;
+}
+export interface OnConflictClause<T> {
+    fields: string[] | RawQueryFragment;
+    ignore?: boolean;
+    merge?: EntityData<T> | Field<T>[];
+    where?: QBFilterQuery<T>;
+}