typeorm 0.3.18-dev.fdb9866 → 0.3.18

package/browser/driver/mysql/MysqlQueryRunner.js

@@ -16,6 +16,7 @@ import { VersionUtils } from "../../util/VersionUtils";
 import { TypeORMError } from "../../error";
 import { MetadataTableType } from "../types/MetadataTableType";
 import { InstanceChecker } from "../../util/InstanceChecker";
+import { BroadcasterResult } from "../../subscriber/BroadcasterResult";
 /**
  * Runs queries on a single mysql database connection.
  */
@@ -84,15 +85,16 @@ export class MysqlQueryRunner extends BaseQueryRunner {
             throw err;
         }
         if (this.transactionDepth === 0) {
+            this.transactionDepth += 1;
             if (isolationLevel) {
                 await this.query("SET TRANSACTION ISOLATION LEVEL " + isolationLevel);
             }
             await this.query("START TRANSACTION");
         }
         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");
     }
     /**
@@ -104,13 +106,14 @@ export class MysqlQueryRunner 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");
     }
     /**
@@ -122,13 +125,14 @@ export class MysqlQueryRunner 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");
     }
     /**
@@ -138,11 +142,13 @@ export class MysqlQueryRunner extends BaseQueryRunner {
         if (this.isReleased)
             throw new QueryRunnerAlreadyReleasedError();
         return new Promise(async (ok, fail) => {
+            const broadcasterResult = new BroadcasterResult();
             try {
                 const databaseConnection = await this.connect();
                 this.driver.connection.logger.logQuery(query, parameters, this);
+                this.broadcaster.broadcastBeforeQueryEvent(broadcasterResult, query, parameters);
                 const queryStartTime = +new Date();
-                databaseConnection.query(query, parameters, (err, raw) => {
+                databaseConnection.query(query, parameters, async (err, raw) => {
                     // log slow queries if maxQueryExecution time is set
                     const maxQueryExecutionTime = this.driver.options.maxQueryExecutionTime;
                     const queryEndTime = +new Date();
@@ -152,8 +158,10 @@ export class MysqlQueryRunner extends BaseQueryRunner {
                         this.driver.connection.logger.logQuerySlow(queryExecutionTime, query, parameters, this);
                     if (err) {
                         this.driver.connection.logger.logQueryError(err, query, parameters, this);
+                        this.broadcaster.broadcastAfterQueryEvent(broadcasterResult, query, parameters, false, undefined, undefined, err);
                         return fail(new QueryFailedError(query, parameters, err));
                     }
+                    this.broadcaster.broadcastAfterQueryEvent(broadcasterResult, query, parameters, true, queryExecutionTime, raw, undefined);
                     const result = new QueryResult();
                     result.raw = raw;
                     try {
@@ -176,6 +184,9 @@ export class MysqlQueryRunner extends BaseQueryRunner {
             catch (err) {
                 fail(err);
             }
+            finally {
+                await broadcasterResult.wait();
+            }
         });
     }
     /**
@@ -488,6 +499,28 @@ export class MysqlQueryRunner extends BaseQueryRunner {
         oldTable.name = newTable.name;
         this.replaceCachedTable(oldTable, newTable);
     }
+    /**
+     * Change table comment.
+     */
+    async changeTableComment(tableOrName, newComment) {
+        const upQueries = [];
+        const downQueries = [];
+        const table = InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        newComment = this.escapeComment(newComment);
+        const comment = this.escapeComment(table.comment);
+        if (newComment === comment) {
+            return;
+        }
+        const newTable = table.clone();
+        upQueries.push(new Query(`ALTER TABLE ${this.escapePath(newTable)} COMMENT ${newComment}`));
+        downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} COMMENT ${comment}`));
+        await this.executeQueries(upQueries, downQueries);
+        // change table comment and replace it in cached tabled;
+        table.comment = newTable.comment;
+        this.replaceCachedTable(table, newTable);
+    }
     /**
      * Creates a new column from the column in the table.
      */
@@ -1367,7 +1400,7 @@ export class MysqlQueryRunner extends BaseQueryRunner {
         const dbTables = [];
         if (!tableNames) {
             // Since we don't have any of this data we have to do a scan
-            const tablesSql = `SELECT \`TABLE_SCHEMA\`, \`TABLE_NAME\` FROM \`INFORMATION_SCHEMA\`.\`TABLES\``;
+            const tablesSql = `SELECT \`TABLE_SCHEMA\`, \`TABLE_NAME\`, \`TABLE_COMMENT\` FROM \`INFORMATION_SCHEMA\`.\`TABLES\``;
             dbTables.push(...(await this.query(tablesSql)));
         }
         else {
@@ -1381,7 +1414,7 @@ export class MysqlQueryRunner extends BaseQueryRunner {
                 if (!database) {
                     database = currentDatabase;
                 }
-                return `SELECT \`TABLE_SCHEMA\`, \`TABLE_NAME\` FROM \`INFORMATION_SCHEMA\`.\`TABLES\` WHERE \`TABLE_SCHEMA\` = '${database}' AND \`TABLE_NAME\` = '${name}'`;
+                return `SELECT \`TABLE_SCHEMA\`, \`TABLE_NAME\`, \`TABLE_COMMENT\` FROM \`INFORMATION_SCHEMA\`.\`TABLES\` WHERE \`TABLE_SCHEMA\` = '${database}' AND \`TABLE_NAME\` = '${name}'`;
             })
                 .join(" UNION ");
             dbTables.push(...(await this.query(tablesSql)));
@@ -1613,7 +1646,7 @@ export class MysqlQueryRunner extends BaseQueryRunner {
                             ? "VIRTUAL"
                             : "STORED";
                     // We cannot relay on information_schema.columns.generation_expression, because it is formatted different.
-                    const asExpressionQuery = await this.selectTypeormMetadataSql({
+                    const asExpressionQuery = this.selectTypeormMetadataSql({
                         schema: dbTable["TABLE_SCHEMA"],
                         table: dbTable["TABLE_NAME"],
                         type: MetadataTableType.GENERATED_COLUMN,
@@ -1756,6 +1789,7 @@ export class MysqlQueryRunner extends BaseQueryRunner {
                     isFulltext: constraint["INDEX_TYPE"] === "FULLTEXT",
                 });
             });
+            table.comment = dbTable["TABLE_COMMENT"];
             return table;
         }));
     }
@@ -1852,6 +1886,9 @@ export class MysqlQueryRunner extends BaseQueryRunner {
             sql += `, PRIMARY KEY (${columnNames})`;
         }
         sql += `) ENGINE=${table.engine || "InnoDB"}`;
+        if (table.comment) {
+            sql += ` COMMENT="${table.comment}"`;
+        }
         return new Query(sql);
     }
     /**