typeorm 0.2.28 → 0.2.32

package/browser/query-builder/SelectQueryBuilder.js

@@ -1,4 +1,4 @@
-import { __awaiter, __extends, __generator, __read, __spread } from "tslib";
+import { __awaiter, __extends, __generator, __read, __spreadArray } from "tslib";
 import { SapDriver } from "../driver/sap/SapDriver";
 import { RawSqlResultsToEntityTransformer } from "./transformer/RawSqlResultsToEntityTransformer";
 import { SqlServerDriver } from "../driver/sqlserver/SqlServerDriver";
@@ -25,6 +25,7 @@ import { ObjectUtils } from "../util/ObjectUtils";
 import { DriverUtils } from "../driver/DriverUtils";
 import { AuroraDataApiDriver } from "../driver/aurora-data-api/AuroraDataApiDriver";
 import { CockroachDriver } from "../driver/cockroachdb/CockroachDriver";
+import { EntityNotFoundError } from "../error/EntityNotFoundError";
 /**
  * Allows to build complex sql queries in a fashion way and execute those queries.
  */
@@ -40,7 +41,8 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
      * Gets generated sql query without parameters being replaced.
      */
     SelectQueryBuilder.prototype.getQuery = function () {
-        var sql = this.createSelectExpression();
+        var sql = this.createComment();
+        sql += this.createSelectExpression();
         sql += this.createJoinExpression();
         sql += this.createWhereExpression();
         sql += this.createGroupByExpression();
@@ -506,9 +508,10 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
     /**
      * Sets locking mode.
      */
-    SelectQueryBuilder.prototype.setLock = function (lockMode, lockVersion) {
+    SelectQueryBuilder.prototype.setLock = function (lockMode, lockVersion, lockTables) {
         this.expressionMap.lockMode = lockMode;
         this.expressionMap.lockVersion = lockVersion;
+        this.expressionMap.lockTables = lockTables;
         return this;
     };
     /**
@@ -676,6 +679,25 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Gets the first entity returned by execution of generated query builder sql or rejects the returned promise on error.
+     */
+    SelectQueryBuilder.prototype.getOneOrFail = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var entity;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getOne()];
+                    case 1:
+                        entity = _a.sent();
+                        if (!entity) {
+                            throw new EntityNotFoundError(this.expressionMap.mainAlias.target, this);
+                        }
+                        return [2 /*return*/, entity];
+                }
+            });
+        });
+    };
     /**
      * Gets entities returned by execution of generated query builder sql.
      */
@@ -836,7 +858,7 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                         transactionStartedByUs = false;
                         _b.label = 1;
                     case 1:
-                        _b.trys.push([1, 6, 11, 14]);
+                        _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:
@@ -870,14 +892,7 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                         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*/];
+                    case 11: return [2 /*return*/];
                 }
             });
         });
@@ -923,6 +938,10 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
         // 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",
