taon-typeorm 18.0.19 → 18.0.20

package/lib/typeorm/driver/sqlite-abstract/AbstractSqliteQueryRunner.js

@@ -1,33 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractSqliteQueryRunner = void 0;
-var tslib_1 = require("tslib");
-var TransactionNotStartedError_1 = require("../../error/TransactionNotStartedError");
-var TableColumn_1 = require("../../schema-builder/table/TableColumn");
-var Table_1 = require("../../schema-builder/table/Table");
-var TableIndex_1 = require("../../schema-builder/table/TableIndex");
-var TableForeignKey_1 = require("../../schema-builder/table/TableForeignKey");
-var View_1 = require("../../schema-builder/view/View");
-var Query_1 = require("../Query");
-var TableUnique_1 = require("../../schema-builder/table/TableUnique");
-var BaseQueryRunner_1 = require("../../query-runner/BaseQueryRunner");
-var OrmUtils_1 = require("../../util/OrmUtils");
-var TableCheck_1 = require("../../schema-builder/table/TableCheck");
-var error_1 = require("../../error");
-var MetadataTableType_1 = require("../types/MetadataTableType");
-var InstanceChecker_1 = require("../../util/InstanceChecker");
+const TransactionNotStartedError_1 = require("../../error/TransactionNotStartedError");
+const TableColumn_1 = require("../../schema-builder/table/TableColumn");
+const Table_1 = require("../../schema-builder/table/Table");
+const TableIndex_1 = require("../../schema-builder/table/TableIndex");
+const TableForeignKey_1 = require("../../schema-builder/table/TableForeignKey");
+const View_1 = require("../../schema-builder/view/View");
+const Query_1 = require("../Query");
+const TableUnique_1 = require("../../schema-builder/table/TableUnique");
+const BaseQueryRunner_1 = require("../../query-runner/BaseQueryRunner");
+const OrmUtils_1 = require("../../util/OrmUtils");
+const TableCheck_1 = require("../../schema-builder/table/TableCheck");
+const error_1 = require("../../error");
+const MetadataTableType_1 = require("../types/MetadataTableType");
+const InstanceChecker_1 = require("../../util/InstanceChecker");
 /**
  * Runs queries on a single sqlite database connection.
  */
-var AbstractSqliteQueryRunner = /** @class */ (function (_super) {
-    tslib_1.__extends(AbstractSqliteQueryRunner, _super);
+class AbstractSqliteQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
+    // -------------------------------------------------------------------------
+    // Public Implemented Properties
+    // -------------------------------------------------------------------------
+    /**
+     * Database driver used by connection.
+     */
+    driver;
+    transactionPromise = null;
     // -------------------------------------------------------------------------
     // Constructor
     // -------------------------------------------------------------------------
-    function AbstractSqliteQueryRunner() {
-        var _this = _super.call(this) || this;
-        _this.transactionPromise = null;
-        return _this;
+    constructor() {
+        super();
     }
     // -------------------------------------------------------------------------
     // Public Methods
@@ -36,2030 +40,1211 @@ var AbstractSqliteQueryRunner = /** @class */ (function (_super) {
      * Creates/uses database connection from the connection pool to perform further operations.
      * Returns obtained database connection.
      */
-    AbstractSqliteQueryRunner.prototype.connect = function () {
+    connect() {
         return Promise.resolve(this.driver.databaseConnection);
-    };
+    }
     /**
      * Releases used database connection.
      * We just clear loaded tables and sql in memory, because sqlite do not support multiple connections thus query runners.
      */
-    AbstractSqliteQueryRunner.prototype.release = function () {
+    release() {
         this.loadedTables = [];
         this.clearSqlMemory();
         return Promise.resolve();
-    };
+    }
     /**
      * Starts transaction.
      */
-    AbstractSqliteQueryRunner.prototype.startTransaction = function (isolationLevel) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var err_1;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.driver.transactionSupport === "none")
-                            throw new error_1.TypeORMError("Transactions aren't supported by ".concat(this.connection.driver.options.type, "."));
-                        if (this.isTransactionActive &&
-                            this.driver.transactionSupport === "simple")
-                            throw new error_1.TransactionAlreadyStartedError();
-                        if (isolationLevel &&
-                            isolationLevel !== "READ UNCOMMITTED" &&
-                            isolationLevel !== "SERIALIZABLE")
-                            throw new error_1.TypeORMError("SQLite only supports SERIALIZABLE and READ UNCOMMITTED isolation");
-                        this.isTransactionActive = true;
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.broadcaster.broadcast("BeforeTransactionStart")];
-                    case 2:
-                        _a.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        err_1 = _a.sent();
-                        this.isTransactionActive = false;
-                        throw err_1;
-                    case 4:
-                        if (!(this.transactionDepth === 0)) return [3 /*break*/, 10];
-                        if (!isolationLevel) return [3 /*break*/, 8];
-                        if (!(isolationLevel === "READ UNCOMMITTED")) return [3 /*break*/, 6];
-                        return [4 /*yield*/, this.query("PRAGMA read_uncommitted = true")];
-                    case 5:
-                        _a.sent();
-                        return [3 /*break*/, 8];
-                    case 6: return [4 /*yield*/, this.query("PRAGMA read_uncommitted = false")];
-                    case 7:
-                        _a.sent();
-                        _a.label = 8;
-                    case 8: return [4 /*yield*/, this.query("BEGIN TRANSACTION")];
-                    case 9:
-                        _a.sent();
-                        return [3 /*break*/, 12];
-                    case 10: return [4 /*yield*/, this.query("SAVEPOINT typeorm_".concat(this.transactionDepth))];
-                    case 11:
-                        _a.sent();
-                        _a.label = 12;
-                    case 12:
-                        this.transactionDepth += 1;
-                        return [4 /*yield*/, this.broadcaster.broadcast("AfterTransactionStart")];
-                    case 13:
-                        _a.sent();
-                        return [2 /*return*/];
+    async startTransaction(isolationLevel) {
+        if (this.driver.transactionSupport === "none")
+            throw new error_1.TypeORMError(`Transactions aren't supported by ${this.connection.driver.options.type}.`);
+        if (this.isTransactionActive &&
+            this.driver.transactionSupport === "simple")
+            throw new error_1.TransactionAlreadyStartedError();
+        if (isolationLevel &&
+            isolationLevel !== "READ UNCOMMITTED" &&
+            isolationLevel !== "SERIALIZABLE")
+            throw new error_1.TypeORMError(`SQLite only supports SERIALIZABLE and READ UNCOMMITTED isolation`);
+        this.isTransactionActive = true;
+        try {
+            await this.broadcaster.broadcast("BeforeTransactionStart");
+        }
+        catch (err) {
+            this.isTransactionActive = false;
+            throw err;
+        }
+        if (this.transactionDepth === 0) {
+            if (isolationLevel) {
+                if (isolationLevel === "READ UNCOMMITTED") {
+                    await this.query("PRAGMA read_uncommitted = true");
                 }
-            });
-        });
-    };
+                else {
+                    await this.query("PRAGMA read_uncommitted = false");
+                }
+            }
+            await this.query("BEGIN TRANSACTION");
+        }
+        else {
+            await this.query(`SAVEPOINT typeorm_${this.transactionDepth}`);
+        }
+        this.transactionDepth += 1;
+        await this.broadcaster.broadcast("AfterTransactionStart");
+    }
     /**
      * Commits transaction.
      * Error will be thrown if transaction was not started.
      */
-    AbstractSqliteQueryRunner.prototype.commitTransaction = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.isTransactionActive)
-                            throw new TransactionNotStartedError_1.TransactionNotStartedError();
-                        return [4 /*yield*/, this.broadcaster.broadcast("BeforeTransactionCommit")];
-                    case 1:
-                        _a.sent();
-                        if (!(this.transactionDepth > 1)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.query("RELEASE SAVEPOINT typeorm_".concat(this.transactionDepth - 1))];
-                    case 2:
-                        _a.sent();
-                        return [3 /*break*/, 5];
-                    case 3: return [4 /*yield*/, this.query("COMMIT")];
-                    case 4:
-                        _a.sent();
-                        this.isTransactionActive = false;
-                        _a.label = 5;
-                    case 5:
-                        this.transactionDepth -= 1;
-                        return [4 /*yield*/, this.broadcaster.broadcast("AfterTransactionCommit")];
-                    case 6:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async commitTransaction() {
+        if (!this.isTransactionActive)
+            throw new TransactionNotStartedError_1.TransactionNotStartedError();
+        await this.broadcaster.broadcast("BeforeTransactionCommit");
+        if (this.transactionDepth > 1) {
+            await this.query(`RELEASE SAVEPOINT typeorm_${this.transactionDepth - 1}`);
+        }
+        else {
+            await this.query("COMMIT");
+            this.isTransactionActive = false;
+        }
+        this.transactionDepth -= 1;
+        await this.broadcaster.broadcast("AfterTransactionCommit");
+    }
     /**
      * Rollbacks transaction.
      * Error will be thrown if transaction was not started.
      */
-    AbstractSqliteQueryRunner.prototype.rollbackTransaction = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.isTransactionActive)
-                            throw new TransactionNotStartedError_1.TransactionNotStartedError();
-                        return [4 /*yield*/, this.broadcaster.broadcast("BeforeTransactionRollback")];
-                    case 1:
-                        _a.sent();
-                        if (!(this.transactionDepth > 1)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.query("ROLLBACK TO SAVEPOINT typeorm_".concat(this.transactionDepth - 1))];
-                    case 2:
-                        _a.sent();
-                        return [3 /*break*/, 5];
-                    case 3: return [4 /*yield*/, this.query("ROLLBACK")];
-                    case 4:
-                        _a.sent();
-                        this.isTransactionActive = false;
-                        _a.label = 5;
-                    case 5:
-                        this.transactionDepth -= 1;
-                        return [4 /*yield*/, this.broadcaster.broadcast("AfterTransactionRollback")];
-                    case 6:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async rollbackTransaction() {
+        if (!this.isTransactionActive)
+            throw new TransactionNotStartedError_1.TransactionNotStartedError();
+        await this.broadcaster.broadcast("BeforeTransactionRollback");
+        if (this.transactionDepth > 1) {
+            await this.query(`ROLLBACK TO SAVEPOINT typeorm_${this.transactionDepth - 1}`);
+        }
+        else {
+            await this.query("ROLLBACK");
+            this.isTransactionActive = false;
+        }
+        this.transactionDepth -= 1;
+        await this.broadcaster.broadcast("AfterTransactionRollback");
+    }
     /**
      * Returns raw data stream.
      */
-    AbstractSqliteQueryRunner.prototype.stream = function (query, parameters, onEnd, onError) {
-        throw new error_1.TypeORMError("Stream is not supported by sqlite driver.");
-    };
+    stream(query, parameters, onEnd, onError) {
+        throw new error_1.TypeORMError(`Stream is not supported by sqlite driver.`);
+    }
     /**
      * Returns all available database names including system databases.
      */
-    AbstractSqliteQueryRunner.prototype.getDatabases = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, Promise.resolve([])];
-            });
-        });
-    };
+    async getDatabases() {
+        return Promise.resolve([]);
+    }
     /**
      * Returns all available schema names including system schemas.
      * If database parameter specified, returns schemas of that database.
      */
-    AbstractSqliteQueryRunner.prototype.getSchemas = function (database) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, Promise.resolve([])];
-            });
-        });
-    };
+    async getSchemas(database) {
+        return Promise.resolve([]);
+    }
     /**
      * Checks if database with the given name exist.
      */
-    AbstractSqliteQueryRunner.prototype.hasDatabase = function (database) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, Promise.resolve(false)];
-            });
-        });
-    };
+    async hasDatabase(database) {
+        return Promise.resolve(false);
+    }
     /**
      * Loads currently using database
      */
-    AbstractSqliteQueryRunner.prototype.getCurrentDatabase = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, Promise.resolve(undefined)];
-            });
-        });
-    };
+    async getCurrentDatabase() {
+        return Promise.resolve(undefined);
+    }
     /**
      * Checks if schema with the given name exist.
      */
-    AbstractSqliteQueryRunner.prototype.hasSchema = function (schema) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                throw new error_1.TypeORMError("This driver does not support table schemas");
-            });
-        });
-    };
+    async hasSchema(schema) {
+        throw new error_1.TypeORMError(`This driver does not support table schemas`);
+    }
     /**
      * Loads currently using database schema
      */
-    AbstractSqliteQueryRunner.prototype.getCurrentSchema = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, Promise.resolve(undefined)];
-            });
-        });
-    };
+    async getCurrentSchema() {
+        return Promise.resolve(undefined);
+    }
     /**
      * Checks if table with the given name exist in the database.
      */
-    AbstractSqliteQueryRunner.prototype.hasTable = function (tableOrName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var tableName, sql, result;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        tableName = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
-                            ? tableOrName.name
-                            : tableOrName;
-                        sql = "SELECT * FROM \"sqlite_master\" WHERE \"type\" = 'table' AND \"name\" = '".concat(tableName, "'");
-                        return [4 /*yield*/, this.query(sql)];
-                    case 1:
-                        result = _a.sent();
-                        return [2 /*return*/, result.length ? true : false];
-                }
-            });
-        });
-    };
+    async hasTable(tableOrName) {
+        const tableName = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName.name
+            : tableOrName;
+        const sql = `SELECT * FROM "sqlite_master" WHERE "type" = 'table' AND "name" = '${tableName}'`;
+        const result = await this.query(sql);
+        return result.length ? true : false;
+    }
     /**
      * Checks if column with the given name exist in the given table.
      */
-    AbstractSqliteQueryRunner.prototype.hasColumn = function (tableOrName, columnName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var tableName, sql, columns;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        tableName = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
-                            ? tableOrName.name
-                            : tableOrName;
-                        sql = "PRAGMA table_xinfo(".concat(this.escapePath(tableName), ")");
-                        return [4 /*yield*/, this.query(sql)];
-                    case 1:
-                        columns = _a.sent();
-                        return [2 /*return*/, !!columns.find(function (column) { return column["name"] === columnName; })];
-                }
-            });
-        });
-    };
+    async hasColumn(tableOrName, columnName) {
+        const tableName = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName.name
+            : tableOrName;
+        const sql = `PRAGMA table_xinfo(${this.escapePath(tableName)})`;
+        const columns = await this.query(sql);
+        return !!columns.find((column) => column["name"] === columnName);
+    }
     /**
      * Creates a new database.
      */
-    AbstractSqliteQueryRunner.prototype.createDatabase = function (database, ifNotExist) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, Promise.resolve()];
-            });
-        });
-    };
+    async createDatabase(database, ifNotExist) {
+        return Promise.resolve();
+    }
     /**
      * Drops database.
      */
-    AbstractSqliteQueryRunner.prototype.dropDatabase = function (database, ifExist) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, Promise.resolve()];
-            });
-        });
-    };
+    async dropDatabase(database, ifExist) {
+        return Promise.resolve();
+    }
     /**
      * Creates a new table schema.
      */
-    AbstractSqliteQueryRunner.prototype.createSchema = function (schemaPath, ifNotExist) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, Promise.resolve()];
-            });
-        });
-    };
+    async createSchema(schemaPath, ifNotExist) {
+        return Promise.resolve();
+    }
     /**
      * Drops table schema.
      */
-    AbstractSqliteQueryRunner.prototype.dropSchema = function (schemaPath, ifExist) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, Promise.resolve()];
-            });
-        });
-    };
+    async dropSchema(schemaPath, ifExist) {
+        return Promise.resolve();
+    }
     /**
      * Creates a new table.
      */
