typeorm 0.3.18-dev.b240d87 → 0.3.18-dev.b5ec088

package/browser/driver/postgres/PostgresQueryRunner.js

@@ -18,6 +18,7 @@ import { OrmUtils } from "../../util/OrmUtils";
 import { VersionUtils } from "../../util/VersionUtils";
 import { Query } from "../Query";
 import { MetadataTableType } from "../types/MetadataTableType";
+import { BroadcasterResult } from "../../subscriber/BroadcasterResult";
 /**
  * Runs queries on a single postgres database connection.
  */
@@ -115,15 +116,16 @@ export class PostgresQueryRunner extends BaseQueryRunner {
             throw err;
         }
         if (this.transactionDepth === 0) {
+            this.transactionDepth += 1;
             await this.query("START TRANSACTION");
             if (isolationLevel) {
                 await this.query("SET TRANSACTION ISOLATION LEVEL " + isolationLevel);
             }
         }
         else {
-            await this.query(`SAVEPOINT typeorm_${this.transactionDepth}`);
+            this.transactionDepth += 1;
+            await this.query(`SAVEPOINT typeorm_${this.transactionDepth - 1}`);
         }
-        this.transactionDepth += 1;
         await this.broadcaster.broadcast("AfterTransactionStart");
     }
     /**
@@ -135,13 +137,14 @@ export class PostgresQueryRunner extends BaseQueryRunner {
             throw new TransactionNotStartedError();
         await this.broadcaster.broadcast("BeforeTransactionCommit");
         if (this.transactionDepth > 1) {
-            await this.query(`RELEASE SAVEPOINT typeorm_${this.transactionDepth - 1}`);
+            this.transactionDepth -= 1;
+            await this.query(`RELEASE SAVEPOINT typeorm_${this.transactionDepth}`);
         }
         else {
+            this.transactionDepth -= 1;
             await this.query("COMMIT");
             this.isTransactionActive = false;
         }
-        this.transactionDepth -= 1;
         await this.broadcaster.broadcast("AfterTransactionCommit");
     }
     /**
@@ -153,13 +156,14 @@ export class PostgresQueryRunner extends BaseQueryRunner {
             throw new TransactionNotStartedError();
         await this.broadcaster.broadcast("BeforeTransactionRollback");
         if (this.transactionDepth > 1) {
-            await this.query(`ROLLBACK TO SAVEPOINT typeorm_${this.transactionDepth - 1}`);
+            this.transactionDepth -= 1;
+            await this.query(`ROLLBACK TO SAVEPOINT typeorm_${this.transactionDepth}`);
         }
         else {
+            this.transactionDepth -= 1;
             await this.query("ROLLBACK");
             this.isTransactionActive = false;
         }
-        this.transactionDepth -= 1;
         await this.broadcaster.broadcast("AfterTransactionRollback");
     }
     /**
@@ -169,7 +173,9 @@ export class PostgresQueryRunner extends BaseQueryRunner {
         if (this.isReleased)
             throw new QueryRunnerAlreadyReleasedError();
         const databaseConnection = await this.connect();
+        const broadcasterResult = new BroadcasterResult();
         this.driver.connection.logger.logQuery(query, parameters, this);
+        this.broadcaster.broadcastBeforeQueryEvent(broadcasterResult, query, parameters);
         try {
             const queryStartTime = +new Date();
             const raw = await databaseConnection.query(query, parameters);
@@ -177,6 +183,7 @@ export class PostgresQueryRunner extends BaseQueryRunner {
             const maxQueryExecutionTime = this.driver.options.maxQueryExecutionTime;
             const queryEndTime = +new Date();
             const queryExecutionTime = queryEndTime - queryStartTime;
+            this.broadcaster.broadcastAfterQueryEvent(broadcasterResult, query, parameters, true, queryExecutionTime, raw, undefined);
             if (maxQueryExecutionTime &&
                 queryExecutionTime > maxQueryExecutionTime)
                 this.driver.connection.logger.logQuerySlow(queryExecutionTime, query, parameters, this);
@@ -205,8 +212,12 @@ export class PostgresQueryRunner extends BaseQueryRunner {
         }
         catch (err) {
             this.driver.connection.logger.logQueryError(err, query, parameters, this);
+            this.broadcaster.broadcastAfterQueryEvent(broadcasterResult, query, parameters, false, undefined, undefined, err);
             throw new QueryFailedError(query, parameters, err);
         }
+        finally {
+            await broadcasterResult.wait();
+        }
     }
     /**
      * Returns raw data stream.
@@ -1781,13 +1792,14 @@ export class PostgresQueryRunner extends BaseQueryRunner {
             `WHERE "t"."relkind" IN ('r', 'p') AND (${constraintsCondition})`;
         const indicesSql = `SELECT "ns"."nspname" AS "table_schema", "t"."relname" AS "table_name", "i"."relname" AS "constraint_name", "a"."attname" AS "column_name", ` +
             `CASE "ix"."indisunique" WHEN 't' THEN 'TRUE' ELSE'FALSE' END AS "is_unique", pg_get_expr("ix"."indpred", "ix"."indrelid") AS "condition", ` +
-            `"types"."typname" AS "type_name" ` +
+            `"types"."typname" AS "type_name", "am"."amname" AS "index_type" ` +
             `FROM "pg_class" "t" ` +
             `INNER JOIN "pg_index" "ix" ON "ix"."indrelid" = "t"."oid" ` +
             `INNER JOIN "pg_attribute" "a" ON "a"."attrelid" = "t"."oid"  AND "a"."attnum" = ANY ("ix"."indkey") ` +
             `INNER JOIN "pg_namespace" "ns" ON "ns"."oid" = "t"."relnamespace" ` +
             `INNER JOIN "pg_class" "i" ON "i"."oid" = "ix"."indexrelid" ` +
             `INNER JOIN "pg_type" "types" ON "types"."oid" = "a"."atttypid" ` +
+            `INNER JOIN "pg_am" "am" ON "i"."relam" = "am"."oid" ` +
             `LEFT JOIN "pg_constraint" "cnst" ON "cnst"."conname" = "i"."relname" ` +
             `WHERE "t"."relkind" IN ('r', 'p') AND "cnst"."contype" IS NULL AND (${constraintsCondition})`;
         const foreignKeysCondition = dbTables
@@ -1857,26 +1869,34 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                 tableColumn.name = dbColumn["column_name"];
                 tableColumn.type = dbColumn["regtype"].toLowerCase();
                 if (tableColumn.type === "numeric" ||
+                    tableColumn.type === "numeric[]" ||
                     tableColumn.type === "decimal" ||
                     tableColumn.type === "float") {
+                    let numericPrecision = dbColumn["numeric_precision"];
+                    let numericScale = dbColumn["numeric_scale"];
+                    if (dbColumn["data_type"] === "ARRAY") {
+                        const numericSize = dbColumn["format_type"].match(/^numeric\(([0-9]+),([0-9]+)\)\[\]$/);
+                        if (numericSize) {
+                            numericPrecision = +numericSize[1];
+                            numericScale = +numericSize[2];
+                        }
+                    }
                     // If one of these properties was set, and another was not, Postgres sets '0' in to unspecified property
                     // we set 'undefined' in to unspecified property to avoid changing column on sync
-                    if (dbColumn["numeric_precision"] !== null &&
-                        !this.isDefaultColumnPrecision(table, tableColumn, dbColumn["numeric_precision"])) {
-                        tableColumn.precision =
-                            dbColumn["numeric_precision"];
+                    if (numericPrecision !== null &&
+                        !this.isDefaultColumnPrecision(table, tableColumn, numericPrecision)) {
+                        tableColumn.precision = numericPrecision;
                     }
-                    else if (dbColumn["numeric_scale"] !== null &&
-                        !this.isDefaultColumnScale(table, tableColumn, dbColumn["numeric_scale"])) {
+                    else if (numericScale !== null &&
+                        !this.isDefaultColumnScale(table, tableColumn, numericScale)) {
                         tableColumn.precision = undefined;
                     }
-                    if (dbColumn["numeric_scale"] !== null &&
-                        !this.isDefaultColumnScale(table, tableColumn, dbColumn["numeric_scale"])) {
-                        tableColumn.scale =
-                            dbColumn["numeric_scale"];
+                    if (numericScale !== null &&
+                        !this.isDefaultColumnScale(table, tableColumn, numericScale)) {
+                        tableColumn.scale = numericScale;
                     }
-                    else if (dbColumn["numeric_precision"] !== null &&
-                        !this.isDefaultColumnPrecision(table, tableColumn, dbColumn["numeric_precision"])) {
+                    else if (numericPrecision !== null &&
+                        !this.isDefaultColumnPrecision(table, tableColumn, numericPrecision)) {
                         tableColumn.scale = undefined;
                     }
                 }
@@ -2159,7 +2179,7 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                     columnNames: indices.map((i) => i["column_name"]),
                     isUnique: constraint["is_unique"] === "TRUE",
                     where: constraint["condition"],
-                    isSpatial: indices.every((i) => this.driver.spatialTypes.indexOf(i["type_name"]) >= 0),
+                    isSpatial: constraint["index_type"] === "gist",
                     isFulltext: false,
                 });
             });
@@ -2380,7 +2400,7 @@ export class PostgresQueryRunner extends BaseQueryRunner {
         const columns = index.columnNames
             .map((columnName) => `"${columnName}"`)
             .join(", ");
-        return new Query(`CREATE ${index.isUnique ? "UNIQUE " : ""}INDEX "${index.name}" ON ${this.escapePath(table)} ${index.isSpatial ? "USING GiST " : ""}(${columns}) ${index.where ? "WHERE " + index.where : ""}`);
+        return new Query(`CREATE ${index.isUnique ? "UNIQUE " : ""}${index.isConcurrent ? "CONCURRENTLY " : ""}INDEX "${index.name}" ON ${this.escapePath(table)} ${index.isSpatial ? "USING GiST " : ""}(${columns}) ${index.where ? "WHERE " + index.where : ""}`);
     }
     /**
      * Builds create view index sql.
@@ -2398,10 +2418,13 @@ export class PostgresQueryRunner extends BaseQueryRunner {
         let indexName = InstanceChecker.isTableIndex(indexOrName)
             ? indexOrName.name
             : indexOrName;
+        const concurrent = InstanceChecker.isTableIndex(indexOrName)
+            ? indexOrName.isConcurrent
+            : false;
         const { schema } = this.driver.parseTableName(table);
         return schema
-            ? new Query(`DROP INDEX "${schema}"."${indexName}"`)
-            : new Query(`DROP INDEX "${indexName}"`);
+            ? new Query(`DROP INDEX ${concurrent ? "CONCURRENTLY" : ""}"${schema}"."${indexName}"`)
+            : new Query(`DROP INDEX ${concurrent ? "CONCURRENTLY" : ""}"${indexName}"`);
     }
     /**
      * Builds create primary key sql.