typeorm
Version:
Data-Mapper ORM for TypeScript, ES7, ES6, ES5. Supports MySQL, PostgreSQL, MariaDB, SQLite, MS SQL Server, Oracle, MongoDB databases.
1,014 lines • 92.3 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SelectQueryBuilder = void 0;
var tslib_1 = require("tslib");
var SapDriver_1 = require("../driver/sap/SapDriver");
var RawSqlResultsToEntityTransformer_1 = require("./transformer/RawSqlResultsToEntityTransformer");
var SqlServerDriver_1 = require("../driver/sqlserver/SqlServerDriver");
var PessimisticLockTransactionRequiredError_1 = require("../error/PessimisticLockTransactionRequiredError");
var NoVersionOrUpdateDateColumnError_1 = require("../error/NoVersionOrUpdateDateColumnError");
var OptimisticLockVersionMismatchError_1 = require("../error/OptimisticLockVersionMismatchError");
var OptimisticLockCanNotBeUsedError_1 = require("../error/OptimisticLockCanNotBeUsedError");
var JoinAttribute_1 = require("./JoinAttribute");
var RelationIdAttribute_1 = require("./relation-id/RelationIdAttribute");
var RelationCountAttribute_1 = require("./relation-count/RelationCountAttribute");
var RelationIdLoader_1 = require("./relation-id/RelationIdLoader");
var RelationIdMetadataToAttributeTransformer_1 = require("./relation-id/RelationIdMetadataToAttributeTransformer");
var RelationCountLoader_1 = require("./relation-count/RelationCountLoader");
var RelationCountMetadataToAttributeTransformer_1 = require("./relation-count/RelationCountMetadataToAttributeTransformer");
var QueryBuilder_1 = require("./QueryBuilder");
var LockNotSupportedOnGivenDriverError_1 = require("../error/LockNotSupportedOnGivenDriverError");
var MysqlDriver_1 = require("../driver/mysql/MysqlDriver");
var PostgresDriver_1 = require("../driver/postgres/PostgresDriver");
var OracleDriver_1 = require("../driver/oracle/OracleDriver");
var AbstractSqliteDriver_1 = require("../driver/sqlite-abstract/AbstractSqliteDriver");
var OffsetWithoutLimitNotSupportedError_1 = require("../error/OffsetWithoutLimitNotSupportedError");
var BroadcasterResult_1 = require("../subscriber/BroadcasterResult");
var ObjectUtils_1 = require("../util/ObjectUtils");
var DriverUtils_1 = require("../driver/DriverUtils");
var AuroraDataApiDriver_1 = require("../driver/aurora-data-api/AuroraDataApiDriver");
var CockroachDriver_1 = require("../driver/cockroachdb/CockroachDriver");
var EntityNotFoundError_1 = require("../error/EntityNotFoundError");
/**
* Allows to build complex sql queries in a fashion way and execute those queries.
*/
var SelectQueryBuilder = /** @class */ (function (_super) {
tslib_1.__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.createComment();
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 (Array.isArray(selection)) {
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 (Array.isArray(selection)) {
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;
};
/**
* Set max execution time.
* @param milliseconds
*/
SelectQueryBuilder.prototype.maxExecutionTime = function (milliseconds) {
this.expressionMap.maxExecutionTime = milliseconds;
return this;
};
/**
* Sets whether the selection is DISTINCT.
*/
SelectQueryBuilder.prototype.distinct = function (distinct) {
if (distinct === void 0) { distinct = true; }
this.expressionMap.selectDistinct = distinct;
return this;
};
/**
* Sets the distinct on clause for Postgres.
*/
SelectQueryBuilder.prototype.distinctOn = function (distinctOn) {
this.expressionMap.selectDistinctOn = distinctOn;
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_1.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_1.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) {
var _a, _b;
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;
};
/**
* 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, lockTables) {
this.expressionMap.lockMode = lockMode;
this.expressionMap.lockVersion = lockVersion;
this.expressionMap.lockTables = lockTables;
return this;
};
/**
* Disables the global condition of "non-deleted" for the entity with delete date columns.
*/
SelectQueryBuilder.prototype.withDeleted = function () {
this.expressionMap.withDeleted = true;
return this;
};
/**
* Gets first raw result returned by execution of generated query builder sql.
*/
SelectQueryBuilder.prototype.getRawOne = function () {
return tslib_1.__awaiter(this, void 0, void 0, function () {
return tslib_1.__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 tslib_1.__awaiter(this, void 0, void 0, function () {
var queryRunner, transactionStartedByUs, results, error_1, rollbackError_1;
return tslib_1.__generator(this, function (_a) {
switch (_a.label) {
case 0:
if (this.expressionMap.lockMode === "optimistic")
throw new OptimisticLockCanNotBeUsedError_1.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 tslib_1.__awaiter(this, void 0, void 0, function () {
var queryRunner, transactionStartedByUs, results, error_2, rollbackError_2;
return tslib_1.__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 tslib_1.__awaiter(this, void 0, void 0, function () {
var results, result, metadata, actualVersion, actualVersion;
return tslib_1.__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_1.OptimisticLockVersionMismatchError(metadata.name, this.expressionMap.lockVersion, actualVersion);
}
else {
actualVersion = metadata.versionColumn.getEntityValue(result);
if (actualVersion !== this.expressionMap.lockVersion)
throw new OptimisticLockVersionMismatchError_1.OptimisticLockVersionMismatchError(metadata.name, this.expressionMap.lockVersion, actualVersion);
}
}
return [2 /*return*/, result];
}
});
});
};
/**
* Gets the first entity returned by execution of generated query builder sql or rejects the returned promise on error.
*/
SelectQueryBuilder.prototype.getOneOrFail = function () {
return tslib_1.__awaiter(this, void 0, void 0, function () {
var entity;
return tslib_1.__generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.getOne()];
case 1:
entity = _a.sent();
if (!entity) {
throw new EntityNotFoundError_1.EntityNotFoundError(this.expressionMap.mainAlias.target, this);
}
return [2 /*return*/, entity];
}
});
});
};
/**
* Gets entities returned by execution of generated query builder sql.
*/
SelectQueryBuilder.prototype.getMany = function () {
return tslib_1.__awaiter(this, void 0, void 0, function () {
var results;
return tslib_1.__generator(this, function (_a) {
switch (_a.label) {
case 0:
if (this.expressionMap.lockMode === "optimistic")
throw new OptimisticLockCanNotBeUsedError_1.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 tslib_1.__awaiter(this, void 0, void 0, function () {
var queryRunner, transactionStartedByUs, results, error_3, rollbackError_3;
return tslib_1.__generator(this, function (_a) {
switch (_a.label) {
case 0:
if (this.expressionMap.lockMode === "optimistic")
throw new OptimisticLockCanNotBeUsedError_1.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 tslib_1.__awaiter(this, void 0, void 0, function () {
var queryRunner, transactionStartedByUs, entitiesAndRaw, count, results, error_4, rollbackError_4;
return tslib_1.__generator(this, function (_a) {
switch (_a.label) {
case 0:
if (this.expressionMap.lockMode === "optimistic")
throw new OptimisticLockCanNotBeUsedError_1.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 tslib_1.__awaiter(this, void 0, void 0, function () {
var _a, sql, parameters, queryRunner, transactionStartedByUs, releaseFn, results, error_5, rollbackError_5;
var _this = this;
return tslib_1.__generator(this, function (_b) {
switch (_b.label) {
case 0:
this.expressionMap.queryEntity = false;
_a = tslib_1.__read(this.getQueryAndParameters(), 2), sql = _a[0], parameters = _a[1];
queryRunner = this.obtainQueryRunner();
transactionStartedByUs = false;
_b.label = 1;
case 1:
_b.trys.push([1, 6, , 11]);
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: 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_1.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) {
if (joinAttribute.metadata.deleteDateColumn && !this.expressionMap.withDeleted) {
var conditionDeleteColumn = aliasName + "." + joinAttribute.metadata.deleteDateColumn.propertyName + " IS NULL";
joinAttribute.condition += joinAttribute.condition ? " AND " + conditionDeleteColumn : "" + conditionDeleteColumn;
}
// 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, tslib_1.__spreadArray([], tslib_1.__read(this.buildEscapedEntityColumnSelects(this.expressionMap.mainAlias.name, metadata))));
excludedSelects.push.apply(excludedSelects, tslib_1.__spreadArray([], tslib_1.__read(this.findEntityColumnSelects(this.expressionMap.mainAlias.name, metadata))));
}
// add selects from joins
this.expressionMap.joinAttributes
.forEach(function (join) {
if (join.metadata) {
allSelects.push.apply(allSelects, tslib_1.__spreadArray([], tslib_1.__read(_this.buildEscapedEntityColumnSelects(join.alias.name, join.metadata))));
excludedSelects.push.apply(excludedSelects, tslib_1.__spreadArray([], tslib_1.__read(_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) + ".*" }