-    AbstractSqliteQueryRunner.prototype.createTable = function (table_1) {
-        return tslib_1.__awaiter(this, arguments, void 0, function (table, ifNotExist, createForeignKeys, createIndices) {
-            var upQueries, downQueries, isTableExist, generatedColumns, generatedColumns_1, generatedColumns_1_1, column, insertQuery, deleteQuery;
-            var e_1, _a;
-            var _this = this;
-            if (ifNotExist === void 0) { ifNotExist = false; }
-            if (createForeignKeys === void 0) { createForeignKeys = true; }
-            if (createIndices === void 0) { createIndices = true; }
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        upQueries = [];
-                        downQueries = [];
-                        if (!ifNotExist) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.hasTable(table)];
-                    case 1:
-                        isTableExist = _b.sent();
-                        if (isTableExist)
-                            return [2 /*return*/, Promise.resolve()];
-                        _b.label = 2;
-                    case 2:
-                        upQueries.push(this.createTableSql(table, createForeignKeys));
-                        downQueries.push(this.dropTableSql(table));
-                        if (createIndices) {
-                            table.indices.forEach(function (index) {
-                                // new index may be passed without name. In this case we generate index name manually.
-                                if (!index.name)
-                                    index.name = _this.connection.namingStrategy.indexName(table, index.columnNames, index.where);
-                                upQueries.push(_this.createIndexSql(table, index));
-                                downQueries.push(_this.dropIndexSql(index));
-                            });
-                        }
-                        generatedColumns = table.columns.filter(function (column) { return column.generatedType && column.asExpression; });
-                        try {
-                            for (generatedColumns_1 = tslib_1.__values(generatedColumns), generatedColumns_1_1 = generatedColumns_1.next(); !generatedColumns_1_1.done; generatedColumns_1_1 = generatedColumns_1.next()) {
-                                column = generatedColumns_1_1.value;
-                                insertQuery = this.insertTypeormMetadataSql({
-                                    table: table.name,
-                                    type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                                    name: column.name,
-                                    value: column.asExpression,
-                                });
-                                deleteQuery = this.deleteTypeormMetadataSql({
-                                    table: table.name,
-                                    type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                                    name: column.name,
-                                });
-                                upQueries.push(insertQuery);
-                                downQueries.push(deleteQuery);
-                            }
-                        }
-                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                        finally {
-                            try {
-                                if (generatedColumns_1_1 && !generatedColumns_1_1.done && (_a = generatedColumns_1.return)) _a.call(generatedColumns_1);
-                            }
-                            finally { if (e_1) throw e_1.error; }
-                        }
-                        return [4 /*yield*/, this.executeQueries(upQueries, downQueries)];
-                    case 3:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
+    async createTable(table, ifNotExist = false, createForeignKeys = true, createIndices = true) {
+        const upQueries = [];
+        const downQueries = [];
+        if (ifNotExist) {
+            const isTableExist = await this.hasTable(table);
+            if (isTableExist)
+                return Promise.resolve();
+        }
+        upQueries.push(this.createTableSql(table, createForeignKeys));
+        downQueries.push(this.dropTableSql(table));
+        if (createIndices) {
+            table.indices.forEach((index) => {
+                // new index may be passed without name. In this case we generate index name manually.
+                if (!index.name)
+                    index.name = this.connection.namingStrategy.indexName(table, index.columnNames, index.where);
+                upQueries.push(this.createIndexSql(table, index));
+                downQueries.push(this.dropIndexSql(index));
             });
-        });
-    };
+        }
+        // if table have column with generated type, we must add the expression to the metadata table
+        const generatedColumns = table.columns.filter((column) => column.generatedType && column.asExpression);
+        for (const column of generatedColumns) {
+            const insertQuery = this.insertTypeormMetadataSql({
+                table: table.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                table: table.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            upQueries.push(insertQuery);
+            downQueries.push(deleteQuery);
+        }
+        await this.executeQueries(upQueries, downQueries);
+    }
     /**
      * Drops the table.
      */
-    AbstractSqliteQueryRunner.prototype.dropTable = function (tableOrName_1, ifExist_1) {
-        return tslib_1.__awaiter(this, arguments, void 0, function (tableOrName, ifExist, dropForeignKeys, dropIndices) {
-            var isTableExist, createForeignKeys, table, _a, upQueries, downQueries, generatedColumns, generatedColumns_2, generatedColumns_2_1, column, deleteQuery, insertQuery;
-            var e_2, _b;
-            var _this = this;
-            if (dropForeignKeys === void 0) { dropForeignKeys = true; }
-            if (dropIndices === void 0) { dropIndices = true; }
-            return tslib_1.__generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!ifExist) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.hasTable(tableOrName)];
-                    case 1:
-                        isTableExist = _c.sent();
-                        if (!isTableExist)
-                            return [2 /*return*/, Promise.resolve()];
-                        _c.label = 2;
-                    case 2:
-                        createForeignKeys = dropForeignKeys;
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 3];
-                        _a = tableOrName;
-                        return [3 /*break*/, 5];
-                    case 3: return [4 /*yield*/, this.getCachedTable(tableOrName)];
-                    case 4:
-                        _a = _c.sent();
-                        _c.label = 5;
-                    case 5:
-                        table = _a;
-                        upQueries = [];
-                        downQueries = [];
-                        if (dropIndices) {
-                            table.indices.forEach(function (index) {
-                                upQueries.push(_this.dropIndexSql(index));
-                                downQueries.push(_this.createIndexSql(table, index));
-                            });
-                        }
-                        upQueries.push(this.dropTableSql(table, ifExist));
-                        downQueries.push(this.createTableSql(table, createForeignKeys));
-                        generatedColumns = table.columns.filter(function (column) { return column.generatedType && column.asExpression; });
-                        try {
-                            for (generatedColumns_2 = tslib_1.__values(generatedColumns), generatedColumns_2_1 = generatedColumns_2.next(); !generatedColumns_2_1.done; generatedColumns_2_1 = generatedColumns_2.next()) {
-                                column = generatedColumns_2_1.value;
-                                deleteQuery = this.deleteTypeormMetadataSql({
-                                    table: table.name,
-                                    type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                                    name: column.name,
-                                });
-                                insertQuery = this.insertTypeormMetadataSql({
-                                    table: table.name,
-                                    type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                                    name: column.name,
-                                    value: column.asExpression,
-                                });
-                                upQueries.push(deleteQuery);
-                                downQueries.push(insertQuery);
-                            }
-                        }
-                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                        finally {
-                            try {
-                                if (generatedColumns_2_1 && !generatedColumns_2_1.done && (_b = generatedColumns_2.return)) _b.call(generatedColumns_2);
-                            }
-                            finally { if (e_2) throw e_2.error; }
-                        }
-                        return [4 /*yield*/, this.executeQueries(upQueries, downQueries)];
-                    case 6:
-                        _c.sent();
-                        return [2 /*return*/];
-                }
+    async dropTable(tableOrName, ifExist, dropForeignKeys = true, dropIndices = true) {
+        if (ifExist) {
+            const isTableExist = await this.hasTable(tableOrName);
+            if (!isTableExist)
+                return Promise.resolve();
+        }
+        // if dropTable called with dropForeignKeys = true, we must create foreign keys in down query.
+        const createForeignKeys = dropForeignKeys;
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        const upQueries = [];
+        const downQueries = [];
+        if (dropIndices) {
+            table.indices.forEach((index) => {
+                upQueries.push(this.dropIndexSql(index));
+                downQueries.push(this.createIndexSql(table, index));
             });
-        });
-    };
+        }
+        upQueries.push(this.dropTableSql(table, ifExist));
+        downQueries.push(this.createTableSql(table, createForeignKeys));
+        // if table had columns with generated type, we must remove the expression from the metadata table
+        const generatedColumns = table.columns.filter((column) => column.generatedType && column.asExpression);
+        for (const column of generatedColumns) {
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                table: table.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            const insertQuery = this.insertTypeormMetadataSql({
+                table: table.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            upQueries.push(deleteQuery);
+            downQueries.push(insertQuery);
+        }
+        await this.executeQueries(upQueries, downQueries);
+    }
     /**
      * Creates a new view.
      */
-    AbstractSqliteQueryRunner.prototype.createView = function (view_1) {
-        return tslib_1.__awaiter(this, arguments, void 0, function (view, syncWithMetadata) {
-            var upQueries, downQueries;
-            if (syncWithMetadata === void 0) { syncWithMetadata = false; }
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        upQueries = [];
-                        downQueries = [];
-                        upQueries.push(this.createViewSql(view));
-                        if (syncWithMetadata)
-                            upQueries.push(this.insertViewDefinitionSql(view));
-                        downQueries.push(this.dropViewSql(view));
-                        if (syncWithMetadata)
-                            downQueries.push(this.deleteViewDefinitionSql(view));
-                        return [4 /*yield*/, this.executeQueries(upQueries, downQueries)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async createView(view, syncWithMetadata = false) {
+        const upQueries = [];
+        const downQueries = [];
+        upQueries.push(this.createViewSql(view));
+        if (syncWithMetadata)
+            upQueries.push(this.insertViewDefinitionSql(view));
+        downQueries.push(this.dropViewSql(view));
+        if (syncWithMetadata)
+            downQueries.push(this.deleteViewDefinitionSql(view));
+        await this.executeQueries(upQueries, downQueries);
+    }
     /**
      * Drops the view.
      */
-    AbstractSqliteQueryRunner.prototype.dropView = function (target) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var viewName, view, upQueries, downQueries;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        viewName = InstanceChecker_1.InstanceChecker.isView(target) ? target.name : target;
-                        return [4 /*yield*/, this.getCachedView(viewName)];
-                    case 1:
-                        view = _a.sent();
-                        upQueries = [];
-                        downQueries = [];
-                        upQueries.push(this.deleteViewDefinitionSql(view));
-                        upQueries.push(this.dropViewSql(view));
-                        downQueries.push(this.insertViewDefinitionSql(view));
-                        downQueries.push(this.createViewSql(view));
-                        return [4 /*yield*/, this.executeQueries(upQueries, downQueries)];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async dropView(target) {
+        const viewName = InstanceChecker_1.InstanceChecker.isView(target) ? target.name : target;
+        const view = await this.getCachedView(viewName);
+        const upQueries = [];
+        const downQueries = [];
+        upQueries.push(this.deleteViewDefinitionSql(view));
+        upQueries.push(this.dropViewSql(view));
+        downQueries.push(this.insertViewDefinitionSql(view));
+        downQueries.push(this.createViewSql(view));
+        await this.executeQueries(upQueries, downQueries);
+    }
     /**
      * Renames the given table.
      */
-    AbstractSqliteQueryRunner.prototype.renameTable = function (oldTableOrName, newTableName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var oldTable, _a, newTable, up, down;
-            var _this = this;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(oldTableOrName)) return [3 /*break*/, 1];
-                        _a = oldTableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(oldTableOrName)];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        oldTable = _a;
-                        newTable = oldTable.clone();
-                        newTable.name = newTableName;
-                        up = new Query_1.Query("ALTER TABLE ".concat(this.escapePath(oldTable.name), " RENAME TO ").concat(this.escapePath(newTableName)));
-                        down = new Query_1.Query("ALTER TABLE ".concat(this.escapePath(newTableName), " RENAME TO ").concat(this.escapePath(oldTable.name)));
-                        return [4 /*yield*/, this.executeQueries(up, down)
-                            // rename unique constraints
-                        ];
-                    case 4:
-                        _b.sent();
-                        // rename unique constraints
-                        newTable.uniques.forEach(function (unique) {
-                            var oldUniqueName = _this.connection.namingStrategy.uniqueConstraintName(oldTable, unique.columnNames);
-                            // Skip renaming if Unique has user defined constraint name
-                            if (unique.name !== oldUniqueName)
-                                return;
-                            unique.name = _this.connection.namingStrategy.uniqueConstraintName(newTable, unique.columnNames);
-                        });
-                        // rename foreign key constraints
-                        newTable.foreignKeys.forEach(function (foreignKey) {
-                            var oldForeignKeyName = _this.connection.namingStrategy.foreignKeyName(oldTable, foreignKey.columnNames, _this.getTablePath(foreignKey), foreignKey.referencedColumnNames);
-                            // Skip renaming if foreign key has user defined constraint name
-                            if (foreignKey.name !== oldForeignKeyName)
-                                return;
-                            foreignKey.name = _this.connection.namingStrategy.foreignKeyName(newTable, foreignKey.columnNames, _this.getTablePath(foreignKey), foreignKey.referencedColumnNames);
-                        });
-                        // rename indices
-                        newTable.indices.forEach(function (index) {
-                            var oldIndexName = _this.connection.namingStrategy.indexName(oldTable, index.columnNames, index.where);
-                            // Skip renaming if Index has user defined constraint name
-                            if (index.name !== oldIndexName)
-                                return;
-                            index.name = _this.connection.namingStrategy.indexName(newTable, index.columnNames, index.where);
-                        });
-                        // rename old table;
-                        oldTable.name = newTable.name;
-                        // recreate table with new constraint names
-                        return [4 /*yield*/, this.recreateTable(newTable, oldTable)];
-                    case 5:
-                        // recreate table with new constraint names
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
+    async renameTable(oldTableOrName, newTableName) {
+        const oldTable = InstanceChecker_1.InstanceChecker.isTable(oldTableOrName)
+            ? oldTableOrName
+            : await this.getCachedTable(oldTableOrName);
+        const newTable = oldTable.clone();
+        newTable.name = newTableName;
+        // rename table
+        const up = new Query_1.Query(`ALTER TABLE ${this.escapePath(oldTable.name)} RENAME TO ${this.escapePath(newTableName)}`);
+        const down = new Query_1.Query(`ALTER TABLE ${this.escapePath(newTableName)} RENAME TO ${this.escapePath(oldTable.name)}`);
+        await this.executeQueries(up, down);
+        // rename unique constraints
+        newTable.uniques.forEach((unique) => {
+            const oldUniqueName = this.connection.namingStrategy.uniqueConstraintName(oldTable, unique.columnNames);
+            // Skip renaming if Unique has user defined constraint name
+            if (unique.name !== oldUniqueName)
+                return;
+            unique.name = this.connection.namingStrategy.uniqueConstraintName(newTable, unique.columnNames);
+        });
+        // rename foreign key constraints
+        newTable.foreignKeys.forEach((foreignKey) => {
+            const oldForeignKeyName = this.connection.namingStrategy.foreignKeyName(oldTable, foreignKey.columnNames, this.getTablePath(foreignKey), foreignKey.referencedColumnNames);
+            // Skip renaming if foreign key has user defined constraint name
+            if (foreignKey.name !== oldForeignKeyName)
+                return;
+            foreignKey.name = this.connection.namingStrategy.foreignKeyName(newTable, foreignKey.columnNames, this.getTablePath(foreignKey), foreignKey.referencedColumnNames);
+        });
+        // rename indices
+        newTable.indices.forEach((index) => {
+            const oldIndexName = this.connection.namingStrategy.indexName(oldTable, index.columnNames, index.where);
+            // Skip renaming if Index has user defined constraint name
+            if (index.name !== oldIndexName)
+                return;
+            index.name = this.connection.namingStrategy.indexName(newTable, index.columnNames, index.where);
         });
-    };
+        // rename old table;
+        oldTable.name = newTable.name;
+        // recreate table with new constraint names
+        await this.recreateTable(newTable, oldTable);
+    }
     /**
      * Creates a new column from the column in the table.
      */
-    AbstractSqliteQueryRunner.prototype.addColumn = function (tableOrName, column) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        return [2 /*return*/, this.addColumns(table, [column])];
-                }
-            });
-        });
-    };
+    async addColumn(tableOrName, column) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        return this.addColumns(table, [column]);
+    }
     /**
      * Creates a new columns from the column in the table.
      */
-    AbstractSqliteQueryRunner.prototype.addColumns = function (tableOrName, columns) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, changedTable;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        changedTable = table.clone();
-                        columns.forEach(function (column) { return changedTable.addColumn(column); });
-                        return [4 /*yield*/, this.recreateTable(changedTable, table)];
-                    case 4:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async addColumns(tableOrName, columns) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        const changedTable = table.clone();
+        columns.forEach((column) => changedTable.addColumn(column));
+        await this.recreateTable(changedTable, table);
+    }
     /**
      * Renames column in the given table.
      */
-    AbstractSqliteQueryRunner.prototype.renameColumn = function (tableOrName, oldTableColumnOrName, newTableColumnOrName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, oldColumn, newColumn;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        oldColumn = InstanceChecker_1.InstanceChecker.isTableColumn(oldTableColumnOrName)
-                            ? oldTableColumnOrName
-                            : table.columns.find(function (c) { return c.name === oldTableColumnOrName; });
-                        if (!oldColumn)
-                            throw new error_1.TypeORMError("Column \"".concat(oldTableColumnOrName, "\" was not found in the \"").concat(table.name, "\" table."));
-                        newColumn = undefined;
-                        if (InstanceChecker_1.InstanceChecker.isTableColumn(newTableColumnOrName)) {
-                            newColumn = newTableColumnOrName;
-                        }
-                        else {
-                            newColumn = oldColumn.clone();
-                            newColumn.name = newTableColumnOrName;
-                        }
-                        return [2 /*return*/, this.changeColumn(table, oldColumn, newColumn)];
-                }
-            });
-        });
-    };
+    async renameColumn(tableOrName, oldTableColumnOrName, newTableColumnOrName) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        const oldColumn = InstanceChecker_1.InstanceChecker.isTableColumn(oldTableColumnOrName)
+            ? oldTableColumnOrName
+            : table.columns.find((c) => c.name === oldTableColumnOrName);
+        if (!oldColumn)
+            throw new error_1.TypeORMError(`Column "${oldTableColumnOrName}" was not found in the "${table.name}" table.`);
+        let newColumn = undefined;
+        if (InstanceChecker_1.InstanceChecker.isTableColumn(newTableColumnOrName)) {
+            newColumn = newTableColumnOrName;
+        }
+        else {
+            newColumn = oldColumn.clone();
+            newColumn.name = newTableColumnOrName;
+        }
+        return this.changeColumn(table, oldColumn, newColumn);
+    }
     /**
      * Changes a column in the table.
      */
