database-builder
Version:
Library to assist in creating and maintaining SQL commands.
95 lines (94 loc) • 5.02 kB
TypeScript
import { ProjectionCompiled } from "../projection-compiled";
import { UnionType } from "../../core/union-type";
import { ProjectionBuilder } from "../projection-builder";
import { ExpressionOrColumn, ParamType, TypeOrderBy } from "../../core/utils";
import { WhereBuilder } from "../where-builder";
import { OrderBy } from "../../core/enums/order-by";
import { WhereCompiled } from "../where-compiled";
import { QueryCompiled } from "../../core/query-compiled";
import { LambdaExpression } from "lambda-expression";
import { JoinQueryBuilderContract } from "./join-query-builder-contract";
import { QueryBuilderBaseContract } from "./query-builder-base-contract";
import { HavingBuilder } from "../having-builder";
import { ProjectionsHelper } from "../../core/projections-helper";
import { BuilderCompiled } from "../../core/builder-compiled";
import { ColumnRef } from "../../core/column-ref";
import { MapperTable } from "../../mapper-table";
import { SqlCompilable } from "../sql-compilable";
import { SqlBaseBuilder } from "../sql-base-builder";
import { MetadataTable } from "../../metadata-table";
import { QueryBuilder } from "./query-builder";
import { ProjectionModel } from "../projection-model";
export declare abstract class QueryBuilderBase<T, TQuery extends QueryBuilderBase<T, TQuery>> extends SqlBaseBuilder<T> implements QueryBuilderBaseContract<T, QueryBuilderBase<T, TQuery>> {
protected _getMapper?: (tKey: (new () => any) | string) => MetadataTable<any>;
get alias(): string;
get tablename(): string;
protected _groupBy: string;
protected _limit: BuilderCompiled;
protected _orderBy: string;
protected _having: WhereCompiled;
protected _projections: ProjectionModel[];
protected _joinParams: ParamType[];
protected _ignoreQueryFilter: boolean;
private readonly GROUP_BY;
private readonly HAVING;
private readonly ORDER_BY;
private readonly LIMIT;
private readonly OFFSET;
private _paramsQueryFilter;
private _joinsQuery;
private _unionsQuery;
private _fromParams;
constructor(queryT: (new () => T) | QueryBuilder<T>, mapperTable: MapperTable, alias?: string, _getMapper?: (tKey: (new () => any) | string) => MetadataTable<any>);
getAlias(tKey: (new () => any) | string): string;
clone(): TQuery;
ref<TReturn>(expression: ExpressionOrColumn<TReturn, T>, alias?: string): ColumnRef;
hasAlias(alias: string): boolean;
from(query: QueryCompiled[] | SqlCompilable): TQuery;
unionAll(query: QueryCompiled[] | SqlCompilable): TQuery;
union(query: QueryCompiled[] | SqlCompilable, type?: UnionType): TQuery;
createWhere(): WhereBuilder<T>;
where(whereCallback: (where: WhereBuilder<T>) => void): TQuery;
/**
* Where with expression Lambda
* #Experimental
* @param {LambdaExpression<T>} expression
* @returns {TQuery}
* @memberof QueryBuilderBase
*/
whereExp(expression: LambdaExpression<T>): TQuery;
projection(projectionCallback: (projection: ProjectionBuilder<T>) => void): TQuery;
select(...expressions: Array<ExpressionOrColumn<any, T>>): TQuery;
orderBy<TReturn>(expression: TypeOrderBy<TReturn, T>, order?: OrderBy): TQuery;
asc<TReturn>(expression: TypeOrderBy<TReturn, T>): TQuery;
desc<TReturn>(expression: TypeOrderBy<TReturn, T>): TQuery;
groupBy<TReturn>(expression: ExpressionOrColumn<TReturn, T>, havingCallback?: (having: HavingBuilder<T>, projection: ProjectionsHelper<T>) => void): TQuery;
limit(limit: number, offset?: number): TQuery;
/**
* Find projection by alias and result index (base 1...N+1)
* @param projectionAlias alias to find the projection
* @returns index (base 1...N+1)
*/
getIndexProjection<TReturn>(projectionAlias: ExpressionOrColumn<TReturn, T>): number;
ignoreQueryFilters(): TQuery;
enableQueryFilters(): TQuery;
setParamsQueryFilter(params: {
[s: string]: ParamType;
}): TQuery;
compileTable(): string;
compile(): QueryCompiled;
protected whereCompile(baseWhereCompiled: WhereCompiled): WhereCompiled;
protected createProjectionBuilder(addAliasTableToAlias?: boolean, addAliasDefault?: boolean): ProjectionBuilder<T>;
protected addJoin<TJoin, TQueryJoin extends JoinQueryBuilderContract<TJoin, TQueryJoin>>(joinQuery: JoinQueryBuilderContract<TJoin, TQueryJoin>): void;
protected setDefaultColumns(): void;
protected getColumnsCompiled(): ProjectionCompiled;
protected compileJoin(): QueryCompiled;
protected buildBase(): QueryCompiled;
protected compileGroupBy(groupBy: string, addCommand?: boolean): void;
protected compileHaving(having: WhereCompiled, addCommand?: boolean): void;
protected compileOrderBy(orderBy: string, addCommand?: boolean): void;
protected abstract _getInstance(): TQuery;
private buildUnions;
private buildProjections;
private compileTableJoins;
}