typeorm 0.2.27 → 0.2.31

package/query-builder/SelectQueryBuilder.js

@@ -1,6 +1,5 @@
 "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");
@@ -28,6 +27,7 @@ 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.
  */
@@ -43,7 +43,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();
@@ -679,6 +680,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 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.
      */
@@ -839,7 +859,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:
@@ -873,14 +893,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*/];
                 }
             });
         });
@@ -926,6 +939,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",
@@ -1077,6 +1094,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 ");
@@ -1234,14 +1254,14 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                     throw new LockNotSupportedOnGivenDriverError_1.LockNotSupportedOnGivenDriverError();
                 }
             case "pessimistic_partial_write":
-                if (driver instanceof PostgresDriver_1.PostgresDriver) {
+                if (driver instanceof PostgresDriver_1.PostgresDriver || driver instanceof MysqlDriver_1.MysqlDriver) {
                     return " FOR UPDATE SKIP LOCKED";
                 }
                 else {
                     throw new LockNotSupportedOnGivenDriverError_1.LockNotSupportedOnGivenDriverError();
                 }
             case "pessimistic_write_or_fail":
-                if (driver instanceof PostgresDriver_1.PostgresDriver) {
+                if (driver instanceof PostgresDriver_1.PostgresDriver || driver instanceof MysqlDriver_1.MysqlDriver) {
                     return " FOR UPDATE NOWAIT";
                 }
                 else {
@@ -1307,7 +1327,12 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                 }
                 if (_this.connection.driver instanceof PostgresDriver_1.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_1.SqlServerDriver)
                     selectionPath = selectionPath + ".ToString()";
             }
@@ -1327,49 +1352,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_1.CockroachDriver || this.connection.driver instanceof PostgresDriver_1.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_1.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_1.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 tslib_1.__awaiter(this, void 0, void 0, function () {
-            var mainAlias, metadata, distinctAlias, countSql, results;
-            var _this = this;
+            var countSql, results;
             return tslib_1.__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_1.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_1.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_1.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()
@@ -1377,7 +1414,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:
@@ -1510,9 +1547,11 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
         var selectString = Object.keys(orderBys)
             .map(function (orderCriteria) {
             if (orderCriteria.indexOf(".") !== -1) {
-                var _a = tslib_1.__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_1.DriverUtils.buildColumnAlias(_this.connection.driver, aliasName, column.databaseName));
             }
             else {
@@ -1525,9 +1564,11 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
         var orderByObject = {};
         Object.keys(orderBys).forEach(function (orderCriteria) {
             if (orderCriteria.indexOf(".") !== -1) {
-                var _a = tslib_1.__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_1.DriverUtils.buildColumnAlias(_this.connection.driver, aliasName, column.databaseName))] = orderBys[orderCriteria];
             }
             else {