-    AbstractSqliteQueryRunner.prototype.changeColumn = function (tableOrName, oldTableColumnOrName, newColumn) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, oldColumn;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        oldColumn = InstanceChecker_1.InstanceChecker.isTableColumn(oldTableColumnOrName)
-                            ? oldTableColumnOrName
-                            : table.columns.find(function (c) { return c.name === oldTableColumnOrName; });
-                        if (!oldColumn)
-                            throw new error_1.TypeORMError("Column \"".concat(oldTableColumnOrName, "\" was not found in the \"").concat(table.name, "\" table."));
-                        return [4 /*yield*/, this.changeColumns(table, [{ oldColumn: oldColumn, newColumn: newColumn }])];
-                    case 4:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async changeColumn(tableOrName, oldTableColumnOrName, newColumn) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        const oldColumn = InstanceChecker_1.InstanceChecker.isTableColumn(oldTableColumnOrName)
+            ? oldTableColumnOrName
+            : table.columns.find((c) => c.name === oldTableColumnOrName);
+        if (!oldColumn)
+            throw new error_1.TypeORMError(`Column "${oldTableColumnOrName}" was not found in the "${table.name}" table.`);
+        await this.changeColumns(table, [{ oldColumn, newColumn }]);
+    }
     /**
      * Changes a column in the table.
      * Changed column looses all its keys in the db.
      */
-    AbstractSqliteQueryRunner.prototype.changeColumns = function (tableOrName, changedColumns) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, changedTable;
-            var _this = this;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        changedTable = table.clone();
-                        changedColumns.forEach(function (changedColumnSet) {
-                            if (changedColumnSet.newColumn.name !==
-                                changedColumnSet.oldColumn.name) {
-                                changedTable
-                                    .findColumnUniques(changedColumnSet.oldColumn)
-                                    .forEach(function (unique) {
-                                    var uniqueName = _this.connection.namingStrategy.uniqueConstraintName(table, unique.columnNames);
-                                    unique.columnNames.splice(unique.columnNames.indexOf(changedColumnSet.oldColumn.name), 1);
-                                    unique.columnNames.push(changedColumnSet.newColumn.name);
-                                    // rename Unique only if it has default constraint name
-                                    if (unique.name === uniqueName) {
-                                        unique.name =
-                                            _this.connection.namingStrategy.uniqueConstraintName(changedTable, unique.columnNames);
-                                    }
-                                });
-                                changedTable
-                                    .findColumnForeignKeys(changedColumnSet.oldColumn)
-                                    .forEach(function (foreignKey) {
-                                    var foreignKeyName = _this.connection.namingStrategy.foreignKeyName(table, foreignKey.columnNames, _this.getTablePath(foreignKey), foreignKey.referencedColumnNames);
-                                    foreignKey.columnNames.splice(foreignKey.columnNames.indexOf(changedColumnSet.oldColumn.name), 1);
-                                    foreignKey.columnNames.push(changedColumnSet.newColumn.name);
-                                    // rename FK only if it has default constraint name
-                                    if (foreignKey.name === foreignKeyName) {
-                                        foreignKey.name =
-                                            _this.connection.namingStrategy.foreignKeyName(changedTable, foreignKey.columnNames, _this.getTablePath(foreignKey), foreignKey.referencedColumnNames);
-                                    }
-                                });
-                                changedTable
-                                    .findColumnIndices(changedColumnSet.oldColumn)
-                                    .forEach(function (index) {
-                                    var indexName = _this.connection.namingStrategy.indexName(table, index.columnNames, index.where);
-                                    index.columnNames.splice(index.columnNames.indexOf(changedColumnSet.oldColumn.name), 1);
-                                    index.columnNames.push(changedColumnSet.newColumn.name);
-                                    // rename Index only if it has default constraint name
-                                    if (index.name === indexName) {
-                                        index.name =
-                                            _this.connection.namingStrategy.indexName(changedTable, index.columnNames, index.where);
-                                    }
-                                });
-                            }
-                            var originalColumn = changedTable.columns.find(function (column) { return column.name === changedColumnSet.oldColumn.name; });
-                            if (originalColumn)
-                                changedTable.columns[changedTable.columns.indexOf(originalColumn)] = changedColumnSet.newColumn;
-                        });
-                        return [4 /*yield*/, this.recreateTable(changedTable, table)];
-                    case 4:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
+    async changeColumns(tableOrName, changedColumns) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        const changedTable = table.clone();
+        changedColumns.forEach((changedColumnSet) => {
+            if (changedColumnSet.newColumn.name !==
+                changedColumnSet.oldColumn.name) {
+                changedTable
+                    .findColumnUniques(changedColumnSet.oldColumn)
+                    .forEach((unique) => {
+                    const uniqueName = this.connection.namingStrategy.uniqueConstraintName(table, unique.columnNames);
+                    unique.columnNames.splice(unique.columnNames.indexOf(changedColumnSet.oldColumn.name), 1);
+                    unique.columnNames.push(changedColumnSet.newColumn.name);
+                    // rename Unique only if it has default constraint name
+                    if (unique.name === uniqueName) {
+                        unique.name =
+                            this.connection.namingStrategy.uniqueConstraintName(changedTable, unique.columnNames);
+                    }
+                });
+                changedTable
+                    .findColumnForeignKeys(changedColumnSet.oldColumn)
+                    .forEach((foreignKey) => {
+                    const foreignKeyName = this.connection.namingStrategy.foreignKeyName(table, foreignKey.columnNames, this.getTablePath(foreignKey), foreignKey.referencedColumnNames);
+                    foreignKey.columnNames.splice(foreignKey.columnNames.indexOf(changedColumnSet.oldColumn.name), 1);
+                    foreignKey.columnNames.push(changedColumnSet.newColumn.name);
+                    // rename FK only if it has default constraint name
+                    if (foreignKey.name === foreignKeyName) {
+                        foreignKey.name =
+                            this.connection.namingStrategy.foreignKeyName(changedTable, foreignKey.columnNames, this.getTablePath(foreignKey), foreignKey.referencedColumnNames);
+                    }
+                });
+                changedTable
+                    .findColumnIndices(changedColumnSet.oldColumn)
+                    .forEach((index) => {
+                    const indexName = this.connection.namingStrategy.indexName(table, index.columnNames, index.where);
+                    index.columnNames.splice(index.columnNames.indexOf(changedColumnSet.oldColumn.name), 1);
+                    index.columnNames.push(changedColumnSet.newColumn.name);
+                    // rename Index only if it has default constraint name
+                    if (index.name === indexName) {
+                        index.name =
+                            this.connection.namingStrategy.indexName(changedTable, index.columnNames, index.where);
+                    }
+                });
+            }
+            const originalColumn = changedTable.columns.find((column) => column.name === changedColumnSet.oldColumn.name);
+            if (originalColumn)
+                changedTable.columns[changedTable.columns.indexOf(originalColumn)] = changedColumnSet.newColumn;
         });
-    };
+        await this.recreateTable(changedTable, table);
+    }
     /**
      * Drops column in the table.
      */
-    AbstractSqliteQueryRunner.prototype.dropColumn = function (tableOrName, columnOrName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, column;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        column = InstanceChecker_1.InstanceChecker.isTableColumn(columnOrName)
-                            ? columnOrName
-                            : table.findColumnByName(columnOrName);
-                        if (!column)
-                            throw new error_1.TypeORMError("Column \"".concat(columnOrName, "\" was not found in table \"").concat(table.name, "\""));
-                        return [4 /*yield*/, this.dropColumns(table, [column])];
-                    case 4:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async dropColumn(tableOrName, columnOrName) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        const column = InstanceChecker_1.InstanceChecker.isTableColumn(columnOrName)
+            ? columnOrName
+            : table.findColumnByName(columnOrName);
+        if (!column)
+            throw new error_1.TypeORMError(`Column "${columnOrName}" was not found in table "${table.name}"`);
+        await this.dropColumns(table, [column]);
+    }
     /**
      * Drops the columns in the table.
      */
-    AbstractSqliteQueryRunner.prototype.dropColumns = function (tableOrName, columns) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, changedTable;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)
-                        // clone original table and remove column and its constraints from cloned table
-                    ];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        changedTable = table.clone();
-                        columns.forEach(function (column) {
-                            var columnInstance = InstanceChecker_1.InstanceChecker.isTableColumn(column)
-                                ? column
-                                : table.findColumnByName(column);
-                            if (!columnInstance)
-                                throw new Error("Column \"".concat(column, "\" was not found in table \"").concat(table.name, "\""));
-                            changedTable.removeColumn(columnInstance);
-                            changedTable
-                                .findColumnUniques(columnInstance)
-                                .forEach(function (unique) {
-                                return changedTable.removeUniqueConstraint(unique);
-                            });
-                            changedTable
-                                .findColumnIndices(columnInstance)
-                                .forEach(function (index) { return changedTable.removeIndex(index); });
-                            changedTable
-                                .findColumnForeignKeys(columnInstance)
-                                .forEach(function (fk) { return changedTable.removeForeignKey(fk); });
-                        });
-                        return [4 /*yield*/, this.recreateTable(changedTable, table)];
-                    case 4:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
+    async dropColumns(tableOrName, columns) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        // clone original table and remove column and its constraints from cloned table
+        const changedTable = table.clone();
+        columns.forEach((column) => {
+            const columnInstance = InstanceChecker_1.InstanceChecker.isTableColumn(column)
+                ? column
+                : table.findColumnByName(column);
+            if (!columnInstance)
+                throw new Error(`Column "${column}" was not found in table "${table.name}"`);
+            changedTable.removeColumn(columnInstance);
+            changedTable
+                .findColumnUniques(columnInstance)
+                .forEach((unique) => changedTable.removeUniqueConstraint(unique));
+            changedTable
+                .findColumnIndices(columnInstance)
+                .forEach((index) => changedTable.removeIndex(index));
+            changedTable
+                .findColumnForeignKeys(columnInstance)
+                .forEach((fk) => changedTable.removeForeignKey(fk));
         });
-    };
+        await this.recreateTable(changedTable, table);
+    }
     /**
      * Creates a new primary key.
      */
-    AbstractSqliteQueryRunner.prototype.createPrimaryKey = function (tableOrName, columnNames) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, changedTable;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)
-                        // clone original table and mark columns as primary
-                    ];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        changedTable = table.clone();
-                        changedTable.columns.forEach(function (column) {
-                            if (columnNames.find(function (columnName) { return columnName === column.name; }))
-                                column.isPrimary = true;
-                        });
-                        return [4 /*yield*/, this.recreateTable(changedTable, table)
-                            // mark columns as primary in original table
-                        ];
-                    case 4:
-                        _b.sent();
-                        // mark columns as primary in original table
-                        table.columns.forEach(function (column) {
-                            if (columnNames.find(function (columnName) { return columnName === column.name; }))
-                                column.isPrimary = true;
-                        });
-                        return [2 /*return*/];
-                }
-            });
+    async createPrimaryKey(tableOrName, columnNames) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        // clone original table and mark columns as primary
+        const changedTable = table.clone();
+        changedTable.columns.forEach((column) => {
+            if (columnNames.find((columnName) => columnName === column.name))
+                column.isPrimary = true;
         });
-    };
+        await this.recreateTable(changedTable, table);
+        // mark columns as primary in original table
+        table.columns.forEach((column) => {
+            if (columnNames.find((columnName) => columnName === column.name))
+                column.isPrimary = true;
+        });
+    }
     /**
      * Updates composite primary keys.
      */
-    AbstractSqliteQueryRunner.prototype.updatePrimaryKeys = function (tableOrName, columns) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Promise.resolve()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async updatePrimaryKeys(tableOrName, columns) {
+        await Promise.resolve();
+    }
     /**
      * Drops a primary key.
      */
-    AbstractSqliteQueryRunner.prototype.dropPrimaryKey = function (tableOrName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, changedTable;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)
-                        // clone original table and mark primary columns as non-primary
-                    ];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        changedTable = table.clone();
-                        changedTable.primaryColumns.forEach(function (column) {
-                            column.isPrimary = false;
-                        });
-                        return [4 /*yield*/, this.recreateTable(changedTable, table)
-                            // mark primary columns as non-primary in original table
-                        ];
-                    case 4:
-                        _b.sent();
-                        // mark primary columns as non-primary in original table
-                        table.primaryColumns.forEach(function (column) {
-                            column.isPrimary = false;
-                        });
-                        return [2 /*return*/];
-                }
-            });
+    async dropPrimaryKey(tableOrName) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        // clone original table and mark primary columns as non-primary
+        const changedTable = table.clone();
+        changedTable.primaryColumns.forEach((column) => {
+            column.isPrimary = false;
+        });
+        await this.recreateTable(changedTable, table);
+        // mark primary columns as non-primary in original table
+        table.primaryColumns.forEach((column) => {
+            column.isPrimary = false;
         });
-    };
+    }
     /**
      * Creates a new unique constraint.
      */
-    AbstractSqliteQueryRunner.prototype.createUniqueConstraint = function (tableOrName, uniqueConstraint) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.createUniqueConstraints(tableOrName, [uniqueConstraint])];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async createUniqueConstraint(tableOrName, uniqueConstraint) {
+        await this.createUniqueConstraints(tableOrName, [uniqueConstraint]);
+    }
     /**
      * Creates a new unique constraints.
      */
-    AbstractSqliteQueryRunner.prototype.createUniqueConstraints = function (tableOrName, uniqueConstraints) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, changedTable;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)
-                        // clone original table and add unique constraints in to cloned table
-                    ];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        changedTable = table.clone();
-                        uniqueConstraints.forEach(function (uniqueConstraint) {
-                            return changedTable.addUniqueConstraint(uniqueConstraint);
-                        });
-                        return [4 /*yield*/, this.recreateTable(changedTable, table)];
-                    case 4:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async createUniqueConstraints(tableOrName, uniqueConstraints) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        // clone original table and add unique constraints in to cloned table
+        const changedTable = table.clone();
+        uniqueConstraints.forEach((uniqueConstraint) => changedTable.addUniqueConstraint(uniqueConstraint));
+        await this.recreateTable(changedTable, table);
+    }
     /**
      * Drops an unique constraint.
      */
-    AbstractSqliteQueryRunner.prototype.dropUniqueConstraint = function (tableOrName, uniqueOrName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, uniqueConstraint;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        uniqueConstraint = InstanceChecker_1.InstanceChecker.isTableUnique(uniqueOrName)
-                            ? uniqueOrName
-                            : table.uniques.find(function (u) { return u.name === uniqueOrName; });
-                        if (!uniqueConstraint)
-                            throw new error_1.TypeORMError("Supplied unique constraint was not found in table ".concat(table.name));
-                        return [4 /*yield*/, this.dropUniqueConstraints(table, [uniqueConstraint])];
-                    case 4:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async dropUniqueConstraint(tableOrName, uniqueOrName) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        const uniqueConstraint = InstanceChecker_1.InstanceChecker.isTableUnique(uniqueOrName)
+            ? uniqueOrName
+            : table.uniques.find((u) => u.name === uniqueOrName);
+        if (!uniqueConstraint)
+            throw new error_1.TypeORMError(`Supplied unique constraint was not found in table ${table.name}`);
+        await this.dropUniqueConstraints(table, [uniqueConstraint]);
+    }
     /**
      * Creates an unique constraints.
      */
