typeorm
Version:
Data-Mapper ORM for TypeScript, ES7, ES6, ES5. Supports MySQL, PostgreSQL, MariaDB, SQLite, MS SQL Server, Oracle, MongoDB databases.
1,004 lines (1,003 loc) • 83.2 kB
JavaScript
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [0, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
import { RawSqlResultsToEntityTransformer } from "./transformer/RawSqlResultsToEntityTransformer";
import { SqlServerDriver } from "../driver/sqlserver/SqlServerDriver";
import { PessimisticLockTransactionRequiredError } from "../error/PessimisticLockTransactionRequiredError";
import { NoVersionOrUpdateDateColumnError } from "../error/NoVersionOrUpdateDateColumnError";
import { OptimisticLockVersionMismatchError } from "../error/OptimisticLockVersionMismatchError";
import { OptimisticLockCanNotBeUsedError } from "../error/OptimisticLockCanNotBeUsedError";
import { JoinAttribute } from "./JoinAttribute";
import { RelationIdAttribute } from "./relation-id/RelationIdAttribute";
import { RelationCountAttribute } from "./relation-count/RelationCountAttribute";
import { RelationIdLoader } from "./relation-id/RelationIdLoader";
import { RelationIdMetadataToAttributeTransformer } from "./relation-id/RelationIdMetadataToAttributeTransformer";
import { RelationCountLoader } from "./relation-count/RelationCountLoader";
import { RelationCountMetadataToAttributeTransformer } from "./relation-count/RelationCountMetadataToAttributeTransformer";
import { QueryBuilder } from "./QueryBuilder";
import { LockNotSupportedOnGivenDriverError } from "../error/LockNotSupportedOnGivenDriverError";
import { MysqlDriver } from "../driver/mysql/MysqlDriver";
import { PostgresDriver } from "../driver/postgres/PostgresDriver";
import { OracleDriver } from "../driver/oracle/OracleDriver";
import { AbstractSqliteDriver } from "../driver/sqlite-abstract/AbstractSqliteDriver";
import { OffsetWithoutLimitNotSupportedError } from "../error/OffsetWithoutLimitNotSupportedError";
import { BroadcasterResult } from "../subscriber/BroadcasterResult";
import { abbreviate } from "../util/StringUtils";
/**
* Allows to build complex sql queries in a fashion way and execute those queries.
*/
var SelectQueryBuilder = /** @class */ (function (_super) {
__extends(SelectQueryBuilder, _super);
function SelectQueryBuilder() {
return _super !== null && _super.apply(this, arguments) || this;
}
// -------------------------------------------------------------------------
// Public Implemented Methods
// -------------------------------------------------------------------------
/**
* Gets generated sql query without parameters being replaced.
*/
SelectQueryBuilder.prototype.getQuery = function () {
var sql = this.createSelectExpression();
sql += this.createJoinExpression();
sql += this.createWhereExpression();
sql += this.createGroupByExpression();
sql += this.createHavingExpression();
sql += this.createOrderByExpression();
sql += this.createLimitOffsetExpression();
sql += this.createLockExpression();
sql = sql.trim();
if (this.expressionMap.subQuery)
sql = "(" + sql + ")";
return sql;
};
// -------------------------------------------------------------------------
// Public Methods
// -------------------------------------------------------------------------
/**
* Creates a subquery - query that can be used inside other queries.
*/
SelectQueryBuilder.prototype.subQuery = function () {
var qb = this.createQueryBuilder();
qb.expressionMap.subQuery = true;
qb.expressionMap.parentQueryBuilder = this;
return qb;
};
/**
* Creates SELECT query and selects given data.
* Replaces all previous selections if they exist.
*/
SelectQueryBuilder.prototype.select = function (selection, selectionAliasName) {
this.expressionMap.queryType = "select";
if (selection instanceof Array) {
this.expressionMap.selects = selection.map(function (selection) { return ({ selection: selection }); });
}
else if (selection instanceof Function) {
var subQueryBuilder = selection(this.subQuery());
this.setParameters(subQueryBuilder.getParameters());
this.expressionMap.selects.push({ selection: subQueryBuilder.getQuery(), aliasName: selectionAliasName });
}
else if (selection) {
this.expressionMap.selects = [{ selection: selection, aliasName: selectionAliasName }];
}
return this;
};
/**
* Adds new selection to the SELECT query.
*/
SelectQueryBuilder.prototype.addSelect = function (selection, selectionAliasName) {
if (!selection)
return this;
if (selection instanceof Array) {
this.expressionMap.selects = this.expressionMap.selects.concat(selection.map(function (selection) { return ({ selection: selection }); }));
}
else if (selection instanceof Function) {
var subQueryBuilder = selection(this.subQuery());
this.setParameters(subQueryBuilder.getParameters());
this.expressionMap.selects.push({ selection: subQueryBuilder.getQuery(), aliasName: selectionAliasName });
}
else if (selection) {
this.expressionMap.selects.push({ selection: selection, aliasName: selectionAliasName });
}
return this;
};
/**
* Specifies FROM which entity's table select/update/delete will be executed.
* Also sets a main string alias of the selection data.
* Removes all previously set from-s.
*/
SelectQueryBuilder.prototype.from = function (entityTarget, aliasName) {
var mainAlias = this.createFromAlias(entityTarget, aliasName);
this.expressionMap.setMainAlias(mainAlias);
return this;
};
/**
* Specifies FROM which entity's table select/update/delete will be executed.
* Also sets a main string alias of the selection data.
*/
SelectQueryBuilder.prototype.addFrom = function (entityTarget, aliasName) {
var alias = this.createFromAlias(entityTarget, aliasName);
if (!this.expressionMap.mainAlias)
this.expressionMap.setMainAlias(alias);
return this;
};
/**
* INNER JOINs (without selection).
* You also need to specify an alias of the joined data.
* Optionally, you can add condition and parameters used in condition.
*/
SelectQueryBuilder.prototype.innerJoin = function (entityOrProperty, alias, condition, parameters) {
if (condition === void 0) { condition = ""; }
this.join("INNER", entityOrProperty, alias, condition, parameters);
return this;
};
/**
* LEFT JOINs (without selection).
* You also need to specify an alias of the joined data.
* Optionally, you can add condition and parameters used in condition.
*/
SelectQueryBuilder.prototype.leftJoin = function (entityOrProperty, alias, condition, parameters) {
if (condition === void 0) { condition = ""; }
this.join("LEFT", entityOrProperty, alias, condition, parameters);
return this;
};
/**
* INNER JOINs and adds all selection properties to SELECT.
* You also need to specify an alias of the joined data.
* Optionally, you can add condition and parameters used in condition.
*/
SelectQueryBuilder.prototype.innerJoinAndSelect = function (entityOrProperty, alias, condition, parameters) {
if (condition === void 0) { condition = ""; }
this.addSelect(alias);
this.innerJoin(entityOrProperty, alias, condition, parameters);
return this;
};
/**
* LEFT JOINs and adds all selection properties to SELECT.
* You also need to specify an alias of the joined data.
* Optionally, you can add condition and parameters used in condition.
*/
SelectQueryBuilder.prototype.leftJoinAndSelect = function (entityOrProperty, alias, condition, parameters) {
if (condition === void 0) { condition = ""; }
this.addSelect(alias);
this.leftJoin(entityOrProperty, alias, condition, parameters);
return this;
};
/**
* INNER JOINs, SELECTs the data returned by a join and MAPs all that data to some entity's property.
* This is extremely useful when you want to select some data and map it to some virtual property.
* It will assume that there are multiple rows of selecting data, and mapped result will be an array.
* You also need to specify an alias of the joined data.
* Optionally, you can add condition and parameters used in condition.
*/
SelectQueryBuilder.prototype.innerJoinAndMapMany = function (mapToProperty, entityOrProperty, alias, condition, parameters) {
if (condition === void 0) { condition = ""; }
this.addSelect(alias);
this.join("INNER", entityOrProperty, alias, condition, parameters, mapToProperty, true);
return this;
};
/**
* INNER JOINs, SELECTs the data returned by a join and MAPs all that data to some entity's property.
* This is extremely useful when you want to select some data and map it to some virtual property.
* It will assume that there is a single row of selecting data, and mapped result will be a single selected value.
* You also need to specify an alias of the joined data.
* Optionally, you can add condition and parameters used in condition.
*/
SelectQueryBuilder.prototype.innerJoinAndMapOne = function (mapToProperty, entityOrProperty, alias, condition, parameters) {
if (condition === void 0) { condition = ""; }
this.addSelect(alias);
this.join("INNER", entityOrProperty, alias, condition, parameters, mapToProperty, false);
return this;
};
/**
* LEFT JOINs, SELECTs the data returned by a join and MAPs all that data to some entity's property.
* This is extremely useful when you want to select some data and map it to some virtual property.
* It will assume that there are multiple rows of selecting data, and mapped result will be an array.
* You also need to specify an alias of the joined data.
* Optionally, you can add condition and parameters used in condition.
*/
SelectQueryBuilder.prototype.leftJoinAndMapMany = function (mapToProperty, entityOrProperty, alias, condition, parameters) {
if (condition === void 0) { condition = ""; }
this.addSelect(alias);
this.join("LEFT", entityOrProperty, alias, condition, parameters, mapToProperty, true);
return this;
};
/**
* LEFT JOINs, SELECTs the data returned by a join and MAPs all that data to some entity's property.
* This is extremely useful when you want to select some data and map it to some virtual property.
* It will assume that there is a single row of selecting data, and mapped result will be a single selected value.
* You also need to specify an alias of the joined data.
* Optionally, you can add condition and parameters used in condition.
*/
SelectQueryBuilder.prototype.leftJoinAndMapOne = function (mapToProperty, entityOrProperty, alias, condition, parameters) {
if (condition === void 0) { condition = ""; }
this.addSelect(alias);
this.join("LEFT", entityOrProperty, alias, condition, parameters, mapToProperty, false);
return this;
};
/**
* LEFT JOINs relation id and maps it into some entity's property.
* Optionally, you can add condition and parameters used in condition.
*/
SelectQueryBuilder.prototype.loadRelationIdAndMap = function (mapToProperty, relationName, aliasNameOrOptions, queryBuilderFactory) {
var relationIdAttribute = new RelationIdAttribute(this.expressionMap);
relationIdAttribute.mapToProperty = mapToProperty;
relationIdAttribute.relationName = relationName;
if (typeof aliasNameOrOptions === "string")
relationIdAttribute.alias = aliasNameOrOptions;
if (aliasNameOrOptions instanceof Object && aliasNameOrOptions.disableMixedMap)
relationIdAttribute.disableMixedMap = true;
relationIdAttribute.queryBuilderFactory = queryBuilderFactory;
this.expressionMap.relationIdAttributes.push(relationIdAttribute);
if (relationIdAttribute.relation.junctionEntityMetadata) {
this.expressionMap.createAlias({
type: "other",
name: relationIdAttribute.junctionAlias,
metadata: relationIdAttribute.relation.junctionEntityMetadata
});
}
return this;
};
/**
* Counts number of entities of entity's relation and maps the value into some entity's property.
* Optionally, you can add condition and parameters used in condition.
*/
SelectQueryBuilder.prototype.loadRelationCountAndMap = function (mapToProperty, relationName, aliasName, queryBuilderFactory) {
var relationCountAttribute = new RelationCountAttribute(this.expressionMap);
relationCountAttribute.mapToProperty = mapToProperty;
relationCountAttribute.relationName = relationName;
relationCountAttribute.alias = aliasName;
relationCountAttribute.queryBuilderFactory = queryBuilderFactory;
this.expressionMap.relationCountAttributes.push(relationCountAttribute);
this.expressionMap.createAlias({
type: "other",
name: relationCountAttribute.junctionAlias
});
if (relationCountAttribute.relation.junctionEntityMetadata) {
this.expressionMap.createAlias({
type: "other",
name: relationCountAttribute.junctionAlias,
metadata: relationCountAttribute.relation.junctionEntityMetadata
});
}
return this;
};
/**
* Loads all relation ids for all relations of the selected entity.
* All relation ids will be mapped to relation property themself.
* If array of strings is given then loads only relation ids of the given properties.
*/
SelectQueryBuilder.prototype.loadAllRelationIds = function (options) {
var _this = this;
this.expressionMap.mainAlias.metadata.relations.forEach(function (relation) {
if (options !== undefined && options.relations !== undefined && options.relations.indexOf(relation.propertyPath) === -1)
return;
_this.loadRelationIdAndMap(_this.expressionMap.mainAlias.name + "." + relation.propertyPath, _this.expressionMap.mainAlias.name + "." + relation.propertyPath, options);
});
return this;
};
/**
* Sets WHERE condition in the query builder.
* If you had previously WHERE expression defined,
* calling this function will override previously set WHERE conditions.
* Additionally you can add parameters used in where expression.
*/
SelectQueryBuilder.prototype.where = function (where, parameters) {
this.expressionMap.wheres = []; // don't move this block below since computeWhereParameter can add where expressions
var condition = this.computeWhereParameter(where);
if (condition)
this.expressionMap.wheres = [{ type: "simple", condition: condition }];
if (parameters)
this.setParameters(parameters);
return this;
};
/**
* Adds new AND WHERE condition in the query builder.
* Additionally you can add parameters used in where expression.
*/
SelectQueryBuilder.prototype.andWhere = function (where, parameters) {
this.expressionMap.wheres.push({ type: "and", condition: this.computeWhereParameter(where) });
if (parameters)
this.setParameters(parameters);
return this;
};
/**
* Adds new OR WHERE condition in the query builder.
* Additionally you can add parameters used in where expression.
*/
SelectQueryBuilder.prototype.orWhere = function (where, parameters) {
this.expressionMap.wheres.push({ type: "or", condition: this.computeWhereParameter(where) });
if (parameters)
this.setParameters(parameters);
return this;
};
/**
* Adds new AND WHERE with conditions for the given ids.
*
* Ids are mixed.
* It means if you have single primary key you can pass a simple id values, for example [1, 2, 3].
* If you have multiple primary keys you need to pass object with property names and values specified,
* for example [{ firstId: 1, secondId: 2 }, { firstId: 2, secondId: 3 }, ...]
*/
SelectQueryBuilder.prototype.whereInIds = function (ids) {
return this.where(this.createWhereIdsExpression(ids));
};
/**
* Adds new AND WHERE with conditions for the given ids.
*
* Ids are mixed.
* It means if you have single primary key you can pass a simple id values, for example [1, 2, 3].
* If you have multiple primary keys you need to pass object with property names and values specified,
* for example [{ firstId: 1, secondId: 2 }, { firstId: 2, secondId: 3 }, ...]
*/
SelectQueryBuilder.prototype.andWhereInIds = function (ids) {
return this.andWhere("(" + this.createWhereIdsExpression(ids) + ")");
};
/**
* Adds new OR WHERE with conditions for the given ids.
*
* Ids are mixed.
* It means if you have single primary key you can pass a simple id values, for example [1, 2, 3].
* If you have multiple primary keys you need to pass object with property names and values specified,
* for example [{ firstId: 1, secondId: 2 }, { firstId: 2, secondId: 3 }, ...]
*/
SelectQueryBuilder.prototype.orWhereInIds = function (ids) {
return this.orWhere("(" + this.createWhereIdsExpression(ids) + ")");
};
/**
* Sets HAVING condition in the query builder.
* If you had previously HAVING expression defined,
* calling this function will override previously set HAVING conditions.
* Additionally you can add parameters used in where expression.
*/
SelectQueryBuilder.prototype.having = function (having, parameters) {
this.expressionMap.havings.push({ type: "simple", condition: having });
if (parameters)
this.setParameters(parameters);
return this;
};
/**
* Adds new AND HAVING condition in the query builder.
* Additionally you can add parameters used in where expression.
*/
SelectQueryBuilder.prototype.andHaving = function (having, parameters) {
this.expressionMap.havings.push({ type: "and", condition: having });
if (parameters)
this.setParameters(parameters);
return this;
};
/**
* Adds new OR HAVING condition in the query builder.
* Additionally you can add parameters used in where expression.
*/
SelectQueryBuilder.prototype.orHaving = function (having, parameters) {
this.expressionMap.havings.push({ type: "or", condition: having });
if (parameters)
this.setParameters(parameters);
return this;
};
/**
* Sets GROUP BY condition in the query builder.
* If you had previously GROUP BY expression defined,
* calling this function will override previously set GROUP BY conditions.
*/
SelectQueryBuilder.prototype.groupBy = function (groupBy) {
if (groupBy) {
this.expressionMap.groupBys = [groupBy];
}
else {
this.expressionMap.groupBys = [];
}
return this;
};
/**
* Adds GROUP BY condition in the query builder.
*/
SelectQueryBuilder.prototype.addGroupBy = function (groupBy) {
this.expressionMap.groupBys.push(groupBy);
return this;
};
/**
* Sets ORDER BY condition in the query builder.
* If you had previously ORDER BY expression defined,
* calling this function will override previously set ORDER BY conditions.
*/
SelectQueryBuilder.prototype.orderBy = function (sort, order, nulls) {
if (order === void 0) { order = "ASC"; }
if (order !== undefined && order !== "ASC" && order !== "DESC")
throw new Error("SelectQueryBuilder.addOrderBy \"order\" can accept only \"ASC\" and \"DESC\" values.");
if (nulls !== undefined && nulls !== "NULLS FIRST" && nulls !== "NULLS LAST")
throw new Error("SelectQueryBuilder.addOrderBy \"nulls\" can accept only \"NULLS FIRST\" and \"NULLS LAST\" values.");
if (sort) {
if (sort instanceof Object) {
this.expressionMap.orderBys = sort;
}
else {
if (nulls) {
this.expressionMap.orderBys = (_a = {}, _a[sort] = { order: order, nulls: nulls }, _a);
}
else {
this.expressionMap.orderBys = (_b = {}, _b[sort] = order, _b);
}
}
}
else {
this.expressionMap.orderBys = {};
}
return this;
var _a, _b;
};
/**
* Adds ORDER BY condition in the query builder.
*/
SelectQueryBuilder.prototype.addOrderBy = function (sort, order, nulls) {
if (order === void 0) { order = "ASC"; }
if (order !== undefined && order !== "ASC" && order !== "DESC")
throw new Error("SelectQueryBuilder.addOrderBy \"order\" can accept only \"ASC\" and \"DESC\" values.");
if (nulls !== undefined && nulls !== "NULLS FIRST" && nulls !== "NULLS LAST")
throw new Error("SelectQueryBuilder.addOrderBy \"nulls\" can accept only \"NULLS FIRST\" and \"NULLS LAST\" values.");
if (nulls) {
this.expressionMap.orderBys[sort] = { order: order, nulls: nulls };
}
else {
this.expressionMap.orderBys[sort] = order;
}
return this;
};
/**
* Set's LIMIT - maximum number of rows to be selected.
* NOTE that it may not work as you expect if you are using joins.
* If you want to implement pagination, and you are having join in your query,
* then use instead take method instead.
*/
SelectQueryBuilder.prototype.limit = function (limit) {
this.expressionMap.limit = this.normalizeNumber(limit);
if (this.expressionMap.limit !== undefined && isNaN(this.expressionMap.limit))
throw new Error("Provided \"limit\" value is not a number. Please provide a numeric value.");
return this;
};
/**
* Set's OFFSET - selection offset.
* NOTE that it may not work as you expect if you are using joins.
* If you want to implement pagination, and you are having join in your query,
* then use instead skip method instead.
*/
SelectQueryBuilder.prototype.offset = function (offset) {
this.expressionMap.offset = this.normalizeNumber(offset);
if (this.expressionMap.offset !== undefined && isNaN(this.expressionMap.offset))
throw new Error("Provided \"offset\" value is not a number. Please provide a numeric value.");
return this;
};
/**
* Sets maximal number of entities to take.
*/
SelectQueryBuilder.prototype.take = function (take) {
this.expressionMap.take = this.normalizeNumber(take);
if (this.expressionMap.take !== undefined && isNaN(this.expressionMap.take))
throw new Error("Provided \"take\" value is not a number. Please provide a numeric value.");
return this;
};
/**
* Sets number of entities to skip.
*/
SelectQueryBuilder.prototype.skip = function (skip) {
this.expressionMap.skip = this.normalizeNumber(skip);
if (this.expressionMap.skip !== undefined && isNaN(this.expressionMap.skip))
throw new Error("Provided \"skip\" value is not a number. Please provide a numeric value.");
return this;
};
/**
* Sets locking mode.
*/
SelectQueryBuilder.prototype.setLock = function (lockMode, lockVersion) {
this.expressionMap.lockMode = lockMode;
this.expressionMap.lockVersion = lockVersion;
return this;
};
/**
* Gets first raw result returned by execution of generated query builder sql.
*/
SelectQueryBuilder.prototype.getRawOne = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.getRawMany()];
case 1: return [2 /*return*/, (_a.sent())[0]];
}
});
});
};
/**
* Gets all raw results returned by execution of generated query builder sql.
*/
SelectQueryBuilder.prototype.getRawMany = function () {
return __awaiter(this, void 0, void 0, function () {
var queryRunner, transactionStartedByUs, results, error_1, rollbackError_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (this.expressionMap.lockMode === "optimistic")
throw new OptimisticLockCanNotBeUsedError();
this.expressionMap.queryEntity = false;
queryRunner = this.obtainQueryRunner();
transactionStartedByUs = false;
_a.label = 1;
case 1:
_a.trys.push([1, 7, 12, 15]);
if (!(this.expressionMap.useTransaction === true && queryRunner.isTransactionActive === false)) return [3 /*break*/, 3];
return [4 /*yield*/, queryRunner.startTransaction()];
case 2:
_a.sent();
transactionStartedByUs = true;
_a.label = 3;
case 3: return [4 /*yield*/, this.loadRawResults(queryRunner)];
case 4:
results = _a.sent();
if (!transactionStartedByUs) return [3 /*break*/, 6];
return [4 /*yield*/, queryRunner.commitTransaction()];
case 5:
_a.sent();
_a.label = 6;
case 6: return [2 /*return*/, results];
case 7:
error_1 = _a.sent();
if (!transactionStartedByUs) return [3 /*break*/, 11];
_a.label = 8;
case 8:
_a.trys.push([8, 10, , 11]);
return [4 /*yield*/, queryRunner.rollbackTransaction()];
case 9:
_a.sent();
return [3 /*break*/, 11];
case 10:
rollbackError_1 = _a.sent();
return [3 /*break*/, 11];
case 11: throw error_1;
case 12:
if (!(queryRunner !== this.queryRunner)) return [3 /*break*/, 14];
return [4 /*yield*/, queryRunner.release()];
case 13:
_a.sent();
_a.label = 14;
case 14: return [7 /*endfinally*/];
case 15: return [2 /*return*/];
}
});
});
};
/**
* Executes sql generated by query builder and returns object with raw results and entities created from them.
*/
SelectQueryBuilder.prototype.getRawAndEntities = function () {
return __awaiter(this, void 0, void 0, function () {
var queryRunner, transactionStartedByUs, results, error_2, rollbackError_2;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
queryRunner = this.obtainQueryRunner();
transactionStartedByUs = false;
_a.label = 1;
case 1:
_a.trys.push([1, 7, 12, 15]);
if (!(this.expressionMap.useTransaction === true && queryRunner.isTransactionActive === false)) return [3 /*break*/, 3];
return [4 /*yield*/, queryRunner.startTransaction()];
case 2:
_a.sent();
transactionStartedByUs = true;
_a.label = 3;
case 3:
this.expressionMap.queryEntity = true;
return [4 /*yield*/, this.executeEntitiesAndRawResults(queryRunner)];
case 4:
results = _a.sent();
if (!transactionStartedByUs) return [3 /*break*/, 6];
return [4 /*yield*/, queryRunner.commitTransaction()];
case 5:
_a.sent();
_a.label = 6;
case 6: return [2 /*return*/, results];
case 7:
error_2 = _a.sent();
if (!transactionStartedByUs) return [3 /*break*/, 11];
_a.label = 8;
case 8:
_a.trys.push([8, 10, , 11]);
return [4 /*yield*/, queryRunner.rollbackTransaction()];
case 9:
_a.sent();
return [3 /*break*/, 11];
case 10:
rollbackError_2 = _a.sent();
return [3 /*break*/, 11];
case 11: throw error_2;
case 12:
if (!(queryRunner !== this.queryRunner)) return [3 /*break*/, 14];
return [4 /*yield*/, queryRunner.release()];
case 13:
_a.sent();
_a.label = 14;
case 14: return [7 /*endfinally*/];
case 15: return [2 /*return*/];
}
});
});
};
/**
* Gets single entity returned by execution of generated query builder sql.
*/
SelectQueryBuilder.prototype.getOne = function () {
return __awaiter(this, void 0, void 0, function () {
var results, result, metadata, actualVersion, actualVersion;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.getRawAndEntities()];
case 1:
results = _a.sent();
result = results.entities[0];
if (result && this.expressionMap.lockMode === "optimistic" && this.expressionMap.lockVersion) {
metadata = this.expressionMap.mainAlias.metadata;
if (this.expressionMap.lockVersion instanceof Date) {
actualVersion = metadata.updateDateColumn.getEntityValue(result);
if (actualVersion.getTime() !== this.expressionMap.lockVersion.getTime())
throw new OptimisticLockVersionMismatchError(metadata.name, this.expressionMap.lockVersion, actualVersion);
}
else {
actualVersion = metadata.versionColumn.getEntityValue(result);
if (actualVersion !== this.expressionMap.lockVersion)
throw new OptimisticLockVersionMismatchError(metadata.name, this.expressionMap.lockVersion, actualVersion);
}
}
return [2 /*return*/, result];
}
});
});
};
/**
* Gets entities returned by execution of generated query builder sql.
*/
SelectQueryBuilder.prototype.getMany = function () {
return __awaiter(this, void 0, void 0, function () {
var results;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (this.expressionMap.lockMode === "optimistic")
throw new OptimisticLockCanNotBeUsedError();
return [4 /*yield*/, this.getRawAndEntities()];
case 1:
results = _a.sent();
return [2 /*return*/, results.entities];
}
});
});
};
/**
* Gets count - number of entities selected by sql generated by this query builder.
* Count excludes all limitations set by setFirstResult and setMaxResults methods call.
*/
SelectQueryBuilder.prototype.getCount = function () {
return __awaiter(this, void 0, void 0, function () {
var queryRunner, transactionStartedByUs, results, error_3, rollbackError_3;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (this.expressionMap.lockMode === "optimistic")
throw new OptimisticLockCanNotBeUsedError();
queryRunner = this.obtainQueryRunner();
transactionStartedByUs = false;
_a.label = 1;
case 1:
_a.trys.push([1, 7, 12, 15]);
if (!(this.expressionMap.useTransaction === true && queryRunner.isTransactionActive === false)) return [3 /*break*/, 3];
return [4 /*yield*/, queryRunner.startTransaction()];
case 2:
_a.sent();
transactionStartedByUs = true;
_a.label = 3;
case 3:
this.expressionMap.queryEntity = false;
return [4 /*yield*/, this.executeCountQuery(queryRunner)];
case 4:
results = _a.sent();
if (!transactionStartedByUs) return [3 /*break*/, 6];
return [4 /*yield*/, queryRunner.commitTransaction()];
case 5:
_a.sent();
_a.label = 6;
case 6: return [2 /*return*/, results];
case 7:
error_3 = _a.sent();
if (!transactionStartedByUs) return [3 /*break*/, 11];
_a.label = 8;
case 8:
_a.trys.push([8, 10, , 11]);
return [4 /*yield*/, queryRunner.rollbackTransaction()];
case 9:
_a.sent();
return [3 /*break*/, 11];
case 10:
rollbackError_3 = _a.sent();
return [3 /*break*/, 11];
case 11: throw error_3;
case 12:
if (!(queryRunner !== this.queryRunner)) return [3 /*break*/, 14];
return [4 /*yield*/, queryRunner.release()];
case 13:
_a.sent();
_a.label = 14;
case 14: return [7 /*endfinally*/];
case 15: return [2 /*return*/];
}
});
});
};
/**
* Executes built SQL query and returns entities and overall entities count (without limitation).
* This method is useful to build pagination.
*/
SelectQueryBuilder.prototype.getManyAndCount = function () {
return __awaiter(this, void 0, void 0, function () {
var queryRunner, transactionStartedByUs, entitiesAndRaw, count, results, error_4, rollbackError_4;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (this.expressionMap.lockMode === "optimistic")
throw new OptimisticLockCanNotBeUsedError();
queryRunner = this.obtainQueryRunner();
transactionStartedByUs = false;
_a.label = 1;
case 1:
_a.trys.push([1, 8, 13, 16]);
if (!(this.expressionMap.useTransaction === true && queryRunner.isTransactionActive === false)) return [3 /*break*/, 3];
return [4 /*yield*/, queryRunner.startTransaction()];
case 2:
_a.sent();
transactionStartedByUs = true;
_a.label = 3;
case 3:
this.expressionMap.queryEntity = true;
return [4 /*yield*/, this.executeEntitiesAndRawResults(queryRunner)];
case 4:
entitiesAndRaw = _a.sent();
this.expressionMap.queryEntity = false;
return [4 /*yield*/, this.executeCountQuery(queryRunner)];
case 5:
count = _a.sent();
results = [entitiesAndRaw.entities, count];
if (!transactionStartedByUs) return [3 /*break*/, 7];
return [4 /*yield*/, queryRunner.commitTransaction()];
case 6:
_a.sent();
_a.label = 7;
case 7: return [2 /*return*/, results];
case 8:
error_4 = _a.sent();
if (!transactionStartedByUs) return [3 /*break*/, 12];
_a.label = 9;
case 9:
_a.trys.push([9, 11, , 12]);
return [4 /*yield*/, queryRunner.rollbackTransaction()];
case 10:
_a.sent();
return [3 /*break*/, 12];
case 11:
rollbackError_4 = _a.sent();
return [3 /*break*/, 12];
case 12: throw error_4;
case 13:
if (!(queryRunner !== this.queryRunner)) return [3 /*break*/, 15];
return [4 /*yield*/, queryRunner.release()];
case 14:
_a.sent();
_a.label = 15;
case 15: return [7 /*endfinally*/];
case 16: return [2 /*return*/];
}
});
});
};
/**
* Executes built SQL query and returns raw data stream.
*/
SelectQueryBuilder.prototype.stream = function () {
return __awaiter(this, void 0, void 0, function () {
var _this = this;
var _a, sql, parameters, queryRunner, transactionStartedByUs, releaseFn, results, error_5, rollbackError_5;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
this.expressionMap.queryEntity = false;
_a = this.getQueryAndParameters(), sql = _a[0], parameters = _a[1];
queryRunner = this.obtainQueryRunner();
transactionStartedByUs = false;
_b.label = 1;
case 1:
_b.trys.push([1, 6, 11, 14]);
if (!(this.expressionMap.useTransaction === true && queryRunner.isTransactionActive === false)) return [3 /*break*/, 3];
return [4 /*yield*/, queryRunner.startTransaction()];
case 2:
_b.sent();
transactionStartedByUs = true;
_b.label = 3;
case 3:
releaseFn = function () {
if (queryRunner !== _this.queryRunner) // means we created our own query runner
return queryRunner.release();
return;
};
results = queryRunner.stream(sql, parameters, releaseFn, releaseFn);
if (!transactionStartedByUs) return [3 /*break*/, 5];
return [4 /*yield*/, queryRunner.commitTransaction()];
case 4:
_b.sent();
_b.label = 5;
case 5: return [2 /*return*/, results];
case 6:
error_5 = _b.sent();
if (!transactionStartedByUs) return [3 /*break*/, 10];
_b.label = 7;
case 7:
_b.trys.push([7, 9, , 10]);
return [4 /*yield*/, queryRunner.rollbackTransaction()];
case 8:
_b.sent();
return [3 /*break*/, 10];
case 9:
rollbackError_5 = _b.sent();
return [3 /*break*/, 10];
case 10: throw error_5;
case 11:
if (!(queryRunner !== this.queryRunner)) return [3 /*break*/, 13];
return [4 /*yield*/, queryRunner.release()];
case 12:
_b.sent();
_b.label = 13;
case 13: return [7 /*endfinally*/];
case 14: return [2 /*return*/];
}
});
});
};
/**
* Enables or disables query result caching.
*/
SelectQueryBuilder.prototype.cache = function (enabledOrMillisecondsOrId, maybeMilliseconds) {
if (typeof enabledOrMillisecondsOrId === "boolean") {
this.expressionMap.cache = enabledOrMillisecondsOrId;
}
else if (typeof enabledOrMillisecondsOrId === "number") {
this.expressionMap.cache = true;
this.expressionMap.cacheDuration = enabledOrMillisecondsOrId;
}
else if (typeof enabledOrMillisecondsOrId === "string" || typeof enabledOrMillisecondsOrId === "number") {
this.expressionMap.cache = true;
this.expressionMap.cacheId = enabledOrMillisecondsOrId;
}
if (maybeMilliseconds) {
this.expressionMap.cacheDuration = maybeMilliseconds;
}
return this;
};
/**
* Sets extra options that can be used to configure how query builder works.
*/
SelectQueryBuilder.prototype.setOption = function (option) {
this.expressionMap.options.push(option);
return this;
};
// -------------------------------------------------------------------------
// Protected Methods
// -------------------------------------------------------------------------
SelectQueryBuilder.prototype.join = function (direction, entityOrProperty, aliasName, condition, parameters, mapToProperty, isMappingMany) {
this.setParameters(parameters || {});
var joinAttribute = new JoinAttribute(this.connection, this.expressionMap);
joinAttribute.direction = direction;
joinAttribute.mapToProperty = mapToProperty;
joinAttribute.isMappingMany = isMappingMany;
joinAttribute.entityOrProperty = entityOrProperty; // relationName
joinAttribute.condition = condition; // joinInverseSideCondition
// joinAttribute.junctionAlias = joinAttribute.relation.isOwning ? parentAlias + "_" + destinationTableAlias : destinationTableAlias + "_" + parentAlias;
this.expressionMap.joinAttributes.push(joinAttribute);
if (joinAttribute.metadata) {
// todo: find and set metadata right there?
joinAttribute.alias = this.expressionMap.createAlias({
type: "join",
name: aliasName,
metadata: joinAttribute.metadata
});
if (joinAttribute.relation && joinAttribute.relation.junctionEntityMetadata) {
this.expressionMap.createAlias({
type: "join",
name: joinAttribute.junctionAlias,
metadata: joinAttribute.relation.junctionEntityMetadata
});
}
}
else {
var subQuery = "";
if (entityOrProperty instanceof Function) {
var subQueryBuilder = entityOrProperty(this.subQuery());
this.setParameters(subQueryBuilder.getParameters());
subQuery = subQueryBuilder.getQuery();
}
else {
subQuery = entityOrProperty;
}
var isSubQuery = entityOrProperty instanceof Function || entityOrProperty.substr(0, 1) === "(" && entityOrProperty.substr(-1) === ")";
joinAttribute.alias = this.expressionMap.createAlias({
type: "join",
name: aliasName,
tablePath: isSubQuery === false ? entityOrProperty : undefined,
subQuery: isSubQuery === true ? subQuery : undefined,
});
}
};
/**
* Creates "SELECT FROM" part of SQL query.
*/
SelectQueryBuilder.prototype.createSelectExpression = function () {
var _this = this;
if (!this.expressionMap.mainAlias)
throw new Error("Cannot build query because main alias is not set (call qb#from method)");
// todo throw exception if selects or from is missing
var allSelects = [];
var excludedSelects = [];
if (this.expressionMap.mainAlias.hasMetadata) {
var metadata = this.expressionMap.mainAlias.metadata;
allSelects.push.apply(allSelects, this.buildEscapedEntityColumnSelects(this.expressionMap.mainAlias.name, metadata));
excludedSelects.push.apply(excludedSelects, this.findEntityColumnSelects(this.expressionMap.mainAlias.name, metadata));
}
// add selects from joins
this.expressionMap.joinAttributes
.forEach(function (join) {
if (join.metadata) {
allSelects.push.apply(allSelects, _this.buildEscapedEntityColumnSelects(join.alias.name, join.metadata));
excludedSelects.push.apply(excludedSelects, _this.findEntityColumnSelects(join.alias.name, join.metadata));
}
else {
var hasMainAlias = _this.expressionMap.selects.some(function (select) { return select.selection === join.alias.name; });
if (hasMainAlias) {
allSelects.push({ selection: _this.escape(join.alias.name) + ".*" });
var excludedSelect = _this.expressionMap.selects.find(function (select) { return select.selection === join.alias.name; });