typeorm 0.3.23-dev.cebd63b → 0.3.23-dev.fadad1a

package/browser/driver/spanner/SpannerQueryRunner.js

@@ -1,7 +1,9 @@
+import { TypeORMError } from "../../error";
 import { QueryFailedError } from "../../error/QueryFailedError";
 import { QueryRunnerAlreadyReleasedError } from "../../error/QueryRunnerAlreadyReleasedError";
 import { TransactionNotStartedError } from "../../error/TransactionNotStartedError";
 import { BaseQueryRunner } from "../../query-runner/BaseQueryRunner";
+import { QueryResult } from "../../query-runner/QueryResult";
 import { Table } from "../../schema-builder/table/Table";
 import { TableCheck } from "../../schema-builder/table/TableCheck";
 import { TableColumn } from "../../schema-builder/table/TableColumn";
@@ -10,12 +12,10 @@ import { TableIndex } from "../../schema-builder/table/TableIndex";
 import { TableUnique } from "../../schema-builder/table/TableUnique";
 import { View } from "../../schema-builder/view/View";
 import { Broadcaster } from "../../subscriber/Broadcaster";
+import { BroadcasterResult } from "../../subscriber/BroadcasterResult";
 import { OrmUtils } from "../../util/OrmUtils";
 import { Query } from "../Query";
-import { TypeORMError } from "../../error";
-import { QueryResult } from "../../query-runner/QueryResult";
 import { MetadataTableType } from "../types/MetadataTableType";
-import { BroadcasterResult } from "../../subscriber/BroadcasterResult";
 /**
  * Runs queries on a single postgres database connection.
  */
@@ -107,10 +107,12 @@ export class SpannerQueryRunner extends BaseQueryRunner {
     async query(query, parameters, useStructuredResult = false) {
         if (this.isReleased)
             throw new QueryRunnerAlreadyReleasedError();
+        await this.connect();
+        this.driver.connection.logger.logQuery(query, parameters, this);
+        await this.broadcaster.broadcast("BeforeQuery", query, parameters);
         const broadcasterResult = new BroadcasterResult();
         try {
-            const queryStartTime = +new Date();
-            await this.connect();
+            const queryStartTime = Date.now();
             let rawResult = undefined;
             const isSelect = query.startsWith("SELECT");
             const executor = isSelect && !this.isTransactionActive
@@ -120,8 +122,6 @@ export class SpannerQueryRunner extends BaseQueryRunner {
                 await this.sessionTransaction.begin();
             }
             try {
-                this.driver.connection.logger.logQuery(query, parameters, this);
-                this.broadcaster.broadcastBeforeQueryEvent(broadcasterResult, query, parameters);
                 rawResult = await executor.run({
                     sql: query,
                     params: parameters
@@ -147,7 +147,7 @@ export class SpannerQueryRunner extends BaseQueryRunner {
             }
             // log slow queries if maxQueryExecution time is set
             const maxQueryExecutionTime = this.driver.options.maxQueryExecutionTime;
-            const queryEndTime = +new Date();
+            const queryEndTime = Date.now();
             const queryExecutionTime = queryEndTime - queryStartTime;
             this.broadcaster.broadcastAfterQueryEvent(broadcasterResult, query, parameters, true, queryExecutionTime, rawResult, undefined);
             if (maxQueryExecutionTime &&
@@ -184,12 +184,12 @@ export class SpannerQueryRunner extends BaseQueryRunner {
             throw new QueryRunnerAlreadyReleasedError();
         this.driver.connection.logger.logQuery(query, parameters, this);
         try {
-            const queryStartTime = +new Date();
+            const queryStartTime = Date.now();
             const [operation] = await this.driver.instanceDatabase.updateSchema(query);
             await operation.promise();
             // log slow queries if maxQueryExecution time is set
             const maxQueryExecutionTime = this.driver.options.maxQueryExecutionTime;
-            const queryEndTime = +new Date();
+            const queryEndTime = Date.now();
             const queryExecutionTime = queryEndTime - queryStartTime;
             if (maxQueryExecutionTime &&
                 queryExecutionTime > maxQueryExecutionTime)