-    AbstractSqliteQueryRunner.prototype.dropUniqueConstraints = function (tableOrName, uniqueConstraints) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, changedTable;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)
-                        // clone original table and remove unique constraints from cloned table
-                    ];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        changedTable = table.clone();
-                        uniqueConstraints.forEach(function (uniqueConstraint) {
-                            return changedTable.removeUniqueConstraint(uniqueConstraint);
-                        });
-                        return [4 /*yield*/, this.recreateTable(changedTable, table)];
-                    case 4:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async dropUniqueConstraints(tableOrName, uniqueConstraints) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        // clone original table and remove unique constraints from cloned table
+        const changedTable = table.clone();
+        uniqueConstraints.forEach((uniqueConstraint) => changedTable.removeUniqueConstraint(uniqueConstraint));
+        await this.recreateTable(changedTable, table);
+    }
     /**
      * Creates new check constraint.
      */
-    AbstractSqliteQueryRunner.prototype.createCheckConstraint = function (tableOrName, checkConstraint) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.createCheckConstraints(tableOrName, [checkConstraint])];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async createCheckConstraint(tableOrName, checkConstraint) {
+        await this.createCheckConstraints(tableOrName, [checkConstraint]);
+    }
     /**
      * Creates new check constraints.
      */
-    AbstractSqliteQueryRunner.prototype.createCheckConstraints = function (tableOrName, checkConstraints) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, changedTable;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)
-                        // clone original table and add check constraints in to cloned table
-                    ];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        changedTable = table.clone();
-                        checkConstraints.forEach(function (checkConstraint) {
-                            return changedTable.addCheckConstraint(checkConstraint);
-                        });
-                        return [4 /*yield*/, this.recreateTable(changedTable, table)];
-                    case 4:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async createCheckConstraints(tableOrName, checkConstraints) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        // clone original table and add check constraints in to cloned table
+        const changedTable = table.clone();
+        checkConstraints.forEach((checkConstraint) => changedTable.addCheckConstraint(checkConstraint));
+        await this.recreateTable(changedTable, table);
+    }
     /**
      * Drops check constraint.
      */
-    AbstractSqliteQueryRunner.prototype.dropCheckConstraint = function (tableOrName, checkOrName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, checkConstraint;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        checkConstraint = InstanceChecker_1.InstanceChecker.isTableCheck(checkOrName)
-                            ? checkOrName
-                            : table.checks.find(function (c) { return c.name === checkOrName; });
-                        if (!checkConstraint)
-                            throw new error_1.TypeORMError("Supplied check constraint was not found in table ".concat(table.name));
-                        return [4 /*yield*/, this.dropCheckConstraints(table, [checkConstraint])];
-                    case 4:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async dropCheckConstraint(tableOrName, checkOrName) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        const checkConstraint = InstanceChecker_1.InstanceChecker.isTableCheck(checkOrName)
+            ? checkOrName
+            : table.checks.find((c) => c.name === checkOrName);
+        if (!checkConstraint)
+            throw new error_1.TypeORMError(`Supplied check constraint was not found in table ${table.name}`);
+        await this.dropCheckConstraints(table, [checkConstraint]);
+    }
     /**
      * Drops check constraints.
      */
-    AbstractSqliteQueryRunner.prototype.dropCheckConstraints = function (tableOrName, checkConstraints) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, changedTable;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)
-                        // clone original table and remove check constraints from cloned table
-                    ];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        changedTable = table.clone();
-                        checkConstraints.forEach(function (checkConstraint) {
-                            return changedTable.removeCheckConstraint(checkConstraint);
-                        });
-                        return [4 /*yield*/, this.recreateTable(changedTable, table)];
-                    case 4:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async dropCheckConstraints(tableOrName, checkConstraints) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        // clone original table and remove check constraints from cloned table
+        const changedTable = table.clone();
+        checkConstraints.forEach((checkConstraint) => changedTable.removeCheckConstraint(checkConstraint));
+        await this.recreateTable(changedTable, table);
+    }
     /**
      * Creates a new exclusion constraint.
      */
-    AbstractSqliteQueryRunner.prototype.createExclusionConstraint = function (tableOrName, exclusionConstraint) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                throw new error_1.TypeORMError("Sqlite does not support exclusion constraints.");
-            });
-        });
-    };
+    async createExclusionConstraint(tableOrName, exclusionConstraint) {
+        throw new error_1.TypeORMError(`Sqlite does not support exclusion constraints.`);
+    }
     /**
      * Creates a new exclusion constraints.
      */
-    AbstractSqliteQueryRunner.prototype.createExclusionConstraints = function (tableOrName, exclusionConstraints) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                throw new error_1.TypeORMError("Sqlite does not support exclusion constraints.");
-            });
-        });
-    };
+    async createExclusionConstraints(tableOrName, exclusionConstraints) {
+        throw new error_1.TypeORMError(`Sqlite does not support exclusion constraints.`);
+    }
     /**
      * Drops exclusion constraint.
      */
-    AbstractSqliteQueryRunner.prototype.dropExclusionConstraint = function (tableOrName, exclusionOrName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                throw new error_1.TypeORMError("Sqlite does not support exclusion constraints.");
-            });
-        });
-    };
+    async dropExclusionConstraint(tableOrName, exclusionOrName) {
+        throw new error_1.TypeORMError(`Sqlite does not support exclusion constraints.`);
+    }
     /**
      * Drops exclusion constraints.
      */
-    AbstractSqliteQueryRunner.prototype.dropExclusionConstraints = function (tableOrName, exclusionConstraints) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                throw new error_1.TypeORMError("Sqlite does not support exclusion constraints.");
-            });
-        });
-    };
+    async dropExclusionConstraints(tableOrName, exclusionConstraints) {
+        throw new error_1.TypeORMError(`Sqlite does not support exclusion constraints.`);
+    }
     /**
      * Creates a new foreign key.
      */
-    AbstractSqliteQueryRunner.prototype.createForeignKey = function (tableOrName, foreignKey) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.createForeignKeys(tableOrName, [foreignKey])];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async createForeignKey(tableOrName, foreignKey) {
+        await this.createForeignKeys(tableOrName, [foreignKey]);
+    }
     /**
      * Creates a new foreign keys.
      */
-    AbstractSqliteQueryRunner.prototype.createForeignKeys = function (tableOrName, foreignKeys) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, changedTable;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)
-                        // clone original table and add foreign keys in to cloned table
-                    ];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        changedTable = table.clone();
-                        foreignKeys.forEach(function (foreignKey) {
-                            return changedTable.addForeignKey(foreignKey);
-                        });
-                        return [4 /*yield*/, this.recreateTable(changedTable, table)];
-                    case 4:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async createForeignKeys(tableOrName, foreignKeys) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        // clone original table and add foreign keys in to cloned table
+        const changedTable = table.clone();
+        foreignKeys.forEach((foreignKey) => changedTable.addForeignKey(foreignKey));
+        await this.recreateTable(changedTable, table);
+    }
     /**
      * Drops a foreign key from the table.
      */
-    AbstractSqliteQueryRunner.prototype.dropForeignKey = function (tableOrName, foreignKeyOrName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, foreignKey;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        foreignKey = InstanceChecker_1.InstanceChecker.isTableForeignKey(foreignKeyOrName)
-                            ? foreignKeyOrName
-                            : table.foreignKeys.find(function (fk) { return fk.name === foreignKeyOrName; });
-                        if (!foreignKey)
-                            throw new error_1.TypeORMError("Supplied foreign key was not found in table ".concat(table.name));
-                        return [4 /*yield*/, this.dropForeignKeys(tableOrName, [foreignKey])];
-                    case 4:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async dropForeignKey(tableOrName, foreignKeyOrName) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        const foreignKey = InstanceChecker_1.InstanceChecker.isTableForeignKey(foreignKeyOrName)
+            ? foreignKeyOrName
+            : table.foreignKeys.find((fk) => fk.name === foreignKeyOrName);
+        if (!foreignKey)
+            throw new error_1.TypeORMError(`Supplied foreign key was not found in table ${table.name}`);
+        await this.dropForeignKeys(tableOrName, [foreignKey]);
+    }
     /**
      * Drops a foreign keys from the table.
      */
-    AbstractSqliteQueryRunner.prototype.dropForeignKeys = function (tableOrName, foreignKeys) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, changedTable;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)
-                        // clone original table and remove foreign keys from cloned table
-                    ];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        changedTable = table.clone();
-                        foreignKeys.forEach(function (foreignKey) {
-                            return changedTable.removeForeignKey(foreignKey);
-                        });
-                        return [4 /*yield*/, this.recreateTable(changedTable, table)];
-                    case 4:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async dropForeignKeys(tableOrName, foreignKeys) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        // clone original table and remove foreign keys from cloned table
+        const changedTable = table.clone();
+        foreignKeys.forEach((foreignKey) => changedTable.removeForeignKey(foreignKey));
+        await this.recreateTable(changedTable, table);
+    }
     /**
      * Creates a new index.
      */
-    AbstractSqliteQueryRunner.prototype.createIndex = function (tableOrName, index) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, up, down;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)
-                        // new index may be passed without name. In this case we generate index name manually.
-                    ];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        // new index may be passed without name. In this case we generate index name manually.
-                        if (!index.name)
-                            index.name = this.generateIndexName(table, index);
-                        up = this.createIndexSql(table, index);
-                        down = this.dropIndexSql(index);
-                        return [4 /*yield*/, this.executeQueries(up, down)];
-                    case 4:
-                        _b.sent();
-                        table.addIndex(index);
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async createIndex(tableOrName, index) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        // new index may be passed without name. In this case we generate index name manually.
+        if (!index.name)
+            index.name = this.generateIndexName(table, index);
+        const up = this.createIndexSql(table, index);
+        const down = this.dropIndexSql(index);
+        await this.executeQueries(up, down);
+        table.addIndex(index);
+    }
     /**
      * Creates a new indices
      */
-    AbstractSqliteQueryRunner.prototype.createIndices = function (tableOrName, indices) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var promises;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        promises = indices.map(function (index) {
-                            return _this.createIndex(tableOrName, index);
-                        });
-                        return [4 /*yield*/, Promise.all(promises)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async createIndices(tableOrName, indices) {
+        const promises = indices.map((index) => this.createIndex(tableOrName, index));
+        await Promise.all(promises);
+    }
     /**
      * Drops an index from the table.
      */
-    AbstractSqliteQueryRunner.prototype.dropIndex = function (tableOrName, indexOrName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var table, _a, index, up, down;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!InstanceChecker_1.InstanceChecker.isTable(tableOrName)) return [3 /*break*/, 1];
-                        _a = tableOrName;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getCachedTable(tableOrName)];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        table = _a;
-                        index = InstanceChecker_1.InstanceChecker.isTableIndex(indexOrName)
-                            ? indexOrName
-                            : table.indices.find(function (i) { return i.name === indexOrName; });
-                        if (!index)
-                            throw new error_1.TypeORMError("Supplied index ".concat(indexOrName, " was not found in table ").concat(table.name));
-                        // old index may be passed without name. In this case we generate index name manually.
-                        if (!index.name)
-                            index.name = this.generateIndexName(table, index);
-                        up = this.dropIndexSql(index);
-                        down = this.createIndexSql(table, index);
-                        return [4 /*yield*/, this.executeQueries(up, down)];
-                    case 4:
-                        _b.sent();
-                        table.removeIndex(index);
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async dropIndex(tableOrName, indexOrName) {
+        const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+            ? tableOrName
+            : await this.getCachedTable(tableOrName);
+        const index = InstanceChecker_1.InstanceChecker.isTableIndex(indexOrName)
+            ? indexOrName
+            : table.indices.find((i) => i.name === indexOrName);
+        if (!index)
+            throw new error_1.TypeORMError(`Supplied index ${indexOrName} was not found in table ${table.name}`);
+        // old index may be passed without name. In this case we generate index name manually.
+        if (!index.name)
+            index.name = this.generateIndexName(table, index);
+        const up = this.dropIndexSql(index);
+        const down = this.createIndexSql(table, index);
+        await this.executeQueries(up, down);
+        table.removeIndex(index);
+    }
     /**
      * Drops an indices from the table.
      */
-    AbstractSqliteQueryRunner.prototype.dropIndices = function (tableOrName, indices) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var promises;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        promises = indices.map(function (index) {
-                            return _this.dropIndex(tableOrName, index);
-                        });
-                        return [4 /*yield*/, Promise.all(promises)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async dropIndices(tableOrName, indices) {
+        const promises = indices.map((index) => this.dropIndex(tableOrName, index));
+        await Promise.all(promises);
+    }
     /**
      * Clears all table contents.
      * Note: this operation uses SQL's TRUNCATE query which cannot be reverted in transactions.
      */
-    AbstractSqliteQueryRunner.prototype.clearTable = function (tableName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.query("DELETE FROM ".concat(this.escapePath(tableName)))];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async clearTable(tableName) {
+        await this.query(`DELETE FROM ${this.escapePath(tableName)}`);
+    }
     /**
      * Removes all tables from the currently connected database.
      */
-    AbstractSqliteQueryRunner.prototype.clearDatabase = function (database) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var dbPath, isAnotherTransactionActive, selectViewDropsQuery, dropViewQueries, selectTableDropsQuery, dropTableQueries, error_2, rollbackError_1;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        dbPath = undefined;
-                        if (database &&
-                            this.driver.getAttachedDatabaseHandleByRelativePath(database)) {
-                            dbPath =
-                                this.driver.getAttachedDatabaseHandleByRelativePath(database);
-                        }
-                        return [4 /*yield*/, this.query("PRAGMA foreign_keys = OFF")];
-                    case 1:
-                        _a.sent();
-                        isAnotherTransactionActive = this.isTransactionActive;
-                        if (!!isAnotherTransactionActive) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.startTransaction()];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        _a.trys.push([3, 10, 16, 18]);
-                        selectViewDropsQuery = dbPath
-                            ? "SELECT 'DROP VIEW \"".concat(dbPath, "\".\"' || name || '\";' as query FROM \"").concat(dbPath, "\".\"sqlite_master\" WHERE \"type\" = 'view'")
-                            : "SELECT 'DROP VIEW \"' || name || '\";' as query FROM \"sqlite_master\" WHERE \"type\" = 'view'";
-                        return [4 /*yield*/, this.query(selectViewDropsQuery)];
-                    case 4:
-                        dropViewQueries = _a.sent();
-                        return [4 /*yield*/, Promise.all(dropViewQueries.map(function (q) { return _this.query(q["query"]); }))];
-                    case 5:
-                        _a.sent();
-                        selectTableDropsQuery = dbPath
-                            ? "SELECT 'DROP TABLE \"".concat(dbPath, "\".\"' || name || '\";' as query FROM \"").concat(dbPath, "\".\"sqlite_master\" WHERE \"type\" = 'table' AND \"name\" != 'sqlite_sequence'")
-                            : "SELECT 'DROP TABLE \"' || name || '\";' as query FROM \"sqlite_master\" WHERE \"type\" = 'table' AND \"name\" != 'sqlite_sequence'";
-                        return [4 /*yield*/, this.query(selectTableDropsQuery)];
-                    case 6:
-                        dropTableQueries = _a.sent();
-                        return [4 /*yield*/, Promise.all(dropTableQueries.map(function (q) { return _this.query(q["query"]); }))];
-                    case 7:
-                        _a.sent();
-                        if (!!isAnotherTransactionActive) return [3 /*break*/, 9];
-                        return [4 /*yield*/, this.commitTransaction()];
-                    case 8:
-                        _a.sent();
-                        _a.label = 9;
-                    case 9: return [3 /*break*/, 18];
-                    case 10:
-                        error_2 = _a.sent();
-                        _a.label = 11;
-                    case 11:
-                        _a.trys.push([11, 14, , 15]);
-                        if (!!isAnotherTransactionActive) return [3 /*break*/, 13];
-                        return [4 /*yield*/, this.rollbackTransaction()];
-                    case 12:
-                        _a.sent();
-                        _a.label = 13;
-                    case 13: return [3 /*break*/, 15];
-                    case 14:
-                        rollbackError_1 = _a.sent();
-                        return [3 /*break*/, 15];
-                    case 15: throw error_2;
-                    case 16: return [4 /*yield*/, this.query("PRAGMA foreign_keys = ON")];
-                    case 17:
-                        _a.sent();
-                        return [7 /*endfinally*/];
-                    case 18: return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async clearDatabase(database) {
+        let dbPath = undefined;
+        if (database &&
+            this.driver.getAttachedDatabaseHandleByRelativePath(database)) {
+            dbPath =
+                this.driver.getAttachedDatabaseHandleByRelativePath(database);
+        }
+        await this.query(`PRAGMA foreign_keys = OFF`);
+        const isAnotherTransactionActive = this.isTransactionActive;
+        if (!isAnotherTransactionActive)
+            await this.startTransaction();
+        try {
+            const selectViewDropsQuery = dbPath
+                ? `SELECT 'DROP VIEW "${dbPath}"."' || name || '";' as query FROM "${dbPath}"."sqlite_master" WHERE "type" = 'view'`
+                : `SELECT 'DROP VIEW "' || name || '";' as query FROM "sqlite_master" WHERE "type" = 'view'`;
+            const dropViewQueries = await this.query(selectViewDropsQuery);
+            await Promise.all(dropViewQueries.map((q) => this.query(q["query"])));
+            const selectTableDropsQuery = dbPath
+                ? `SELECT 'DROP TABLE "${dbPath}"."' || name || '";' as query FROM "${dbPath}"."sqlite_master" WHERE "type" = 'table' AND "name" != 'sqlite_sequence'`
+                : `SELECT 'DROP TABLE "' || name || '";' as query FROM "sqlite_master" WHERE "type" = 'table' AND "name" != 'sqlite_sequence'`;
+            const dropTableQueries = await this.query(selectTableDropsQuery);
+            await Promise.all(dropTableQueries.map((q) => this.query(q["query"])));
+            if (!isAnotherTransactionActive)
+                await this.commitTransaction();
+        }
+        catch (error) {
+            try {
+                // we throw original error even if rollback thrown an error
+                if (!isAnotherTransactionActive)
+                    await this.rollbackTransaction();
+            }
+            catch (rollbackError) { }
+            throw error;
+        }
+        finally {
+            await this.query(`PRAGMA foreign_keys = ON`);
+        }
+    }
     // -------------------------------------------------------------------------
     // Protected Methods
     // -------------------------------------------------------------------------