@@ -968,15 +987,15 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
         var excludedSelects = [];
         if (this.expressionMap.mainAlias.hasMetadata) {
             var metadata = this.expressionMap.mainAlias.metadata;
-            allSelects.push.apply(allSelects, __spread(this.buildEscapedEntityColumnSelects(this.expressionMap.mainAlias.name, metadata)));
-            excludedSelects.push.apply(excludedSelects, __spread(this.findEntityColumnSelects(this.expressionMap.mainAlias.name, metadata)));
+            allSelects.push.apply(allSelects, __spreadArray([], __read(this.buildEscapedEntityColumnSelects(this.expressionMap.mainAlias.name, metadata))));
+            excludedSelects.push.apply(excludedSelects, __spreadArray([], __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, __spread(_this.buildEscapedEntityColumnSelects(join.alias.name, join.metadata)));
-                excludedSelects.push.apply(excludedSelects, __spread(_this.findEntityColumnSelects(join.alias.name, join.metadata)));
+                allSelects.push.apply(allSelects, __spreadArray([], __read(_this.buildEscapedEntityColumnSelects(join.alias.name, join.metadata))));
+                excludedSelects.push.apply(excludedSelects, __spreadArray([], __read(_this.findEntityColumnSelects(join.alias.name, join.metadata))));
             }
             else {
                 var hasMainAlias = _this.expressionMap.selects.some(function (select) { return select.selection === join.alias.name; });
@@ -1074,6 +1093,9 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             else if (relation.isOneToMany || relation.isOneToOneNotOwner) {
                 // JOIN `post` `post` ON `post`.`categoryId` = `category`.`id`
                 var condition = relation.inverseRelation.joinColumns.map(function (joinColumn) {
+                    if (relation.inverseEntityMetadata.tableType === "entity-child" && relation.inverseEntityMetadata.discriminatorColumn) {
+                        appendedCondition += " AND " + destinationTableAlias + "." + relation.inverseEntityMetadata.discriminatorColumn.databaseName + "='" + relation.inverseEntityMetadata.discriminatorValue + "'";
+                    }
                     return destinationTableAlias + "." + relation.inverseRelation.propertyPath + "." + joinColumn.referencedColumn.propertyPath + "=" +
                         parentAlias + "." + joinColumn.referencedColumn.propertyPath;
                 }).join(" AND ");
@@ -1203,13 +1225,23 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
      */
     SelectQueryBuilder.prototype.createLockExpression = function () {
         var driver = this.connection.driver;
+        var lockTablesClause = "";
+        if (this.expressionMap.lockTables) {
+            if (!(driver instanceof PostgresDriver)) {
+                throw new Error("Lock tables not supported in selected driver");
+            }
+            if (this.expressionMap.lockTables.length < 1) {
+                throw new Error("lockTables cannot be an empty array");
+            }
+            lockTablesClause = " OF " + this.expressionMap.lockTables.join(", ");
+        }
         switch (this.expressionMap.lockMode) {
             case "pessimistic_read":
                 if (driver instanceof MysqlDriver || driver instanceof AuroraDataApiDriver) {
                     return " LOCK IN SHARE MODE";
                 }
                 else if (driver instanceof PostgresDriver) {
-                    return " FOR SHARE";
+                    return " FOR SHARE" + lockTablesClause;
                 }
                 else if (driver instanceof OracleDriver) {
                     return " FOR UPDATE";
@@ -1221,9 +1253,12 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                     throw new LockNotSupportedOnGivenDriverError();
                 }
             case "pessimistic_write":
-                if (driver instanceof MysqlDriver || driver instanceof AuroraDataApiDriver || driver instanceof PostgresDriver || driver instanceof OracleDriver) {
+                if (driver instanceof MysqlDriver || driver instanceof AuroraDataApiDriver || driver instanceof OracleDriver) {
                     return " FOR UPDATE";
                 }
+                else if (driver instanceof PostgresDriver) {
+                    return " FOR UPDATE" + lockTablesClause;
+                }
                 else if (driver instanceof SqlServerDriver) {
                     return "";
                 }
@@ -1232,6 +1267,9 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                 }
             case "pessimistic_partial_write":
                 if (driver instanceof PostgresDriver) {
+                    return " FOR UPDATE" + lockTablesClause + " SKIP LOCKED";
+                }
+                else if (driver instanceof MysqlDriver) {
                     return " FOR UPDATE SKIP LOCKED";
                 }
                 else {
@@ -1239,6 +1277,9 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                 }
             case "pessimistic_write_or_fail":
                 if (driver instanceof PostgresDriver) {
+                    return " FOR UPDATE" + lockTablesClause + " NOWAIT";
+                }
+                else if (driver instanceof MysqlDriver) {
                     return " FOR UPDATE NOWAIT";
                 }
                 else {
@@ -1246,7 +1287,7 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                 }
             case "for_no_key_update":
                 if (driver instanceof PostgresDriver) {
-                    return " FOR NO KEY UPDATE";
+                    return " FOR NO KEY UPDATE" + lockTablesClause;
                 }
                 else {
                     throw new LockNotSupportedOnGivenDriverError();
@@ -1281,18 +1322,18 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
         var hasMainAlias = this.expressionMap.selects.some(function (select) { return select.selection === aliasName; });
         var columns = [];
         if (hasMainAlias) {
-            columns.push.apply(columns, __spread(metadata.columns.filter(function (column) { return column.isSelect === true; })));
+            columns.push.apply(columns, __spreadArray([], __read(metadata.columns.filter(function (column) { return column.isSelect === true; }))));
         }
-        columns.push.apply(columns, __spread(metadata.columns.filter(function (column) {
+        columns.push.apply(columns, __spreadArray([], __read(metadata.columns.filter(function (column) {
             return _this.expressionMap.selects.some(function (select) { return select.selection === aliasName + "." + column.propertyPath; });
-        })));
+        }))));
         // if user used partial selection and did not select some primary columns which are required to be selected
         // we select those primary columns and mark them as "virtual". Later virtual column values will be removed from final entity
         // to make entity contain exactly what user selected
         if (columns.length === 0) // however not in the case when nothing (even partial) was selected from this target (for example joins without selection)
             return [];
         var nonSelectedPrimaryColumns = this.expressionMap.queryEntity ? metadata.primaryColumns.filter(function (primaryColumn) { return columns.indexOf(primaryColumn) === -1; }) : [];
-        var allColumns = __spread(columns, nonSelectedPrimaryColumns);
+        var allColumns = __spreadArray(__spreadArray([], __read(columns)), __read(nonSelectedPrimaryColumns));
         return allColumns.map(function (column) {
             var selection = _this.expressionMap.selects.find(function (select) { return select.selection === aliasName + "." + column.propertyPath; });
             var selectionPath = _this.escape(aliasName) + "." + _this.escape(column.databaseName);
@@ -1304,7 +1345,12 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                 }
                 if (_this.connection.driver instanceof PostgresDriver)
                     // cast to JSON to trigger parsing in the driver
-                    selectionPath = "ST_AsGeoJSON(" + selectionPath + ")::json";
+                    if (column.precision) {
+                        selectionPath = "ST_AsGeoJSON(" + selectionPath + ", " + column.precision + ")::json";
+                    }
+                    else {
+                        selectionPath = "ST_AsGeoJSON(" + selectionPath + ")::json";
+                    }
                 if (_this.connection.driver instanceof SqlServerDriver)
                     selectionPath = selectionPath + ".ToString()";
             }
@@ -1324,49 +1370,61 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             return metadata.columns.some(function (column) { return select.selection === aliasName + "." + column.propertyPath; });
         });
     };
+    SelectQueryBuilder.prototype.computeCountExpression = function () {
+        var _this = this;
+        var mainAlias = this.expressionMap.mainAlias.name; // todo: will this work with "fromTableName"?
+        var metadata = this.expressionMap.mainAlias.metadata;
+        var primaryColumns = metadata.primaryColumns;
+        var distinctAlias = this.escape(mainAlias);
+        // If we aren't doing anything that will create a join, we can use a simpler `COUNT` instead
+        // so we prevent poor query patterns in the most likely cases
+        if (this.expressionMap.joinAttributes.length === 0 &&
+            this.expressionMap.relationIdAttributes.length === 0 &&
+            this.expressionMap.relationCountAttributes.length === 0) {
+            return "COUNT(1)";
+        }
+        // For everything else, we'll need to do some hackery to get the correct count values.
+        if (this.connection.driver instanceof CockroachDriver || this.connection.driver instanceof PostgresDriver) {
+            // Postgres and CockroachDB can pass multiple parameters to the `DISTINCT` function
+            // https://www.postgresql.org/docs/9.5/sql-select.html#SQL-DISTINCT
+            return "COUNT(DISTINCT(" +
+                primaryColumns.map(function (c) { return distinctAlias + "." + _this.escape(c.databaseName); }).join(", ") +
+                "))";
+        }
+        if (this.connection.driver instanceof MysqlDriver) {
+            // MySQL & MariaDB can pass multiple parameters to the `DISTINCT` language construct
+            // https://mariadb.com/kb/en/count-distinct/
+            return "COUNT(DISTINCT " +
+                primaryColumns.map(function (c) { return distinctAlias + "." + _this.escape(c.databaseName); }).join(", ") +
+                ")";
+        }
+        if (this.connection.driver instanceof SqlServerDriver) {
+            // SQL Server has gotta be different from everyone else.  They don't support
+            // distinct counting multiple columns & they don't have the same operator
+            // characteristic for concatenating, so we gotta use the `CONCAT` function.
+            // However, If it's exactly 1 column we can omit the `CONCAT` for better performance.
+            var columnsExpression = primaryColumns.map(function (primaryColumn) { return distinctAlias + "." + _this.escape(primaryColumn.databaseName); }).join(", '|;|', ");
+            if (primaryColumns.length === 1) {
+                return "COUNT(DISTINCT(" + columnsExpression + "))";
+            }
+            return "COUNT(DISTINCT(CONCAT(" + columnsExpression + ")))";
+        }
+        // If all else fails, fall back to a `COUNT` and `DISTINCT` across all the primary columns concatenated.
+        // Per the SQL spec, this is the canonical string concatenation mechanism which is most
+        // likely to work across servers implementing the SQL standard.
+        // Please note, if there is only one primary column that the concatenation does not occur in this
+        // query and the query is a standard `COUNT DISTINCT` in that case.
+        return "COUNT(DISTINCT(" +
+            primaryColumns.map(function (c) { return distinctAlias + "." + _this.escape(c.databaseName); }).join(" || '|;|' || ") +
+            "))";
+    };
     SelectQueryBuilder.prototype.executeCountQuery = function (queryRunner) {
         return __awaiter(this, void 0, void 0, function () {
-            var mainAlias, metadata, distinctAlias, countSql, results;
-            var _this = this;
+            var countSql, results;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        mainAlias = this.expressionMap.mainAlias.name;
-                        metadata = this.expressionMap.mainAlias.metadata;
-                        distinctAlias = this.escape(mainAlias);
-                        countSql = "";
-                        if (metadata.hasMultiplePrimaryKeys) {
-                            if (this.connection.driver instanceof AbstractSqliteDriver) {
-                                countSql = "COUNT(DISTINCT(" + metadata.primaryColumns.map(function (primaryColumn, index) {
-                                    var propertyName = _this.escape(primaryColumn.databaseName);
-                                    return distinctAlias + "." + propertyName;
-                                }).join(" || ") + ")) as \"cnt\"";
-                            }
-                            else if (this.connection.driver instanceof CockroachDriver) {
-                                countSql = "COUNT(DISTINCT(CONCAT(" + metadata.primaryColumns.map(function (primaryColumn, index) {
-                                    var propertyName = _this.escape(primaryColumn.databaseName);
-                                    return distinctAlias + "." + propertyName + "::text";
-                                }).join(", ") + "))) as \"cnt\"";
-                            }
-                            else if (this.connection.driver instanceof OracleDriver) {
-                                countSql = "COUNT(DISTINCT(" + metadata.primaryColumns.map(function (primaryColumn, index) {
-                                    var propertyName = _this.escape(primaryColumn.databaseName);
-                                    return distinctAlias + "." + propertyName;
-                                }).join(" || ") + ")) as \"cnt\"";
-                            }
-                            else {
-                                countSql = "COUNT(DISTINCT(CONCAT(" + metadata.primaryColumns.map(function (primaryColumn, index) {
-                                    var propertyName = _this.escape(primaryColumn.databaseName);
-                                    return distinctAlias + "." + propertyName;
-                                }).join(", ") + "))) as \"cnt\"";
-                            }
-                        }
-                        else {
-                            countSql = "COUNT(DISTINCT(" + metadata.primaryColumns.map(function (primaryColumn, index) {
-                                var propertyName = _this.escape(primaryColumn.databaseName);
-                                return distinctAlias + "." + propertyName;
-                            }).join(", ") + ")) as \"cnt\"";
-                        }
+                        countSql = this.computeCountExpression();
                         return [4 /*yield*/, this.clone()
                                 .orderBy()
                                 .groupBy()
@@ -1374,7 +1432,7 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                                 .limit(undefined)
                                 .skip(undefined)
                                 .take(undefined)
-                                .select(countSql)
+                                .select(countSql, "cnt")
                                 .setOption("disable-global-order")
                                 .loadRawResults(queryRunner)];
                     case 1:
@@ -1507,9 +1565,11 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
         var selectString = Object.keys(orderBys)
             .map(function (orderCriteria) {
             if (orderCriteria.indexOf(".") !== -1) {
-                var _a = __read(orderCriteria.split("."), 2), aliasName = _a[0], propertyPath = _a[1];
+                var criteriaParts = orderCriteria.split(".");
+                var aliasName = criteriaParts[0];
+                var propertyPath = criteriaParts.slice(1).join(".");
                 var alias = _this.expressionMap.findAliasByName(aliasName);
-                var column = alias.metadata.findColumnWithPropertyName(propertyPath);
+                var column = alias.metadata.findColumnWithPropertyPath(propertyPath);
                 return _this.escape(parentAlias) + "." + _this.escape(DriverUtils.buildColumnAlias(_this.connection.driver, aliasName, column.databaseName));
             }
             else {
@@ -1522,9 +1582,11 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
         var orderByObject = {};
         Object.keys(orderBys).forEach(function (orderCriteria) {
             if (orderCriteria.indexOf(".") !== -1) {
-                var _a = __read(orderCriteria.split("."), 2), aliasName = _a[0], propertyPath = _a[1];
+                var criteriaParts = orderCriteria.split(".");
+                var aliasName = criteriaParts[0];
+                var propertyPath = criteriaParts.slice(1).join(".");
                 var alias = _this.expressionMap.findAliasByName(aliasName);
-                var column = alias.metadata.findColumnWithPropertyName(propertyPath);
+                var column = alias.metadata.findColumnWithPropertyPath(propertyPath);
                 orderByObject[_this.escape(parentAlias) + "." + _this.escape(DriverUtils.buildColumnAlias(_this.connection.driver, aliasName, column.databaseName))] = orderBys[orderCriteria];
             }
             else {