database-builder
Version:
Library to assist in creating and maintaining SQL commands.
182 lines (181 loc) • 7.97 kB
TypeScript
import { JoinType } from "../enums/join-type";
import { RowResult } from "../../core/row-result";
import { QueryCompiled } from "../../core/query-compiled";
import { MapperTable } from "../../mapper-table";
import { ProjectionBuilder } from "../projection-builder";
import { WhereBuilder } from "../where-builder";
import { DatabaseBase, DatabaseResult } from "../../definitions/database-definition";
import { MetadataTable } from "../../metadata-table";
import { QueryBuilder } from "./query-builder";
import { ExpressionOrColumn, ParamType, TypeOrderBy, ValueTypeToParse } from "../../core/utils";
import { OrderBy } from "../../core/enums/order-by";
import { HavingBuilder } from "../having-builder";
import { LambdaExpression } from "lambda-expression";
import { JoinQueryBuilder } from "./join-query-builder";
import { ProjectionsHelper } from "../../core/projections-helper";
import { ColumnRef } from "../../core/column-ref";
import { SqlCompilable } from "../sql-compilable";
import { SqlBase } from "../sql-base";
import { Observable } from "rxjs";
export declare class Query<TType> extends SqlBase<TType> {
private _queryT;
private _queryBuilder;
private _queryReadableBuilder;
private _getMapper;
constructor(_queryT: (new () => TType) | QueryBuilder<TType>, { alias, getMapper, mapperTable, database, enableLog }?: {
alias?: string;
getMapper?: (tKey: (new () => any) | string) => MetadataTable<any>;
mapperTable?: MapperTable;
database?: DatabaseBase;
enableLog?: boolean;
});
clone(): Query<TType>;
compile(): QueryCompiled[];
ignoreQueryFilters(): Query<TType>;
setParamsQueryFilter(params: {
[s: string]: ParamType;
}): Query<TType>;
/**
* @link QueryBuilder
*/
alias(): string;
ref<TReturn>(expression: ExpressionOrColumn<TReturn, TType>): ColumnRef;
from(query: QueryCompiled[] | SqlCompilable): Query<TType>;
union(query: QueryCompiled[] | SqlCompilable): Query<TType>;
unionAll(query: QueryCompiled[] | SqlCompilable): Query<TType>;
join<TJoin>(queryTJoin: (new () => TJoin) | QueryBuilder<TJoin> | {
_builder: () => QueryBuilder<TJoin>;
}, onWhere: (where: WhereBuilder<TJoin>) => void, join: (joinQuery: JoinQueryBuilder<TJoin>) => void, type?: JoinType, alias?: string, ignoreQueryFilters?: boolean): Query<TType>;
createWhere(): WhereBuilder<TType>;
where(where: (whereCallback: WhereBuilder<TType>) => void): Query<TType>;
whereExp(expression: LambdaExpression<TType>): Query<TType>;
/**
* @param projectionCallback
*/
projection(projectionCallback: (projection: ProjectionBuilder<TType>) => void): Query<TType>;
select(...expressions: Array<ExpressionOrColumn<any, TType>>): Query<TType>;
limit(limit: number, offset?: number): Query<TType>;
orderBy<TReturn>(expression: ExpressionOrColumn<TReturn, TType>, order?: OrderBy): Query<TType>;
asc<TReturn>(expression: TypeOrderBy<TReturn, TType>): Query<TType>;
desc<TReturn>(expression: TypeOrderBy<TReturn, TType>): Query<TType>;
groupBy<TReturn>(expression: ExpressionOrColumn<TReturn, TType>, havingCallback?: (having: HavingBuilder<TType>, projection: ProjectionsHelper<TType>) => void): Query<TType>;
/**
* 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, TType>): number;
toString(): string;
/**
* @link QueryReadableBuilder
* @param cascade use cascade fetch in `hasMany` mapper (default = true)
* @param mapper mapper table metadata
* @param database database to execute query
* @returns Array of `TType`
*/
executeAndRead({ cascade, database, mapperTable }?: {
cascade?: boolean;
database?: DatabaseBase;
mapperTable?: MapperTable;
}): Observable<TType[]>;
/**
* Execute query and parse to @type {TType}
* @param cascade use cascade fetch in `hasMany` mapper (default = true)
* @returns Array of @type {TType}
*/
toList({ cascade, database }?: {
cascade?: boolean;
database?: DatabaseBase;
}): Observable<TType[]>;
/**
* Execute query and parse to @type {TPrimitiveType}
* @param cascade use cascade fetch in `hasMany` mapper (default = true)
* @returns first or default @type {TPrimitiveType}
*/
toSingle<TPrimitiveType extends string | number | boolean>({ cascade, database, where, _default }?: {
cascade?: boolean;
database?: DatabaseBase;
where?: (whereCallback: WhereBuilder<TType>) => void;
_default?: any;
}): Observable<TPrimitiveType>;
/**
* Execute query and parse to @type {TPrimitiveType}
* @param cascade use cascade fetch in `hasMany` mapper (default = true)
* @returns Array of @type {TPrimitiveType}
*/
toSingleList<TPrimitiveType extends string | number | boolean>({ cascade, database }?: {
cascade?: boolean;
database?: DatabaseBase;
}): Observable<TPrimitiveType[]>;
/**
* Allow each parse items cursor
* @param mapper callback mapper item
* @param cascade use cascade fetch in `hasMany` mapper (default = true)
* @returns Array of @type {T}
*/
mapper<T extends any>(mapper: (row: RowResult<T>) => T, { cascade, database }?: {
cascade?: boolean;
database?: DatabaseBase;
}): Observable<T[]>;
/**
* Get count rows (count by key column) by query
* @param where where for apply in query
* @returns count items
*/
count({ cascade, database, where }?: {
cascade?: boolean;
database?: DatabaseBase;
where?: (whereCallback: WhereBuilder<TType>) => void;
}): Observable<number>;
/**
* Get first or default item by query
* @param where where for apply in query
* @param cascade use cascade fetch in `hasMany` mapper (default = true)
* @param _default default value if not found any item
* @returns first or default item by query
*/
firstOrDefault({ cascade, database, where, _default }?: {
cascade?: boolean;
database?: DatabaseBase;
where?: (whereCallback: WhereBuilder<TType>) => void;
_default?: any;
}): Observable<TType>;
/**
* @deprecated use `.mapper`
* Supported up to version 1.0.0
*/
read<TReader>(cursor: any, newable: new () => TReader, mapperTable: MapperTable): TReader[];
/**
* @deprecated use `.mapper`
* Supported up to version 1.0.0
*/
toListParse<TParse>(metadataParse: MetadataTable<TParse>): Observable<TParse[]>;
/**
* @deprecated use `.mapper`
* Supported up to version 1.0.0
*/
toListTo<TReader>(newable: new () => TReader, mapperTable: MapperTable): Observable<TReader[]>;
/**
* @deprecated use `.mapper`
* Supported up to version 1.0.0
*/
toCast(): Observable<any[]>;
/**
* @deprecated use `.mapper`
* Supported up to version 1.0.0
*/
map(mapper: (row: any) => any): Observable<any[]>;
/**
* @hidden
*/
_builder(): QueryBuilder<TType>;
protected model(): TType;
protected builderCompiled(): QueryCompiled;
protected resolveDependencyByValue(dependency: MapperTable, value: ValueTypeToParse, index: number): QueryCompiled;
protected resolveDependency(dependency: MapperTable): QueryCompiled;
protected checkDatabaseResult(promise: Observable<DatabaseResult[]>): Observable<DatabaseResult[]>;
private getMapper;
private fetchModels;
private fetchModel;
protected dependencies(): MapperTable[];
}