-    AbstractSqliteQueryRunner.prototype.loadViews = function (viewNames) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var hasTable, viewNamesString, query, dbViews;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.hasTable(this.getTypeormMetadataTableName())];
-                    case 1:
-                        hasTable = _a.sent();
-                        if (!hasTable) {
-                            return [2 /*return*/, []];
-                        }
-                        if (!viewNames) {
-                            viewNames = [];
-                        }
-                        viewNamesString = viewNames
-                            .map(function (name) { return "'" + name + "'"; })
-                            .join(", ");
-                        query = "SELECT \"t\".* FROM \"".concat(this.getTypeormMetadataTableName(), "\" \"t\" INNER JOIN \"sqlite_master\" s ON \"s\".\"name\" = \"t\".\"name\" AND \"s\".\"type\" = 'view' WHERE \"t\".\"type\" = '").concat(MetadataTableType_1.MetadataTableType.VIEW, "'");
-                        if (viewNamesString.length > 0)
-                            query += " AND \"t\".\"name\" IN (".concat(viewNamesString, ")");
-                        return [4 /*yield*/, this.query(query)];
-                    case 2:
-                        dbViews = _a.sent();
-                        return [2 /*return*/, dbViews.map(function (dbView) {
-                                var view = new View_1.View();
-                                view.name = dbView["name"];
-                                view.expression = dbView["value"];
-                                return view;
-                            })];
-                }
-            });
-        });
-    };
-    AbstractSqliteQueryRunner.prototype.loadTableRecords = function (tablePath, tableOrIndex) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var database, _a, schema, tableName, res;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        database = undefined;
-                        _a = tslib_1.__read(this.splitTablePath(tablePath), 2), schema = _a[0], tableName = _a[1];
-                        if (schema &&
-                            this.driver.getAttachedDatabasePathRelativeByHandle(schema)) {
-                            database =
-                                this.driver.getAttachedDatabasePathRelativeByHandle(schema);
-                        }
-                        return [4 /*yield*/, this.query("SELECT ".concat(database ? "'".concat(database, "'") : null, " as database, ").concat(schema ? "'".concat(schema, "'") : null, " as schema, * FROM ").concat(schema ? "\"".concat(schema, "\".") : "").concat(this.escapePath("sqlite_master"), " WHERE \"type\" = '").concat(tableOrIndex, "' AND \"").concat(tableOrIndex === "table" ? "name" : "tbl_name", "\" IN ('").concat(tableName, "')"))];
-                    case 1:
-                        res = _b.sent();
-                        return [2 /*return*/, res];
-                }
-            });
-        });
-    };
-    AbstractSqliteQueryRunner.prototype.loadPragmaRecords = function (tablePath, pragma) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _a, tableName, res;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = tslib_1.__read(this.splitTablePath(tablePath), 2), tableName = _a[1];
-                        return [4 /*yield*/, this.query("PRAGMA ".concat(pragma, "(\"").concat(tableName, "\")"))];
-                    case 1:
-                        res = _b.sent();
-                        return [2 /*return*/, res];
-                }
-            });
+    async loadViews(viewNames) {
+        const hasTable = await this.hasTable(this.getTypeormMetadataTableName());
+        if (!hasTable) {
+            return [];
+        }
+        if (!viewNames) {
+            viewNames = [];
+        }
+        const viewNamesString = viewNames
+            .map((name) => "'" + name + "'")
+            .join(", ");
+        let query = `SELECT "t".* FROM "${this.getTypeormMetadataTableName()}" "t" INNER JOIN "sqlite_master" s ON "s"."name" = "t"."name" AND "s"."type" = 'view' WHERE "t"."type" = '${MetadataTableType_1.MetadataTableType.VIEW}'`;
+        if (viewNamesString.length > 0)
+            query += ` AND "t"."name" IN (${viewNamesString})`;
+        const dbViews = await this.query(query);
+        return dbViews.map((dbView) => {
+            const view = new View_1.View();
+            view.name = dbView["name"];
+            view.expression = dbView["value"];
+            return view;
         });
-    };
+    }
+    async loadTableRecords(tablePath, tableOrIndex) {
+        let database = undefined;
+        const [schema, tableName] = this.splitTablePath(tablePath);
+        if (schema &&
+            this.driver.getAttachedDatabasePathRelativeByHandle(schema)) {
+            database =
+                this.driver.getAttachedDatabasePathRelativeByHandle(schema);
+        }
+        const res = await this.query(`SELECT ${database ? `'${database}'` : null} as database, ${schema ? `'${schema}'` : null} as schema, * FROM ${schema ? `"${schema}".` : ""}${this.escapePath(`sqlite_master`)} WHERE "type" = '${tableOrIndex}' AND "${tableOrIndex === "table" ? "name" : "tbl_name"}" IN ('${tableName}')`);
+        return res;
+    }
+    async loadPragmaRecords(tablePath, pragma) {
+        const [, tableName] = this.splitTablePath(tablePath);
+        const res = await this.query(`PRAGMA ${pragma}("${tableName}")`);
+        return res;
+    }
     /**
      * Loads all tables (with given names) from the database and creates a Table from them.
      */
-    AbstractSqliteQueryRunner.prototype.loadTables = function (tableNames) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var dbTables, dbIndicesDef, tablesSql, _a, _b, _c, _d, tableNamesString;
-            var _this = this;
-            return tslib_1.__generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        // if no tables given then no need to proceed
-                        if (tableNames && tableNames.length === 0) {
-                            return [2 /*return*/, []];
+    async loadTables(tableNames) {
+        // if no tables given then no need to proceed
+        if (tableNames && tableNames.length === 0) {
+            return [];
+        }
+        let dbTables = [];
+        let dbIndicesDef;
+        if (!tableNames) {
+            const tablesSql = `SELECT * FROM "sqlite_master" WHERE "type" = 'table'`;
+            dbTables.push(...(await this.query(tablesSql)));
+            const tableNamesString = dbTables
+                .map(({ name }) => `'${name}'`)
+                .join(", ");
+            dbIndicesDef = await this.query(`SELECT * FROM "sqlite_master" WHERE "type" = 'index' AND "tbl_name" IN (${tableNamesString})`);
+        }
+        else {
+            dbTables = (await Promise.all(tableNames.map((tableName) => this.loadTableRecords(tableName, "table"))))
+                .reduce((acc, res) => [...acc, ...res], [])
+                .filter(Boolean);
+            dbIndicesDef = (await Promise.all((tableNames ?? []).map((tableName) => this.loadTableRecords(tableName, "index"))))
+                .reduce((acc, res) => [...acc, ...res], [])
+                .filter(Boolean);
+        }
+        // if tables were not found in the db, no need to proceed
+        if (dbTables.length === 0) {
+            return [];
+        }
+        // create table schemas for loaded tables
+        return Promise.all(dbTables.map(async (dbTable) => {
+            const tablePath = dbTable["database"] &&
+                this.driver.getAttachedDatabaseHandleByRelativePath(dbTable["database"])
+                ? `${this.driver.getAttachedDatabaseHandleByRelativePath(dbTable["database"])}.${dbTable["name"]}`
+                : dbTable["name"];
+            const sql = dbTable["sql"];
+            const withoutRowid = sql.includes("WITHOUT ROWID");
+            const table = new Table_1.Table({ name: tablePath, withoutRowid });
+            // load columns and indices
+            const [dbColumns, dbIndices, dbForeignKeys] = await Promise.all([
+                this.loadPragmaRecords(tablePath, `table_xinfo`),
+                this.loadPragmaRecords(tablePath, `index_list`),
+                this.loadPragmaRecords(tablePath, `foreign_key_list`),
+            ]);
+            // find column name with auto increment
+            let autoIncrementColumnName = undefined;
+            const tableSql = dbTable["sql"];
+            let autoIncrementIndex = tableSql
+                .toUpperCase()
+                .indexOf("AUTOINCREMENT");
+            if (autoIncrementIndex !== -1) {
+                autoIncrementColumnName = tableSql.substr(0, autoIncrementIndex);
+                const comma = autoIncrementColumnName.lastIndexOf(",");
+                const bracket = autoIncrementColumnName.lastIndexOf("(");
+                if (comma !== -1) {
+                    autoIncrementColumnName =
+                        autoIncrementColumnName.substr(comma);
+                    autoIncrementColumnName =
+                        autoIncrementColumnName.substr(0, autoIncrementColumnName.lastIndexOf('"'));
+                    autoIncrementColumnName =
+                        autoIncrementColumnName.substr(autoIncrementColumnName.indexOf('"') + 1);
+                }
+                else if (bracket !== -1) {
+                    autoIncrementColumnName =
+                        autoIncrementColumnName.substr(bracket);
+                    autoIncrementColumnName =
+                        autoIncrementColumnName.substr(0, autoIncrementColumnName.lastIndexOf('"'));
+                    autoIncrementColumnName =
+                        autoIncrementColumnName.substr(autoIncrementColumnName.indexOf('"') + 1);
+                }
+            }
+            // create columns from the loaded columns
+            table.columns = await Promise.all(dbColumns.map(async (dbColumn) => {
+                const tableColumn = new TableColumn_1.TableColumn();
+                tableColumn.name = dbColumn["name"];
+                tableColumn.type = dbColumn["type"].toLowerCase();
+                tableColumn.default =
+                    dbColumn["dflt_value"] !== null &&
+                        dbColumn["dflt_value"] !== undefined
+                        ? dbColumn["dflt_value"]
+                        : undefined;
+                tableColumn.isNullable = dbColumn["notnull"] === 0;
+                // primary keys are numbered starting with 1, columns that aren't primary keys are marked with 0
+                tableColumn.isPrimary = dbColumn["pk"] > 0;
+                tableColumn.comment = ""; // SQLite does not support column comments
+                tableColumn.isGenerated =
+                    autoIncrementColumnName === dbColumn["name"];
+                if (tableColumn.isGenerated) {
+                    tableColumn.generationStrategy = "increment";
+                }
+                if (dbColumn["hidden"] === 2 ||
+                    dbColumn["hidden"] === 3) {
+                    tableColumn.generatedType =
+                        dbColumn["hidden"] === 2 ? "VIRTUAL" : "STORED";
+                    const asExpressionQuery = await this.selectTypeormMetadataSql({
+                        table: table.name,
+                        type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                        name: tableColumn.name,
+                    });
+                    const results = await this.query(asExpressionQuery.query, asExpressionQuery.parameters);
+                    if (results[0] && results[0].value) {
+                        tableColumn.asExpression = results[0].value;
+                    }
+                    else {
+                        tableColumn.asExpression = "";
+                    }
+                }
+                if (tableColumn.type === "varchar") {
+                    // Check if this is an enum
+                    const enumMatch = sql.match(new RegExp('"(' +
+                        tableColumn.name +
+                        ")\" varchar CHECK\\s*\\(\\s*\"\\1\"\\s+IN\\s*\\(('[^']+'(?:\\s*,\\s*'[^']+')+)\\s*\\)\\s*\\)"));
+                    if (enumMatch) {
+                        // This is an enum
+                        tableColumn.enum = enumMatch[2]
+                            .substr(1, enumMatch[2].length - 2)
+                            .split("','");
+                    }
+                }
+                // parse datatype and attempt to retrieve length, precision and scale
+                let pos = tableColumn.type.indexOf("(");
+                if (pos !== -1) {
+                    const fullType = tableColumn.type;
+                    let dataType = fullType.substr(0, pos);
+                    if (!!this.driver.withLengthColumnTypes.find((col) => col === dataType)) {
+                        let len = parseInt(fullType.substring(pos + 1, fullType.length - 1));
+                        if (len) {
+                            tableColumn.length = len.toString();
+                            tableColumn.type = dataType; // remove the length part from the datatype
+                        }
+                    }
+                    if (!!this.driver.withPrecisionColumnTypes.find((col) => col === dataType)) {
+                        const re = new RegExp(`^${dataType}\\((\\d+),?\\s?(\\d+)?\\)`);
+                        const matches = fullType.match(re);
+                        if (matches && matches[1]) {
+                            tableColumn.precision = +matches[1];
                         }
-                        dbTables = [];
-                        if (!!tableNames) return [3 /*break*/, 3];
-                        tablesSql = "SELECT * FROM \"sqlite_master\" WHERE \"type\" = 'table'";
-                        _b = (_a = dbTables.push).apply;
-                        _c = [dbTables];
-                        _d = [[]];
-                        return [4 /*yield*/, this.query(tablesSql)];
-                    case 1:
-                        _b.apply(_a, _c.concat([tslib_1.__spreadArray.apply(void 0, _d.concat([tslib_1.__read.apply(void 0, [(_e.sent())]), false]))]));
-                        tableNamesString = dbTables
-                            .map(function (_a) {
-                            var name = _a.name;
-                            return "'".concat(name, "'");
-                        })
-                            .join(", ");
-                        return [4 /*yield*/, this.query("SELECT * FROM \"sqlite_master\" WHERE \"type\" = 'index' AND \"tbl_name\" IN (".concat(tableNamesString, ")"))];
-                    case 2:
-                        dbIndicesDef = _e.sent();
-                        return [3 /*break*/, 6];
-                    case 3: return [4 /*yield*/, Promise.all(tableNames.map(function (tableName) {
-                            return _this.loadTableRecords(tableName, "table");
-                        }))];
-                    case 4:
-                        dbTables = (_e.sent())
-                            .reduce(function (acc, res) { return tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(acc), false), tslib_1.__read(res), false); }, [])
-                            .filter(Boolean);
-                        return [4 /*yield*/, Promise.all((tableNames !== null && tableNames !== void 0 ? tableNames : []).map(function (tableName) {
-                                return _this.loadTableRecords(tableName, "index");
-                            }))];
-                    case 5:
-                        dbIndicesDef = (_e.sent())
-                            .reduce(function (acc, res) { return tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(acc), false), tslib_1.__read(res), false); }, [])
-                            .filter(Boolean);
-                        _e.label = 6;
-                    case 6:
-                        // if tables were not found in the db, no need to proceed
-                        if (dbTables.length === 0) {
-                            return [2 /*return*/, []];
+                        if (!!this.driver.withScaleColumnTypes.find((col) => col === dataType)) {
+                            if (matches && matches[2]) {
+                                tableColumn.scale = +matches[2];
+                            }
                         }
-                        // create table schemas for loaded tables
-                        return [2 /*return*/, Promise.all(dbTables.map(function (dbTable) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var tablePath, sql, withoutRowid, table, _a, dbColumns, dbIndices, dbForeignKeys, autoIncrementColumnName, tableSql, autoIncrementIndex, comma, bracket, _b, fkResult, fkMappings, fkRegex, tableForeignKeyConstraints, uniqueRegexResult, uniqueMappings, uniqueRegex, tableUniquePromises, _c, result, regexp, indicesPromises, indices;
-                                var _this = this;
-                                return tslib_1.__generator(this, function (_d) {
-                                    switch (_d.label) {
-                                        case 0:
-                                            tablePath = dbTable["database"] &&
-                                                this.driver.getAttachedDatabaseHandleByRelativePath(dbTable["database"])
-                                                ? "".concat(this.driver.getAttachedDatabaseHandleByRelativePath(dbTable["database"]), ".").concat(dbTable["name"])
-                                                : dbTable["name"];
-                                            sql = dbTable["sql"];
-                                            withoutRowid = sql.includes("WITHOUT ROWID");
-                                            table = new Table_1.Table({ name: tablePath, withoutRowid: withoutRowid });
-                                            return [4 /*yield*/, Promise.all([
-                                                    this.loadPragmaRecords(tablePath, "table_xinfo"),
-                                                    this.loadPragmaRecords(tablePath, "index_list"),
-                                                    this.loadPragmaRecords(tablePath, "foreign_key_list"),
-                                                ])
-                                                // find column name with auto increment
-                                            ];
-                                        case 1:
-                                            _a = tslib_1.__read.apply(void 0, [_d.sent()
-                                                // find column name with auto increment
-                                                , 3]), dbColumns = _a[0], dbIndices = _a[1], dbForeignKeys = _a[2];
-                                            autoIncrementColumnName = undefined;
-                                            tableSql = dbTable["sql"];
-                                            autoIncrementIndex = tableSql
-                                                .toUpperCase()
-                                                .indexOf("AUTOINCREMENT");
-                                            if (autoIncrementIndex !== -1) {
-                                                autoIncrementColumnName = tableSql.substr(0, autoIncrementIndex);
-                                                comma = autoIncrementColumnName.lastIndexOf(",");
-                                                bracket = autoIncrementColumnName.lastIndexOf("(");
-                                                if (comma !== -1) {
-                                                    autoIncrementColumnName =
-                                                        autoIncrementColumnName.substr(comma);
-                                                    autoIncrementColumnName =
-                                                        autoIncrementColumnName.substr(0, autoIncrementColumnName.lastIndexOf('"'));
-                                                    autoIncrementColumnName =
-                                                        autoIncrementColumnName.substr(autoIncrementColumnName.indexOf('"') + 1);
-                                                }
-                                                else if (bracket !== -1) {
-                                                    autoIncrementColumnName =
-                                                        autoIncrementColumnName.substr(bracket);
-                                                    autoIncrementColumnName =
-                                                        autoIncrementColumnName.substr(0, autoIncrementColumnName.lastIndexOf('"'));
-                                                    autoIncrementColumnName =
-                                                        autoIncrementColumnName.substr(autoIncrementColumnName.indexOf('"') + 1);
-                                                }
-                                            }
-                                            // create columns from the loaded columns
-                                            _b = table;
-                                            return [4 /*yield*/, Promise.all(dbColumns.map(function (dbColumn) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                                    var tableColumn, asExpressionQuery, results, enumMatch, pos, fullType, dataType_1, len, re, matches;
-                                                    return tslib_1.__generator(this, function (_a) {
-                                                        switch (_a.label) {
-                                                            case 0:
-                                                                tableColumn = new TableColumn_1.TableColumn();
-                                                                tableColumn.name = dbColumn["name"];
-                                                                tableColumn.type = dbColumn["type"].toLowerCase();
-                                                                tableColumn.default =
-                                                                    dbColumn["dflt_value"] !== null &&
-                                                                        dbColumn["dflt_value"] !== undefined
-                                                                        ? dbColumn["dflt_value"]
-                                                                        : undefined;
-                                                                tableColumn.isNullable = dbColumn["notnull"] === 0;
-                                                                // primary keys are numbered starting with 1, columns that aren't primary keys are marked with 0
-                                                                tableColumn.isPrimary = dbColumn["pk"] > 0;
-                                                                tableColumn.comment = ""; // SQLite does not support column comments
-                                                                tableColumn.isGenerated =
-                                                                    autoIncrementColumnName === dbColumn["name"];
-                                                                if (tableColumn.isGenerated) {
-                                                                    tableColumn.generationStrategy = "increment";
-                                                                }
-                                                                if (!(dbColumn["hidden"] === 2 ||
-                                                                    dbColumn["hidden"] === 3)) return [3 /*break*/, 3];
-                                                                tableColumn.generatedType =
-                                                                    dbColumn["hidden"] === 2 ? "VIRTUAL" : "STORED";
-                                                                return [4 /*yield*/, this.selectTypeormMetadataSql({
-                                                                        table: table.name,
-                                                                        type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                                                                        name: tableColumn.name,
-                                                                    })];
-                                                            case 1:
-                                                                asExpressionQuery = _a.sent();
-                                                                return [4 /*yield*/, this.query(asExpressionQuery.query, asExpressionQuery.parameters)];
-                                                            case 2:
-                                                                results = _a.sent();
-                                                                if (results[0] && results[0].value) {
-                                                                    tableColumn.asExpression = results[0].value;
-                                                                }
-                                                                else {
-                                                                    tableColumn.asExpression = "";
-                                                                }
-                                                                _a.label = 3;
-                                                            case 3:
-                                                                if (tableColumn.type === "varchar") {
-                                                                    enumMatch = sql.match(new RegExp('"(' +
-                                                                        tableColumn.name +
-                                                                        ")\" varchar CHECK\\s*\\(\\s*\"\\1\"\\s+IN\\s*\\(('[^']+'(?:\\s*,\\s*'[^']+')+)\\s*\\)\\s*\\)"));
-                                                                    if (enumMatch) {
-                                                                        // This is an enum
-                                                                        tableColumn.enum = enumMatch[2]
-                                                                            .substr(1, enumMatch[2].length - 2)
-                                                                            .split("','");
-                                                                    }
-                                                                }
-                                                                pos = tableColumn.type.indexOf("(");
-                                                                if (pos !== -1) {
-                                                                    fullType = tableColumn.type;
-                                                                    dataType_1 = fullType.substr(0, pos);
-                                                                    if (!!this.driver.withLengthColumnTypes.find(function (col) { return col === dataType_1; })) {
-                                                                        len = parseInt(fullType.substring(pos + 1, fullType.length - 1));
-                                                                        if (len) {
-                                                                            tableColumn.length = len.toString();
-                                                                            tableColumn.type = dataType_1; // remove the length part from the datatype
-                                                                        }
-                                                                    }
-                                                                    if (!!this.driver.withPrecisionColumnTypes.find(function (col) { return col === dataType_1; })) {
-                                                                        re = new RegExp("^".concat(dataType_1, "\\((\\d+),?\\s?(\\d+)?\\)"));
-                                                                        matches = fullType.match(re);
-                                                                        if (matches && matches[1]) {
-                                                                            tableColumn.precision = +matches[1];
-                                                                        }
-                                                                        if (!!this.driver.withScaleColumnTypes.find(function (col) { return col === dataType_1; })) {
-                                                                            if (matches && matches[2]) {
-                                                                                tableColumn.scale = +matches[2];
-                                                                            }
-                                                                        }
-                                                                        tableColumn.type = dataType_1; // remove the precision/scale part from the datatype
-                                                                    }
-                                                                }
-                                                                return [2 /*return*/, tableColumn];
-                                                        }
-                                                    });
-                                                }); }))
-                                                // find foreign key constraints from CREATE TABLE sql
-                                            ];
-                                        case 2:
-                                            // create columns from the loaded columns
-                                            _b.columns = _d.sent();
-                                            fkMappings = [];
-                                            fkRegex = /CONSTRAINT "([^"]*)" FOREIGN KEY ?\((.*?)\) REFERENCES "([^"]*)"/g;
-                                            while ((fkResult = fkRegex.exec(sql)) !== null) {
-                                                fkMappings.push({
-                                                    name: fkResult[1],
-                                                    columns: fkResult[2]
-                                                        .substr(1, fkResult[2].length - 2)
-                                                        .split("\", \""),
-                                                    referencedTableName: fkResult[3],
-                                                });
-                                            }
-                                            tableForeignKeyConstraints = OrmUtils_1.OrmUtils.uniq(dbForeignKeys, function (dbForeignKey) { return dbForeignKey["id"]; });
-                                            table.foreignKeys = tableForeignKeyConstraints.map(function (foreignKey) {
-                                                var ownForeignKeys = dbForeignKeys.filter(function (dbForeignKey) {
-                                                    return dbForeignKey["id"] === foreignKey["id"] &&
-                                                        dbForeignKey["table"] === foreignKey["table"];
-                                                });
-                                                var columnNames = ownForeignKeys.map(function (dbForeignKey) { return dbForeignKey["from"]; });
-                                                var referencedColumnNames = ownForeignKeys.map(function (dbForeignKey) { return dbForeignKey["to"]; });
-                                                // find related foreign key mapping
-                                                var fkMapping = fkMappings.find(function (it) {
-                                                    return it.referencedTableName ===
-                                                        foreignKey["table"] &&
-                                                        it.columns.every(function (column) {
-                                                            return columnNames.indexOf(column) !== -1;
-                                                        });
-                                                });
-                                                return new TableForeignKey_1.TableForeignKey({
-                                                    name: fkMapping.name,
-                                                    columnNames: columnNames,
-                                                    referencedTableName: foreignKey["table"],
-                                                    referencedColumnNames: referencedColumnNames,
-                                                    onDelete: foreignKey["on_delete"],
-                                                    onUpdate: foreignKey["on_update"],
-                                                });
-                                            });
-                                            uniqueMappings = [];
-                                            uniqueRegex = /CONSTRAINT "([^"]*)" UNIQUE ?\((.*?)\)/g;
-                                            while ((uniqueRegexResult = uniqueRegex.exec(sql)) !== null) {
-                                                uniqueMappings.push({
-                                                    name: uniqueRegexResult[1],
-                                                    columns: uniqueRegexResult[2]
-                                                        .substr(1, uniqueRegexResult[2].length - 2)
-                                                        .split("\", \""),
-                                                });
-                                            }
-                                            tableUniquePromises = dbIndices
-                                                .filter(function (dbIndex) { return dbIndex["origin"] === "u"; })
-                                                .map(function (dbIndex) { return dbIndex["name"]; })
-                                                .filter(function (value, index, self) { return self.indexOf(value) === index; })
-                                                .map(function (dbIndexName) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                                var dbIndex, indexInfos, indexColumns, column, foundMapping;
-                                                return tslib_1.__generator(this, function (_a) {
-                                                    switch (_a.label) {
-                                                        case 0:
-                                                            dbIndex = dbIndices.find(function (dbIndex) { return dbIndex["name"] === dbIndexName; });
-                                                            return [4 /*yield*/, this.query("PRAGMA index_info(\"".concat(dbIndex["name"], "\")"))];
-                                                        case 1:
-                                                            indexInfos = _a.sent();
-                                                            indexColumns = indexInfos
-                                                                .sort(function (indexInfo1, indexInfo2) {
-                                                                return parseInt(indexInfo1["seqno"]) -
-                                                                    parseInt(indexInfo2["seqno"]);
-                                                            })
-                                                                .map(function (indexInfo) { return indexInfo["name"]; });
-                                                            if (indexColumns.length === 1) {
-                                                                column = table.columns.find(function (column) {
-                                                                    return !!indexColumns.find(function (indexColumn) {
-                                                                        return indexColumn === column.name;
-                                                                    });
-                                                                });
-                                                                if (column)
-                                                                    column.isUnique = true;
-                                                            }
-                                                            foundMapping = uniqueMappings.find(function (mapping) {
-                                                                return mapping.columns.every(function (column) { return indexColumns.indexOf(column) !== -1; });
-                                                            });
-                                                            return [2 /*return*/, new TableUnique_1.TableUnique({
-                                                                    name: foundMapping
-                                                                        ? foundMapping.name
-                                                                        : this.connection.namingStrategy.uniqueConstraintName(table, indexColumns),
-                                                                    columnNames: indexColumns,
-                                                                })];
-                                                    }
-                                                });
-                                            }); });
-                                            _c = table;
-                                            return [4 /*yield*/, Promise.all(tableUniquePromises)];
-                                        case 3:
-                                            _c.uniques = (_d.sent());
-                                            regexp = /CONSTRAINT "([^"]*)" CHECK ?(\(.*?\))([,]|[)]$)/g;
-                                            while ((result = regexp.exec(sql)) !== null) {
-                                                table.checks.push(new TableCheck_1.TableCheck({
-                                                    name: result[1],
-                                                    expression: result[2],
-                                                }));
-                                            }
-                                            indicesPromises = dbIndices
-                                                .filter(function (dbIndex) { return dbIndex["origin"] === "c"; })
-                                                .map(function (dbIndex) { return dbIndex["name"]; })
-                                                .filter(function (value, index, self) { return self.indexOf(value) === index; }) // unqiue
-                                                .map(function (dbIndexName) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                                var indexDef, condition, dbIndex, indexInfos, indexColumns, dbIndexPath, isUnique;
-                                                return tslib_1.__generator(this, function (_a) {
-                                                    switch (_a.label) {
-                                                        case 0:
-                                                            indexDef = dbIndicesDef.find(function (dbIndexDef) { return dbIndexDef["name"] === dbIndexName; });
-                                                            condition = /WHERE (.*)/.exec(indexDef["sql"]);
-                                                            dbIndex = dbIndices.find(function (dbIndex) { return dbIndex["name"] === dbIndexName; });
-                                                            return [4 /*yield*/, this.query("PRAGMA index_info(\"".concat(dbIndex["name"], "\")"))];
-                                                        case 1:
-                                                            indexInfos = _a.sent();
-                                                            indexColumns = indexInfos
-                                                                .sort(function (indexInfo1, indexInfo2) {
-                                                                return parseInt(indexInfo1["seqno"]) -
-                                                                    parseInt(indexInfo2["seqno"]);
-                                                            })
-                                                                .map(function (indexInfo) { return indexInfo["name"]; });
-                                                            dbIndexPath = "".concat(dbTable["database"] ? "".concat(dbTable["database"], ".") : "").concat(dbIndex["name"]);
-                                                            isUnique = dbIndex["unique"] === "1" ||
-                                                                dbIndex["unique"] === 1;
-                                                            return [2 /*return*/, new TableIndex_1.TableIndex({
-                                                                    table: table,
-                                                                    name: dbIndexPath,
-                                                                    columnNames: indexColumns,
-                                                                    isUnique: isUnique,
-                                                                    where: condition ? condition[1] : undefined,
-                                                                })];
-                                                    }
-                                                });
-                                            }); });
-                                            return [4 /*yield*/, Promise.all(indicesPromises)];
-                                        case 4:
-                                            indices = _d.sent();
-                                            table.indices = indices.filter(function (index) { return !!index; });
-                                            return [2 /*return*/, table];
-                                    }
-                                });
-                            }); }))];
+                        tableColumn.type = dataType; // remove the precision/scale part from the datatype
+                    }
                 }
+                return tableColumn;
+            }));
+            // find foreign key constraints from CREATE TABLE sql
+            let fkResult;
+            const fkMappings = [];
+            const fkRegex = /CONSTRAINT "([^"]*)" FOREIGN KEY ?\((.*?)\) REFERENCES "([^"]*)"/g;
+            while ((fkResult = fkRegex.exec(sql)) !== null) {
+                fkMappings.push({
+                    name: fkResult[1],
+                    columns: fkResult[2]
+                        .substr(1, fkResult[2].length - 2)
+                        .split(`", "`),
+                    referencedTableName: fkResult[3],
+                });
+            }
+            // build foreign keys
+            const tableForeignKeyConstraints = OrmUtils_1.OrmUtils.uniq(dbForeignKeys, (dbForeignKey) => dbForeignKey["id"]);
+            table.foreignKeys = tableForeignKeyConstraints.map((foreignKey) => {
+                const ownForeignKeys = dbForeignKeys.filter((dbForeignKey) => dbForeignKey["id"] === foreignKey["id"] &&
+                    dbForeignKey["table"] === foreignKey["table"]);
+                const columnNames = ownForeignKeys.map((dbForeignKey) => dbForeignKey["from"]);
+                const referencedColumnNames = ownForeignKeys.map((dbForeignKey) => dbForeignKey["to"]);
+                // find related foreign key mapping
+                const fkMapping = fkMappings.find((it) => it.referencedTableName ===
+                    foreignKey["table"] &&
+                    it.columns.every((column) => columnNames.indexOf(column) !== -1));
+                return new TableForeignKey_1.TableForeignKey({
+                    name: fkMapping.name,
+                    columnNames: columnNames,
+                    referencedTableName: foreignKey["table"],
+                    referencedColumnNames: referencedColumnNames,
+                    onDelete: foreignKey["on_delete"],
+                    onUpdate: foreignKey["on_update"],
+                });
             });
-        });
-    };
+            // find unique constraints from CREATE TABLE sql
+            let uniqueRegexResult;
+            const uniqueMappings = [];
+            const uniqueRegex = /CONSTRAINT "([^"]*)" UNIQUE ?\((.*?)\)/g;
+            while ((uniqueRegexResult = uniqueRegex.exec(sql)) !== null) {
+                uniqueMappings.push({
+                    name: uniqueRegexResult[1],
+                    columns: uniqueRegexResult[2]
+                        .substr(1, uniqueRegexResult[2].length - 2)
+                        .split(`", "`),
+                });
+            }
+            // build unique constraints
+            const tableUniquePromises = dbIndices
+                .filter((dbIndex) => dbIndex["origin"] === "u")
+                .map((dbIndex) => dbIndex["name"])
+                .filter((value, index, self) => self.indexOf(value) === index)
+                .map(async (dbIndexName) => {
+                const dbIndex = dbIndices.find((dbIndex) => dbIndex["name"] === dbIndexName);
+                const indexInfos = await this.query(`PRAGMA index_info("${dbIndex["name"]}")`);
+                const indexColumns = indexInfos
+                    .sort((indexInfo1, indexInfo2) => parseInt(indexInfo1["seqno"]) -
+                    parseInt(indexInfo2["seqno"]))
+                    .map((indexInfo) => indexInfo["name"]);
+                if (indexColumns.length === 1) {
+                    const column = table.columns.find((column) => {
+                        return !!indexColumns.find((indexColumn) => indexColumn === column.name);
+                    });
+                    if (column)
+                        column.isUnique = true;
+                }
+                // find existent mapping by a column names
+                const foundMapping = uniqueMappings.find((mapping) => {
+                    return mapping.columns.every((column) => indexColumns.indexOf(column) !== -1);
+                });
+                return new TableUnique_1.TableUnique({
+                    name: foundMapping
+                        ? foundMapping.name
+                        : this.connection.namingStrategy.uniqueConstraintName(table, indexColumns),
+                    columnNames: indexColumns,
+                });
+            });
+            table.uniques = (await Promise.all(tableUniquePromises));
+            // build checks
+            let result;
+            const regexp = /CONSTRAINT "([^"]*)" CHECK ?(\(.*?\))([,]|[)]$)/g;
+            while ((result = regexp.exec(sql)) !== null) {
+                table.checks.push(new TableCheck_1.TableCheck({
+                    name: result[1],
+                    expression: result[2],
+                }));
+            }
+            // build indices
+            const indicesPromises = dbIndices
+                .filter((dbIndex) => dbIndex["origin"] === "c")
+                .map((dbIndex) => dbIndex["name"])
+                .filter((value, index, self) => self.indexOf(value) === index) // unqiue
+                .map(async (dbIndexName) => {
+                const indexDef = dbIndicesDef.find((dbIndexDef) => dbIndexDef["name"] === dbIndexName);
+                const condition = /WHERE (.*)/.exec(indexDef["sql"]);
+                const dbIndex = dbIndices.find((dbIndex) => dbIndex["name"] === dbIndexName);
+                const indexInfos = await this.query(`PRAGMA index_info("${dbIndex["name"]}")`);
+                const indexColumns = indexInfos
+                    .sort((indexInfo1, indexInfo2) => parseInt(indexInfo1["seqno"]) -
+                    parseInt(indexInfo2["seqno"]))
+                    .map((indexInfo) => indexInfo["name"]);
+                const dbIndexPath = `${dbTable["database"] ? `${dbTable["database"]}.` : ""}${dbIndex["name"]}`;
+                const isUnique = dbIndex["unique"] === "1" ||
+                    dbIndex["unique"] === 1;
+                return new TableIndex_1.TableIndex({
+                    table: table,
+                    name: dbIndexPath,
+                    columnNames: indexColumns,
+                    isUnique: isUnique,
+                    where: condition ? condition[1] : undefined,
+                });
+            });
+            const indices = await Promise.all(indicesPromises);
+            table.indices = indices.filter((index) => !!index);
+            return table;
+        }));
+    }
     /**
      * Builds create table sql.
      */
-    AbstractSqliteQueryRunner.prototype.createTableSql = function (table, createForeignKeys, temporaryTable) {
-        var _this = this;
-        var primaryColumns = table.columns.filter(function (column) { return column.isPrimary; });
-        var hasAutoIncrement = primaryColumns.find(function (column) {
-            return column.isGenerated && column.generationStrategy === "increment";
-        });
-        var skipPrimary = primaryColumns.length > 1;
+    createTableSql(table, createForeignKeys, temporaryTable) {
+        const primaryColumns = table.columns.filter((column) => column.isPrimary);
+        const hasAutoIncrement = primaryColumns.find((column) => column.isGenerated && column.generationStrategy === "increment");
+        const skipPrimary = primaryColumns.length > 1;
         if (skipPrimary && hasAutoIncrement)
-            throw new error_1.TypeORMError("Sqlite does not support AUTOINCREMENT on composite primary key");
-        var columnDefinitions = table.columns
-            .map(function (column) { return _this.buildCreateColumnSql(column, skipPrimary); })
+            throw new error_1.TypeORMError(`Sqlite does not support AUTOINCREMENT on composite primary key`);
+        const columnDefinitions = table.columns
+            .map((column) => this.buildCreateColumnSql(column, skipPrimary))
             .join(", ");
-        var _a = tslib_1.__read(this.splitTablePath(table.name), 1), database = _a[0];
-        var sql = "CREATE TABLE ".concat(this.escapePath(table.name), " (").concat(columnDefinitions);
-        var _b = tslib_1.__read(this.splitTablePath(table.name), 2), databaseNew = _b[0], tableName = _b[1];
-        var newTableName = temporaryTable
-            ? "".concat(databaseNew ? "".concat(databaseNew, ".") : "").concat(tableName.replace(/^temporary_/, ""))
+        const [database] = this.splitTablePath(table.name);
+        let sql = `CREATE TABLE ${this.escapePath(table.name)} (${columnDefinitions}`;
+        let [databaseNew, tableName] = this.splitTablePath(table.name);
+        const newTableName = temporaryTable
+            ? `${databaseNew ? `${databaseNew}.` : ""}${tableName.replace(/^temporary_/, "")}`
             : table.name;
         // need for `addColumn()` method, because it recreates table.
         table.columns
-            .filter(function (column) { return column.isUnique; })
-            .forEach(function (column) {
-            var isUniqueExist = table.uniques.some(function (unique) {
-                return unique.columnNames.length === 1 &&
-                    unique.columnNames[0] === column.name;
-            });
+            .filter((column) => column.isUnique)
+            .forEach((column) => {
+            const isUniqueExist = table.uniques.some((unique) => unique.columnNames.length === 1 &&
+                unique.columnNames[0] === column.name);
             if (!isUniqueExist)
                 table.uniques.push(new TableUnique_1.TableUnique({
-                    name: _this.connection.namingStrategy.uniqueConstraintName(table, [column.name]),
+                    name: this.connection.namingStrategy.uniqueConstraintName(table, [column.name]),
                     columnNames: [column.name],
                 }));
         });
         if (table.uniques.length > 0) {
-            var uniquesSql = table.uniques
-                .map(function (unique) {
-                var uniqueName = unique.name
+            const uniquesSql = table.uniques
+                .map((unique) => {
+                const uniqueName = unique.name
                     ? unique.name
-                    : _this.connection.namingStrategy.uniqueConstraintName(newTableName, unique.columnNames);
-                var columnNames = unique.columnNames
-                    .map(function (columnName) { return "\"".concat(columnName, "\""); })
+                    : this.connection.namingStrategy.uniqueConstraintName(newTableName, unique.columnNames);
+                const columnNames = unique.columnNames
+                    .map((columnName) => `"${columnName}"`)
                     .join(", ");
-                return "CONSTRAINT \"".concat(uniqueName, "\" UNIQUE (").concat(columnNames, ")");
+                return `CONSTRAINT "${uniqueName}" UNIQUE (${columnNames})`;
             })
                 .join(", ");
-            sql += ", ".concat(uniquesSql);
+            sql += `, ${uniquesSql}`;
         }
         if (table.checks.length > 0) {
-            var checksSql = table.checks
-                .map(function (check) {
-                var checkName = check.name
+            const checksSql = table.checks
+                .map((check) => {
+                const checkName = check.name
                     ? check.name
-                    : _this.connection.namingStrategy.checkConstraintName(newTableName, check.expression);
-                return "CONSTRAINT \"".concat(checkName, "\" CHECK (").concat(check.expression, ")");
+                    : this.connection.namingStrategy.checkConstraintName(newTableName, check.expression);
+                return `CONSTRAINT "${checkName}" CHECK (${check.expression})`;
             })
                 .join(", ");
-            sql += ", ".concat(checksSql);
+            sql += `, ${checksSql}`;
         }
         if (table.foreignKeys.length > 0 && createForeignKeys) {
-            var foreignKeysSql = table.foreignKeys
-                .filter(function (fk) {
-                var _a = tslib_1.__read(_this.splitTablePath(fk.referencedTableName), 1), referencedDatabase = _a[0];
+            const foreignKeysSql = table.foreignKeys
+                .filter((fk) => {
+                const [referencedDatabase] = this.splitTablePath(fk.referencedTableName);
                 if (referencedDatabase !== database) {
                     return false;
                 }
                 return true;
             })
-                .map(function (fk) {
-                var _a = tslib_1.__read(_this.splitTablePath(fk.referencedTableName), 2), referencedTable = _a[1];
-                var columnNames = fk.columnNames
-                    .map(function (columnName) { return "\"".concat(columnName, "\""); })
+                .map((fk) => {
+                const [, referencedTable] = this.splitTablePath(fk.referencedTableName);
+                const columnNames = fk.columnNames
+                    .map((columnName) => `"${columnName}"`)
                     .join(", ");
                 if (!fk.name)
-                    fk.name = _this.connection.namingStrategy.foreignKeyName(newTableName, fk.columnNames, _this.getTablePath(fk), fk.referencedColumnNames);
-                var referencedColumnNames = fk.referencedColumnNames
-                    .map(function (columnName) { return "\"".concat(columnName, "\""); })
+                    fk.name = this.connection.namingStrategy.foreignKeyName(newTableName, fk.columnNames, this.getTablePath(fk), fk.referencedColumnNames);
+                const referencedColumnNames = fk.referencedColumnNames
+                    .map((columnName) => `"${columnName}"`)
                     .join(", ");
-                var constraint = "CONSTRAINT \"".concat(fk.name, "\" FOREIGN KEY (").concat(columnNames, ") REFERENCES \"").concat(referencedTable, "\" (").concat(referencedColumnNames, ")");
+                let constraint = `CONSTRAINT "${fk.name}" FOREIGN KEY (${columnNames}) REFERENCES "${referencedTable}" (${referencedColumnNames})`;
                 if (fk.onDelete)
-                    constraint += " ON DELETE ".concat(fk.onDelete);
+                    constraint += ` ON DELETE ${fk.onDelete}`;
                 if (fk.onUpdate)
-                    constraint += " ON UPDATE ".concat(fk.onUpdate);
+                    constraint += ` ON UPDATE ${fk.onUpdate}`;
                 if (fk.deferrable)
-                    constraint += " DEFERRABLE ".concat(fk.deferrable);
+                    constraint += ` DEFERRABLE ${fk.deferrable}`;
                 return constraint;
             })
                 .join(", ");
-            sql += ", ".concat(foreignKeysSql);
+            sql += `, ${foreignKeysSql}`;
         }
         if (primaryColumns.length > 1) {
-            var columnNames = primaryColumns
-                .map(function (column) { return "\"".concat(column.name, "\""); })
+            const columnNames = primaryColumns
+                .map((column) => `"${column.name}"`)
                 .join(", ");
-            sql += ", PRIMARY KEY (".concat(columnNames, ")");
+            sql += `, PRIMARY KEY (${columnNames})`;
         }
-        sql += ")";
+        sql += `)`;
         if (table.withoutRowid) {
             sql += " WITHOUT ROWID";
         }
         return new Query_1.Query(sql);
-    };
+    }
     /**
      * Builds drop table sql.
      */
-    AbstractSqliteQueryRunner.prototype.dropTableSql = function (tableOrName, ifExist) {
-        var tableName = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
+    dropTableSql(tableOrName, ifExist) {
+        const tableName = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
             ? tableOrName.name
             : tableOrName;
-        var query = ifExist
-            ? "DROP TABLE IF EXISTS ".concat(this.escapePath(tableName))
-            : "DROP TABLE ".concat(this.escapePath(tableName));
+        const query = ifExist
+            ? `DROP TABLE IF EXISTS ${this.escapePath(tableName)}`
+            : `DROP TABLE ${this.escapePath(tableName)}`;
         return new Query_1.Query(query);
-    };
-    AbstractSqliteQueryRunner.prototype.createViewSql = function (view) {
+    }
+    createViewSql(view) {
         if (typeof view.expression === "string") {
-            return new Query_1.Query("CREATE VIEW \"".concat(view.name, "\" AS ").concat(view.expression));
+            return new Query_1.Query(`CREATE VIEW "${view.name}" AS ${view.expression}`);
         }
         else {
-            return new Query_1.Query("CREATE VIEW \"".concat(view.name, "\" AS ").concat(view
+            return new Query_1.Query(`CREATE VIEW "${view.name}" AS ${view
                 .expression(this.connection)
-                .getQuery()));
+                .getQuery()}`);
         }
-    };
-    AbstractSqliteQueryRunner.prototype.insertViewDefinitionSql = function (view) {
-        var expression = typeof view.expression === "string"
+    }
+    insertViewDefinitionSql(view) {
+        const expression = typeof view.expression === "string"
             ? view.expression.trim()
             : view.expression(this.connection).getQuery();
         return this.insertTypeormMetadataSql({
@@ -2067,52 +1252,52 @@ var AbstractSqliteQueryRunner = /** @class */ (function (_super) {
             name: view.name,
             value: expression,
         });
-    };
+    }
     /**
      * Builds drop view sql.
      */
-    AbstractSqliteQueryRunner.prototype.dropViewSql = function (viewOrPath) {
-        var viewName = InstanceChecker_1.InstanceChecker.isView(viewOrPath)
+    dropViewSql(viewOrPath) {
+        const viewName = InstanceChecker_1.InstanceChecker.isView(viewOrPath)
             ? viewOrPath.name
             : viewOrPath;
-        return new Query_1.Query("DROP VIEW \"".concat(viewName, "\""));
-    };
+        return new Query_1.Query(`DROP VIEW "${viewName}"`);
+    }
     /**
      * Builds remove view sql.
      */
-    AbstractSqliteQueryRunner.prototype.deleteViewDefinitionSql = function (viewOrPath) {
-        var viewName = InstanceChecker_1.InstanceChecker.isView(viewOrPath)
+    deleteViewDefinitionSql(viewOrPath) {
+        const viewName = InstanceChecker_1.InstanceChecker.isView(viewOrPath)
             ? viewOrPath.name
             : viewOrPath;
         return this.deleteTypeormMetadataSql({
             type: MetadataTableType_1.MetadataTableType.VIEW,
             name: viewName,
         });
-    };
+    }
     /**
      * Builds create index sql.
      */
-    AbstractSqliteQueryRunner.prototype.createIndexSql = function (table, index) {
-        var columns = index.columnNames
-            .map(function (columnName) { return "\"".concat(columnName, "\""); })
+    createIndexSql(table, index) {
+        const columns = index.columnNames
+            .map((columnName) => `"${columnName}"`)
             .join(", ");
-        var _a = tslib_1.__read(this.splitTablePath(table.name), 2), database = _a[0], tableName = _a[1];
-        return new Query_1.Query("CREATE ".concat(index.isUnique ? "UNIQUE " : "", "INDEX ").concat(database ? "\"".concat(database, "\".") : "").concat(this.escapePath(index.name), " ON \"").concat(tableName, "\" (").concat(columns, ") ").concat(index.where ? "WHERE " + index.where : ""));
-    };
+        const [database, tableName] = this.splitTablePath(table.name);
+        return new Query_1.Query(`CREATE ${index.isUnique ? "UNIQUE " : ""}INDEX ${database ? `"${database}".` : ""}${this.escapePath(index.name)} ON "${tableName}" (${columns}) ${index.where ? "WHERE " + index.where : ""}`);
+    }
     /**
      * Builds drop index sql.
      */
-    AbstractSqliteQueryRunner.prototype.dropIndexSql = function (indexOrName) {
-        var indexName = InstanceChecker_1.InstanceChecker.isTableIndex(indexOrName)
+    dropIndexSql(indexOrName) {
+        let indexName = InstanceChecker_1.InstanceChecker.isTableIndex(indexOrName)
             ? indexOrName.name
             : indexOrName;
-        return new Query_1.Query("DROP INDEX ".concat(this.escapePath(indexName)));
-    };
+        return new Query_1.Query(`DROP INDEX ${this.escapePath(indexName)}`);
+    }
     /**
      * Builds a query for create column.
      */
-    AbstractSqliteQueryRunner.prototype.buildCreateColumnSql = function (column, skipPrimary) {
-        var c = '"' + column.name + '"';
+    buildCreateColumnSql(column, skipPrimary) {
+        let c = '"' + column.name + '"';
         if (InstanceChecker_1.InstanceChecker.isColumnMetadata(column)) {
             c += " " + this.driver.normalizeType(column);
         }
@@ -2124,7 +1309,7 @@ var AbstractSqliteQueryRunner = /** @class */ (function (_super) {
                 ' CHECK( "' +
                     column.name +
                     '" IN (' +
-                    column.enum.map(function (val) { return "'" + val + "'"; }).join(",") +
+                    column.enum.map((val) => "'" + val + "'").join(",") +
                     ") )";
         if (column.isPrimary && !skipPrimary)
             c += " PRIMARY KEY";
@@ -2137,201 +1322,184 @@ var AbstractSqliteQueryRunner = /** @class */ (function (_super) {
         if (column.isNullable !== true)
             c += " NOT NULL";
         if (column.asExpression) {
-            c += " AS (".concat(column.asExpression, ") ").concat(column.generatedType ? column.generatedType : "VIRTUAL");
+            c += ` AS (${column.asExpression}) ${column.generatedType ? column.generatedType : "VIRTUAL"}`;
         }
         else {
             if (column.default !== undefined && column.default !== null)
                 c += " DEFAULT (" + column.default + ")";
         }
         return c;
-    };
-    AbstractSqliteQueryRunner.prototype.recreateTable = function (newTable_1, oldTable_1) {
-        return tslib_1.__awaiter(this, arguments, void 0, function (newTable, oldTable, migrateData) {
-            var upQueries, downQueries, _a, databaseNew, tableNameNew, _b, tableNameOld, newColumnNames, oldColumnNames;
-            var _this = this;
-            if (migrateData === void 0) { migrateData = true; }
-            return tslib_1.__generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        upQueries = [];
-                        downQueries = [];
-                        // drop old table indices
-                        oldTable.indices.forEach(function (index) {
-                            upQueries.push(_this.dropIndexSql(index));
-                            downQueries.push(_this.createIndexSql(oldTable, index));
-                        });
-                        _a = tslib_1.__read(this.splitTablePath(newTable.name), 2), databaseNew = _a[0], tableNameNew = _a[1];
-                        _b = tslib_1.__read(this.splitTablePath(oldTable.name), 2), tableNameOld = _b[1];
-                        newTable.name = tableNameNew = "".concat(databaseNew ? "".concat(databaseNew, ".") : "", "temporary_").concat(tableNameNew);
-                        // create new table
-                        upQueries.push(this.createTableSql(newTable, true, true));
-                        downQueries.push(this.dropTableSql(newTable));
-                        // migrate all data from the old table into new table
-                        if (migrateData) {
-                            newColumnNames = newTable.columns
-                                .filter(function (column) { return !column.generatedType; })
-                                .map(function (column) { return "\"".concat(column.name, "\""); });
-                            oldColumnNames = oldTable.columns
-                                .filter(function (column) { return !column.generatedType; })
-                                .map(function (column) { return "\"".concat(column.name, "\""); });
-                            if (oldColumnNames.length < newColumnNames.length) {
-                                newColumnNames = newTable.columns
-                                    .filter(function (column) {
-                                    var oldColumn = oldTable.columns.find(function (c) { return c.name === column.name; });
-                                    if (oldColumn && oldColumn.generatedType)
-                                        return false;
-                                    return !column.generatedType && oldColumn;
-                                })
-                                    .map(function (column) { return "\"".concat(column.name, "\""); });
-                            }
-                            else if (oldColumnNames.length > newColumnNames.length) {
-                                oldColumnNames = oldTable.columns
-                                    .filter(function (column) {
-                                    return (!column.generatedType &&
-                                        newTable.columns.find(function (c) { return c.name === column.name; }));
-                                })
-                                    .map(function (column) { return "\"".concat(column.name, "\""); });
-                            }
-                            upQueries.push(new Query_1.Query("INSERT INTO ".concat(this.escapePath(newTable.name), "(").concat(newColumnNames.join(", "), ") SELECT ").concat(oldColumnNames.join(", "), " FROM ").concat(this.escapePath(oldTable.name))));
-                            downQueries.push(new Query_1.Query("INSERT INTO ".concat(this.escapePath(oldTable.name), "(").concat(oldColumnNames.join(", "), ") SELECT ").concat(newColumnNames.join(", "), " FROM ").concat(this.escapePath(newTable.name))));
-                        }
-                        // drop old table
-                        upQueries.push(this.dropTableSql(oldTable));
-                        downQueries.push(this.createTableSql(oldTable, true));
-                        // rename old table
-                        upQueries.push(new Query_1.Query("ALTER TABLE ".concat(this.escapePath(newTable.name), " RENAME TO ").concat(this.escapePath(tableNameOld))));
-                        downQueries.push(new Query_1.Query("ALTER TABLE ".concat(this.escapePath(oldTable.name), " RENAME TO ").concat(this.escapePath(tableNameNew))));
-                        newTable.name = oldTable.name;
-                        // recreate table indices
-                        newTable.indices.forEach(function (index) {
-                            // new index may be passed without name. In this case we generate index name manually.
-                            if (!index.name)
-                                index.name = _this.connection.namingStrategy.indexName(newTable, index.columnNames, index.where);
-                            upQueries.push(_this.createIndexSql(newTable, index));
-                            downQueries.push(_this.dropIndexSql(index));
-                        });
-                        // update generated columns in "typeorm_metadata" table
-                        // Step 1: clear data for removed generated columns
-                        oldTable.columns
-                            .filter(function (column) {
-                            var newTableColumn = newTable.columns.find(function (c) { return c.name === column.name; });
-                            // we should delete record from "typeorm_metadata" if generated column was removed
-                            // or it was changed to non-generated
-                            return (column.generatedType &&
-                                column.asExpression &&
-                                (!newTableColumn ||
-                                    (!newTableColumn.generatedType &&
-                                        !newTableColumn.asExpression)));
-                        })
-                            .forEach(function (column) {
-                            var deleteQuery = _this.deleteTypeormMetadataSql({
-                                table: oldTable.name,
-                                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                                name: column.name,
-                            });
-                            var insertQuery = _this.insertTypeormMetadataSql({
-                                table: oldTable.name,
-                                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                                name: column.name,
-                                value: column.asExpression,
-                            });
-                            upQueries.push(deleteQuery);
-                            downQueries.push(insertQuery);
-                        });
-                        // Step 2: add data for new generated columns
-                        newTable.columns
-                            .filter(function (column) {
-                            return column.generatedType &&
-                                column.asExpression &&
-                                !oldTable.columns.some(function (c) { return c.name === column.name; });
-                        })
-                            .forEach(function (column) {
-                            var insertQuery = _this.insertTypeormMetadataSql({
-                                table: newTable.name,
-                                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                                name: column.name,
-                                value: column.asExpression,
-                            });
-                            var deleteQuery = _this.deleteTypeormMetadataSql({
-                                table: newTable.name,
-                                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                                name: column.name,
-                            });
-                            upQueries.push(insertQuery);
-                            downQueries.push(deleteQuery);
-                        });
-                        // Step 3: update changed expressions
-                        newTable.columns
-                            .filter(function (column) { return column.generatedType && column.asExpression; })
-                            .forEach(function (column) {
-                            var oldColumn = oldTable.columns.find(function (c) {
-                                return c.name === column.name &&
-                                    c.generatedType &&
-                                    column.generatedType &&
-                                    c.asExpression !== column.asExpression;
-                            });
-                            if (!oldColumn)
-                                return;
-                            // update expression
-                            var deleteQuery = _this.deleteTypeormMetadataSql({
-                                table: oldTable.name,
-                                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                                name: oldColumn.name,
-                            });
-                            var insertQuery = _this.insertTypeormMetadataSql({
-                                table: newTable.name,
-                                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                                name: column.name,
-                                value: column.asExpression,
-                            });
-                            upQueries.push(deleteQuery);
-                            upQueries.push(insertQuery);
-                            // revert update
-                            var revertInsertQuery = _this.insertTypeormMetadataSql({
-                                table: newTable.name,
-                                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                                name: oldColumn.name,
-                                value: oldColumn.asExpression,
-                            });
-                            var revertDeleteQuery = _this.deleteTypeormMetadataSql({
-                                table: oldTable.name,
-                                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                                name: column.name,
-                            });
-                            downQueries.push(revertInsertQuery);
-                            downQueries.push(revertDeleteQuery);
-                        });
-                        return [4 /*yield*/, this.executeQueries(upQueries, downQueries)];
-                    case 1:
-                        _c.sent();
-                        this.replaceCachedTable(oldTable, newTable);
-                        return [2 /*return*/];
-                }
+    }
+    async recreateTable(newTable, oldTable, migrateData = true) {
+        const upQueries = [];
+        const downQueries = [];
+        // drop old table indices
+        oldTable.indices.forEach((index) => {
+            upQueries.push(this.dropIndexSql(index));
+            downQueries.push(this.createIndexSql(oldTable, index));
+        });
+        // change table name into 'temporary_table'
+        let [databaseNew, tableNameNew] = this.splitTablePath(newTable.name);
+        let [, tableNameOld] = this.splitTablePath(oldTable.name);
+        newTable.name = tableNameNew = `${databaseNew ? `${databaseNew}.` : ""}temporary_${tableNameNew}`;
+        // create new table
+        upQueries.push(this.createTableSql(newTable, true, true));
+        downQueries.push(this.dropTableSql(newTable));
+        // migrate all data from the old table into new table
+        if (migrateData) {
+            let newColumnNames = newTable.columns
+                .filter((column) => !column.generatedType)
+                .map((column) => `"${column.name}"`);
+            let oldColumnNames = oldTable.columns
+                .filter((column) => !column.generatedType)
+                .map((column) => `"${column.name}"`);
+            if (oldColumnNames.length < newColumnNames.length) {
+                newColumnNames = newTable.columns
+                    .filter((column) => {
+                    const oldColumn = oldTable.columns.find((c) => c.name === column.name);
+                    if (oldColumn && oldColumn.generatedType)
+                        return false;
+                    return !column.generatedType && oldColumn;
+                })
+                    .map((column) => `"${column.name}"`);
+            }
+            else if (oldColumnNames.length > newColumnNames.length) {
+                oldColumnNames = oldTable.columns
+                    .filter((column) => {
+                    return (!column.generatedType &&
+                        newTable.columns.find((c) => c.name === column.name));
+                })
+                    .map((column) => `"${column.name}"`);
+            }
+            upQueries.push(new Query_1.Query(`INSERT INTO ${this.escapePath(newTable.name)}(${newColumnNames.join(", ")}) SELECT ${oldColumnNames.join(", ")} FROM ${this.escapePath(oldTable.name)}`));
+            downQueries.push(new Query_1.Query(`INSERT INTO ${this.escapePath(oldTable.name)}(${oldColumnNames.join(", ")}) SELECT ${newColumnNames.join(", ")} FROM ${this.escapePath(newTable.name)}`));
+        }
+        // drop old table
+        upQueries.push(this.dropTableSql(oldTable));
+        downQueries.push(this.createTableSql(oldTable, true));
+        // rename old table
+        upQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(newTable.name)} RENAME TO ${this.escapePath(tableNameOld)}`));
+        downQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(oldTable.name)} RENAME TO ${this.escapePath(tableNameNew)}`));
+        newTable.name = oldTable.name;
+        // recreate table indices
+        newTable.indices.forEach((index) => {
+            // new index may be passed without name. In this case we generate index name manually.
+            if (!index.name)
+                index.name = this.connection.namingStrategy.indexName(newTable, index.columnNames, index.where);
+            upQueries.push(this.createIndexSql(newTable, index));
+            downQueries.push(this.dropIndexSql(index));
+        });
+        // update generated columns in "typeorm_metadata" table
+        // Step 1: clear data for removed generated columns
+        oldTable.columns
+            .filter((column) => {
+            const newTableColumn = newTable.columns.find((c) => c.name === column.name);
+            // we should delete record from "typeorm_metadata" if generated column was removed
+            // or it was changed to non-generated
+            return (column.generatedType &&
+                column.asExpression &&
+                (!newTableColumn ||
+                    (!newTableColumn.generatedType &&
+                        !newTableColumn.asExpression)));
+        })
+            .forEach((column) => {
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                table: oldTable.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            const insertQuery = this.insertTypeormMetadataSql({
+                table: oldTable.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
             });
+            upQueries.push(deleteQuery);
+            downQueries.push(insertQuery);
         });
-    };
+        // Step 2: add data for new generated columns
+        newTable.columns
+            .filter((column) => column.generatedType &&
+            column.asExpression &&
+            !oldTable.columns.some((c) => c.name === column.name))
+            .forEach((column) => {
+            const insertQuery = this.insertTypeormMetadataSql({
+                table: newTable.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                table: newTable.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            upQueries.push(insertQuery);
+            downQueries.push(deleteQuery);
+        });
+        // Step 3: update changed expressions
+        newTable.columns
+            .filter((column) => column.generatedType && column.asExpression)
+            .forEach((column) => {
+            const oldColumn = oldTable.columns.find((c) => c.name === column.name &&
+                c.generatedType &&
+                column.generatedType &&
+                c.asExpression !== column.asExpression);
+            if (!oldColumn)
+                return;
+            // update expression
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                table: oldTable.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: oldColumn.name,
+            });
+            const insertQuery = this.insertTypeormMetadataSql({
+                table: newTable.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            upQueries.push(deleteQuery);
+            upQueries.push(insertQuery);
+            // revert update
+            const revertInsertQuery = this.insertTypeormMetadataSql({
+                table: newTable.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: oldColumn.name,
+                value: oldColumn.asExpression,
+            });
+            const revertDeleteQuery = this.deleteTypeormMetadataSql({
+                table: oldTable.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            downQueries.push(revertInsertQuery);
+            downQueries.push(revertDeleteQuery);
+        });
+        await this.executeQueries(upQueries, downQueries);
+        this.replaceCachedTable(oldTable, newTable);
+    }
     /**
      * tablePath e.g. "myDB.myTable", "myTable"
      */
-    AbstractSqliteQueryRunner.prototype.splitTablePath = function (tablePath) {
+    splitTablePath(tablePath) {
         return (tablePath.indexOf(".") !== -1
             ? tablePath.split(".")
             : [undefined, tablePath]);
-    };
+    }
     /**
      * Escapes given table or view path. Tolerates leading/trailing dots
      */
-    AbstractSqliteQueryRunner.prototype.escapePath = function (target, disableEscape) {
-        var tableName = InstanceChecker_1.InstanceChecker.isTable(target) || InstanceChecker_1.InstanceChecker.isView(target)
+    escapePath(target, disableEscape) {
+        const tableName = InstanceChecker_1.InstanceChecker.isTable(target) || InstanceChecker_1.InstanceChecker.isView(target)
             ? target.name
             : target;
         return tableName
             .replace(/^\.+|\.+$/g, "")
             .split(".")
-            .map(function (i) { return (disableEscape ? i : "\"".concat(i, "\"")); })
+            .map((i) => (disableEscape ? i : `"${i}"`))
             .join(".");
-    };
-    return AbstractSqliteQueryRunner;
-}(BaseQueryRunner_1.BaseQueryRunner));
+    }
+}
 exports.AbstractSqliteQueryRunner = AbstractSqliteQueryRunner;
 //# sourceMappingURL=AbstractSqliteQueryRunner.js.map