typeorm 0.3.29-dev.cc07c90 → 1.0.0-beta.1

package/browser/schema-builder/RdbmsSchemaBuilder.js

@@ -1,14 +1,18 @@
-import { Table } from "./table/Table";
-import { TableColumn } from "./table/TableColumn";
-import { TableForeignKey } from "./table/TableForeignKey";
-import { TableIndex } from "./table/TableIndex";
-import { TableUtils } from "./util/TableUtils";
-import { TableUnique } from "./table/TableUnique";
-import { TableCheck } from "./table/TableCheck";
-import { TableExclusion } from "./table/TableExclusion";
-import { View } from "./view/View";
-import { ViewUtils } from "./util/ViewUtils";
-import { DriverUtils } from "../driver/DriverUtils";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RdbmsSchemaBuilder = void 0;
+const Table_1 = require("./table/Table");
+const TableColumn_1 = require("./table/TableColumn");
+const TableForeignKey_1 = require("./table/TableForeignKey");
+const TableIndex_1 = require("./table/TableIndex");
+const TableUtils_1 = require("./util/TableUtils");
+const TableUnique_1 = require("./table/TableUnique");
+const TableCheck_1 = require("./table/TableCheck");
+const TableExclusion_1 = require("./table/TableExclusion");
+const View_1 = require("./view/View");
+const ViewUtils_1 = require("./util/ViewUtils");
+const DriverUtils_1 = require("../driver/DriverUtils");
+const error_1 = require("../error");
 /**
  * Creates complete tables schemas in the database based on the entity metadatas.
  *
@@ -23,13 +27,21 @@ import { DriverUtils } from "../driver/DriverUtils";
  * 8. create foreign keys which does not exist in the table yet
  * 9. create indices which are missing in db yet, and drops indices which exist in the db, but does not exist in the metadata anymore
  */
-export class RdbmsSchemaBuilder {
+class RdbmsSchemaBuilder {
     // -------------------------------------------------------------------------
     // Constructor
     // -------------------------------------------------------------------------
-    constructor(connection) {
-        this.connection = connection;
+    constructor(dataSource) {
+        this.dataSource = dataSource;
         this["@instanceof"] = Symbol.for("RdbmsSchemaBuilder");
+        /**
+         * All tables loaded from the database for the current sync operation.
+         */
+        this.tables = [];
+        /**
+         * All views loaded from the database for the current sync operation.
+         */
+        this.views = [];
     }
     // -------------------------------------------------------------------------
     // Public Methods
@@ -38,32 +50,31 @@ export class RdbmsSchemaBuilder {
      * Creates complete schemas for the given entity metadatas.
      */
     async build() {
-        this.queryRunner = this.connection.createQueryRunner();
-        // this.connection.driver.database || this.currentDatabase;
-        this.currentDatabase = this.connection.driver.database;
-        this.currentSchema = this.connection.driver.schema;
+        this.queryRunner = this.dataSource.createQueryRunner();
+        this.currentDatabase = this.dataSource.driver.database;
+        this.currentSchema = this.dataSource.driver.schema;
         // CockroachDB implements asynchronous schema sync operations which can not been executed in transaction.
         // E.g. if you try to DROP column and ADD it again in the same transaction, crdb throws error.
         // In Spanner queries against the INFORMATION_SCHEMA can be used in a read-only transaction,
         // but not in a read-write transaction.
-        const isUsingTransactions = !(this.connection.driver.options.type === "cockroachdb") &&
-            !(this.connection.driver.options.type === "spanner") &&
-            this.connection.options.migrationsTransactionMode !== "none";
+        const isUsingTransactions = !(this.dataSource.driver.options.type === "cockroachdb") &&
+            !(this.dataSource.driver.options.type === "spanner") &&
+            this.dataSource.options.migrationsTransactionMode !== "none";
         await this.queryRunner.beforeMigration();
         if (isUsingTransactions) {
             await this.queryRunner.startTransaction();
         }
         try {
             await this.createMetadataTableIfNecessary(this.queryRunner);
-            // Flush the queryrunner table & view cache
+            // Flush the queryRunner table & view cache
             const tablePaths = this.entityToSyncMetadatas.map((metadata) => this.getTablePath(metadata));
             const viewPaths = this.viewEntityToSyncMetadatas.map((metadata) => this.getTablePath(metadata));
-            await this.queryRunner.getTables(tablePaths);
-            await this.queryRunner.getViews(viewPaths);
+            this.tables = await this.queryRunner.getTables(tablePaths);
+            this.views = await this.queryRunner.getViews(viewPaths);
             await this.executeSchemaSyncOperationsInProperOrder();
             // if cache is enabled then perform cache-synchronization as well
-            if (this.connection.queryResultCache)
-                await this.connection.queryResultCache.synchronize(this.queryRunner);
+            if (this.dataSource.queryResultCache)
+                await this.dataSource.queryResultCache.synchronize(this.queryRunner);
             if (isUsingTransactions) {
                 await this.queryRunner.commitTransaction();
             }
@@ -85,6 +96,7 @@ export class RdbmsSchemaBuilder {
     }
     /**
      * Create the typeorm_metadata table if necessary.
+     * @param queryRunner
      */
     async createMetadataTableIfNecessary(queryRunner) {
         if (this.viewEntityToSyncMetadatas.length > 0 ||
@@ -96,19 +108,18 @@ export class RdbmsSchemaBuilder {
      * Returns sql queries to be executed by schema builder.
      */
     async log() {
-        this.queryRunner = this.connection.createQueryRunner();
+        this.queryRunner = this.dataSource.createQueryRunner();
         try {
-            // Flush the queryrunner table & view cache
             const tablePaths = this.entityToSyncMetadatas.map((metadata) => this.getTablePath(metadata));
             const viewPaths = this.viewEntityToSyncMetadatas.map((metadata) => this.getTablePath(metadata));
-            await this.queryRunner.getTables(tablePaths);
-            await this.queryRunner.getViews(viewPaths);
+            this.tables = await this.queryRunner.getTables(tablePaths);
+            this.views = await this.queryRunner.getViews(viewPaths);
             this.queryRunner.enableSqlMemory();
             await this.executeSchemaSyncOperationsInProperOrder();
             // if cache is enabled then perform cache-synchronization as well
-            if (this.connection.queryResultCache)
+            if (this.dataSource.queryResultCache)
                 // todo: check this functionality
-                await this.connection.queryResultCache.synchronize(this.queryRunner);
+                await this.dataSource.queryResultCache.synchronize(this.queryRunner);
             return this.queryRunner.getMemorySql();
         }
         finally {
@@ -126,7 +137,7 @@ export class RdbmsSchemaBuilder {
      * Returns only entities that should be synced in the database.
      */
     get entityToSyncMetadatas() {
-        return this.connection.entityMetadatas.filter((metadata) => metadata.synchronize &&
+        return this.dataSource.entityMetadatas.filter((metadata) => metadata.synchronize &&
             metadata.tableType !== "entity-child" &&
             metadata.tableType !== "view");
     }
@@ -134,16 +145,16 @@ export class RdbmsSchemaBuilder {
      * Returns only entities that should be synced in the database.
      */
     get viewEntityToSyncMetadatas() {
-        return (this.connection.entityMetadatas
+        return (this.dataSource.entityMetadatas
             .filter((metadata) => metadata.tableType === "view" && metadata.synchronize)
             // sort views in creation order by dependencies
-            .sort(ViewUtils.viewMetadataCmp));
+            .sort(ViewUtils_1.ViewUtils.viewMetadataCmp));
     }
     /**
      * Checks if there are at least one generated column.
      */
     hasGeneratedColumns() {
-        return this.connection.entityMetadatas.some((entityMetadata) => {
+        return this.dataSource.entityMetadatas.some((entityMetadata) => {
             return entityMetadata.columns.some((column) => column.generatedType);
         });
     }
@@ -175,15 +186,15 @@ export class RdbmsSchemaBuilder {
         await this.createNewViewIndices();
     }
     getTablePath(target) {
-        const parsed = this.connection.driver.parseTableName(target);
-        return this.connection.driver.buildTableName(parsed.tableName, parsed.schema || this.currentSchema, parsed.database || this.currentDatabase);
+        const parsed = this.dataSource.driver.parseTableName(target);
+        return this.dataSource.driver.buildTableName(parsed.tableName, parsed.schema || this.currentSchema, parsed.database || this.currentDatabase);
     }
     /**
      * Drops all (old) foreign keys that exist in the tables, but do not exist in the entity metadata.
      */
     async dropOldForeignKeys() {
         for (const metadata of this.entityToSyncMetadatas) {
-            const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const table = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (!table)
                 continue;
             // find foreign keys that exist in the schemas but does not exist in the entity metadata
@@ -199,7 +210,7 @@ export class RdbmsSchemaBuilder {
             });
             if (tableForeignKeysToDrop.length === 0)
                 continue;
-            this.connection.logger.logSchemaBuild(`dropping old foreign keys of ${table.name}: ${tableForeignKeysToDrop
+            this.dataSource.logger.logSchemaBuild(`dropping old foreign keys of ${table.name}: ${tableForeignKeysToDrop
                 .map((dbForeignKey) => dbForeignKey.name)
                 .join(", ")}`);
             // drop foreign keys from the database
@@ -211,7 +222,7 @@ export class RdbmsSchemaBuilder {
      */
     async renameTables() {
         // for (const metadata of this.entityToSyncMetadatas) {
-        //     const table = this.queryRunner.loadedTables.find(table => this.getTablePath(table) === this.getTablePath(metadata));
+        //     const table = this.tables.find(table => this.getTablePath(table) === this.getTablePath(metadata));
         // }
     }
     /**
@@ -221,7 +232,7 @@ export class RdbmsSchemaBuilder {
      */
     async renameColumns() {
         for (const metadata of this.entityToSyncMetadatas) {
-            const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const table = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (!table)
                 continue;
             if (metadata.columns.length !== table.columns.length)
@@ -232,10 +243,10 @@ export class RdbmsSchemaBuilder {
                 return !table.columns.find((tableColumn) => {
                     return (tableColumn.name === column.databaseName &&
                         tableColumn.type ===
-                            this.connection.driver.normalizeType(column) &&
+                            this.dataSource.driver.normalizeType(column) &&
                         tableColumn.isNullable === column.isNullable &&
                         tableColumn.isUnique ===
-                            this.connection.driver.normalizeIsUnique(column));
+                            this.dataSource.driver.normalizeIsUnique(column));
                 });
             });
             if (renamedMetadataColumns.length === 0 ||
@@ -245,10 +256,10 @@ export class RdbmsSchemaBuilder {
                 return !metadata.columns.find((column) => {
                     return (!column.isVirtualProperty &&
                         column.databaseName === tableColumn.name &&
-                        this.connection.driver.normalizeType(column) ===
+                        this.dataSource.driver.normalizeType(column) ===
                             tableColumn.type &&
                         column.isNullable === tableColumn.isNullable &&
-                        this.connection.driver.normalizeIsUnique(column) ===
+                        this.dataSource.driver.normalizeIsUnique(column) ===
                             tableColumn.isUnique);
                 });
             });
@@ -257,70 +268,64 @@ export class RdbmsSchemaBuilder {
                 continue;
             const renamedColumn = renamedTableColumns[0].clone();
             renamedColumn.name = renamedMetadataColumns[0].databaseName;
-            this.connection.logger.logSchemaBuild(`renaming column "${renamedTableColumns[0].name}" in "${table.name}" to "${renamedColumn.name}"`);
+            this.dataSource.logger.logSchemaBuild(`renaming column "${renamedTableColumns[0].name}" in "${table.name}" to "${renamedColumn.name}"`);
             await this.queryRunner.renameColumn(table, renamedTableColumns[0], renamedColumn);
         }
     }
+    shouldDropIndices(indexMetadata, tableIndex) {
+        if (indexMetadata) {
+            if (indexMetadata.synchronize === false)
+                return false;
+            if (indexMetadata.isUnique !== tableIndex.isUnique)
+                return true;
+            if (indexMetadata.isSpatial !== tableIndex.isSpatial)
+                return true;
+            if (!!this.dataSource.driver.supportedIndexTypes &&
+                typeof this.dataSource.driver.compareTableIndexTypes ===
+                    "function" &&
+                !this.dataSource.driver.compareTableIndexTypes(indexMetadata, tableIndex))
+                return true;
+            if (!this.dataSource.driver.supportedIndexTypes &&
+                indexMetadata.type)
+                throw new error_1.TypeORMError(`Current database driver does not support index 'type' property`);
+            if (this.dataSource.driver.isFullTextColumnTypeSupported() &&
+                indexMetadata.isFulltext !== tableIndex.isFulltext)
+                return true;
+            if (indexMetadata.columns.length !== tableIndex.columnNames.length)
+                return true;
+            return !indexMetadata.columns.every((column) => tableIndex.columnNames.indexOf(column.databaseName) !== -1);
+        }
+        return true;
+    }
     async dropOldIndices() {
         for (const metadata of this.entityToSyncMetadatas) {
-            const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const table = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (!table)
                 continue;
             const dropQueries = table.indices
                 .filter((tableIndex) => {
                 const indexMetadata = metadata.indices.find((index) => index.name === tableIndex.name);
-                if (indexMetadata) {
-                    if (indexMetadata.synchronize === false)
-                        return false;
-                    if (indexMetadata.isUnique !== tableIndex.isUnique)
-                        return true;
-                    if (indexMetadata.isSpatial !== tableIndex.isSpatial)
-                        return true;
-                    if (this.connection.driver.isFullTextColumnTypeSupported() &&
-                        indexMetadata.isFulltext !== tableIndex.isFulltext)
-                        return true;
-                    if (indexMetadata.columns.length !==
-                        tableIndex.columnNames.length)
-                        return true;
-                    return !indexMetadata.columns.every((column) => tableIndex.columnNames.indexOf(column.databaseName) !== -1);
-                }
-                return true;
+                return this.shouldDropIndices(indexMetadata, tableIndex);
             })
                 .map(async (tableIndex) => {
-                this.connection.logger.logSchemaBuild(`dropping an index: "${tableIndex.name}" from table ${table.name}`);
+                this.dataSource.logger.logSchemaBuild(`dropping an index: "${tableIndex.name}" from table ${table.name}`);
                 await this.queryRunner.dropIndex(table, tableIndex);
             });
             await Promise.all(dropQueries);
         }
-        if (this.connection.options.type === "postgres") {
+        if (this.dataSource.options.type === "postgres") {
             const postgresQueryRunner = this.queryRunner;
             for (const metadata of this.viewEntityToSyncMetadatas) {
-                const view = this.queryRunner.loadedViews.find((view) => this.getTablePath(view) === this.getTablePath(metadata));
+                const view = this.views.find((view) => this.getTablePath(view) === this.getTablePath(metadata));
                 if (!view)
                     continue;
                 const dropQueries = view.indices
                     .filter((tableIndex) => {
                     const indexMetadata = metadata.indices.find((index) => index.name === tableIndex.name);
-                    if (indexMetadata) {
-                        if (indexMetadata.synchronize === false)
-                            return false;
-                        if (indexMetadata.isUnique !== tableIndex.isUnique)
-                            return true;
-                        if (indexMetadata.isSpatial !== tableIndex.isSpatial)
-                            return true;
-                        if (this.connection.driver.isFullTextColumnTypeSupported() &&
-                            indexMetadata.isFulltext !==
-                                tableIndex.isFulltext)
-                            return true;
-                        if (indexMetadata.columns.length !==
-                            tableIndex.columnNames.length)
-                            return true;
-                        return !indexMetadata.columns.every((column) => tableIndex.columnNames.indexOf(column.databaseName) !== -1);
-                    }
-                    return true;
+                    return this.shouldDropIndices(indexMetadata, tableIndex);
                 })
                     .map(async (tableIndex) => {
-                    this.connection.logger.logSchemaBuild(`dropping an index: "${tableIndex.name}" from view ${view.name}`);
+                    this.dataSource.logger.logSchemaBuild(`dropping an index: "${tableIndex.name}" from view ${view.name}`);
                     await postgresQueryRunner.dropViewIndex(view, tableIndex);
                 });
                 await Promise.all(dropQueries);
@@ -329,11 +334,11 @@ export class RdbmsSchemaBuilder {
     }
     async dropOldChecks() {
         // Mysql does not support check constraints
-        if (DriverUtils.isMySQLFamily(this.connection.driver) ||
-            this.connection.driver.options.type === "aurora-mysql")
+        if (DriverUtils_1.DriverUtils.isMySQLFamily(this.dataSource.driver) ||
+            this.dataSource.driver.options.type === "aurora-mysql")
             return;
         for (const metadata of this.entityToSyncMetadatas) {
-            const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const table = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (!table)
                 continue;
             const oldChecks = table.checks.filter((tableCheck) => {
@@ -341,7 +346,7 @@ export class RdbmsSchemaBuilder {
             });
             if (oldChecks.length === 0)
                 continue;
-            this.connection.logger.logSchemaBuild(`dropping old check constraint: ${oldChecks
+            this.dataSource.logger.logSchemaBuild(`dropping old check constraint: ${oldChecks
                 .map((check) => `"${check.name}"`)
                 .join(", ")} from table "${table.name}"`);
             await this.queryRunner.dropCheckConstraints(table, oldChecks);
@@ -349,7 +354,7 @@ export class RdbmsSchemaBuilder {
     }
     async dropCompositeUniqueConstraints() {
         for (const metadata of this.entityToSyncMetadatas) {
-            const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const table = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (!table)
                 continue;
             const compositeUniques = table.uniques.filter((tableUnique) => {
@@ -358,7 +363,7 @@ export class RdbmsSchemaBuilder {
             });
             if (compositeUniques.length === 0)
                 continue;
-            this.connection.logger.logSchemaBuild(`dropping old unique constraint: ${compositeUniques
+            this.dataSource.logger.logSchemaBuild(`dropping old unique constraint: ${compositeUniques
                 .map((unique) => `"${unique.name}"`)
                 .join(", ")} from table "${table.name}"`);
             await this.queryRunner.dropUniqueConstraints(table, compositeUniques);
@@ -366,10 +371,10 @@ export class RdbmsSchemaBuilder {
     }
     async dropOldExclusions() {
         // Only PostgreSQL supports exclusion constraints
-        if (!(this.connection.driver.options.type === "postgres"))
+        if (!(this.dataSource.driver.options.type === "postgres"))
             return;
         for (const metadata of this.entityToSyncMetadatas) {
-            const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const table = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (!table)
                 continue;
             const oldExclusions = table.exclusions.filter((tableExclusion) => {
@@ -377,7 +382,7 @@ export class RdbmsSchemaBuilder {
             });
             if (oldExclusions.length === 0)
                 continue;
-            this.connection.logger.logSchemaBuild(`dropping old exclusion constraint: ${oldExclusions
+            this.dataSource.logger.logSchemaBuild(`dropping old exclusion constraint: ${oldExclusions
                 .map((exclusion) => `"${exclusion.name}"`)
                 .join(", ")} from table "${table.name}"`);
             await this.queryRunner.dropExclusionConstraints(table, oldExclusions);
@@ -388,11 +393,12 @@ export class RdbmsSchemaBuilder {
      */
     async changeTableComment() {
         for (const metadata of this.entityToSyncMetadatas) {
-            const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const table = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (!table)
                 continue;
-            if (DriverUtils.isMySQLFamily(this.connection.driver) ||
-                this.connection.driver.options.type === "postgres") {
+            if (DriverUtils_1.DriverUtils.isMySQLFamily(this.dataSource.driver) ||
+                this.dataSource.driver.options.type === "postgres" ||
+                this.dataSource.driver.options.type === "sap") {
                 const newComment = metadata.comment;
                 await this.queryRunner.changeTableComment(table, newComment);
             }
@@ -406,36 +412,36 @@ export class RdbmsSchemaBuilder {
     async createNewTables() {
         for (const metadata of this.entityToSyncMetadatas) {
             // check if table does not exist yet
-            const existTable = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const existTable = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (existTable)
                 continue;
-            this.connection.logger.logSchemaBuild(`creating a new table: ${this.getTablePath(metadata)}`);
+            this.dataSource.logger.logSchemaBuild(`creating a new table: ${this.getTablePath(metadata)}`);
             // create a new table and sync it in the database
-            const table = Table.create(metadata, this.connection.driver);
+            const table = Table_1.Table.create(metadata, this.dataSource.driver);
             await this.queryRunner.createTable(table, false, false);
-            this.queryRunner.loadedTables.push(table);
+            this.tables.push(table);
         }
     }
     async createViews() {
         for (const metadata of this.viewEntityToSyncMetadatas) {
             // check if view does not exist yet
-            const existView = this.queryRunner.loadedViews.find((view) => {
+            const existView = this.views.find((view) => {
                 const viewExpression = typeof view.expression === "string"
                     ? view.expression.trim()
-                    : view.expression(this.connection).getQuery();
+                    : view.expression(this.dataSource).getQuery();
                 const metadataExpression = typeof metadata.expression === "string"
                     ? metadata.expression.trim()
-                    : metadata.expression(this.connection).getQuery();
+                    : metadata.expression(this.dataSource).getQuery();
                 return (this.getTablePath(view) === this.getTablePath(metadata) &&
                     viewExpression === metadataExpression);
             });
             if (existView)
                 continue;
-            this.connection.logger.logSchemaBuild(`creating a new view: ${this.getTablePath(metadata)}`);
+            this.dataSource.logger.logSchemaBuild(`creating a new view: ${this.getTablePath(metadata)}`);
             // create a new view and sync it in the database
-            const view = View.create(metadata, this.connection.driver);
+            const view = View_1.View.create(metadata, this.dataSource.driver);
             await this.queryRunner.createView(view, true);
-            this.queryRunner.loadedViews.push(view);
+            this.views.push(view);
         }
     }
     async dropOldViews() {
@@ -443,7 +449,7 @@ export class RdbmsSchemaBuilder {
         const viewEntityToSyncMetadatas = this.viewEntityToSyncMetadatas;
         // BuIld lookup cache for finding views metadata
         const viewToMetadata = new Map();
-        for (const view of this.queryRunner.loadedViews) {
+        for (const view of this.views) {
             const viewMetadata = viewEntityToSyncMetadatas.find((metadata) => {
                 return this.getTablePath(view) === this.getTablePath(metadata);
             });
@@ -452,20 +458,20 @@ export class RdbmsSchemaBuilder {
             }
         }
         // Gather all changed view, that need a drop
-        for (const view of this.queryRunner.loadedViews) {
+        for (const view of this.views) {
             const viewMetadata = viewToMetadata.get(view);
             if (!viewMetadata) {
                 continue;
             }
             const viewExpression = typeof view.expression === "string"
                 ? view.expression.trim()
-                : view.expression(this.connection).getQuery();
+                : view.expression(this.dataSource).getQuery();
             const metadataExpression = typeof viewMetadata.expression === "string"
                 ? viewMetadata.expression.trim()
-                : viewMetadata.expression(this.connection).getQuery();
+                : viewMetadata.expression(this.dataSource).getQuery();
             if (viewExpression === metadataExpression)
                 continue;
-            this.connection.logger.logSchemaBuild(`dropping an old view: ${view.name}`);
+            this.dataSource.logger.logSchemaBuild(`dropping an old view: ${view.name}`);
             // Collect view to be dropped
             droppedViews.push(view);
         }
@@ -506,7 +512,7 @@ export class RdbmsSchemaBuilder {
         }, [])
             // Sort the views to be dropped in creation order
             .sort((a, b) => {
-            return ViewUtils.viewMetadataCmp(viewToMetadata.get(a), viewToMetadata.get(b));
+            return ViewUtils_1.ViewUtils.viewMetadataCmp(viewToMetadata.get(a), viewToMetadata.get(b));
         })
             // reverse order to get drop order
             .reverse());
@@ -514,7 +520,7 @@ export class RdbmsSchemaBuilder {
         for (const view of droppedViewsWithDependencies) {
             await this.queryRunner.dropView(view);
         }
-        this.queryRunner.loadedViews = this.queryRunner.loadedViews.filter((view) => !droppedViewsWithDependencies.has(view));
+        this.views = this.views.filter((view) => !droppedViewsWithDependencies.has(view));
     }
     /**
      * Drops all columns that exist in the table, but does not exist in the metadata (left old).
@@ -522,17 +528,17 @@ export class RdbmsSchemaBuilder {
      */
     async dropRemovedColumns() {
         for (const metadata of this.entityToSyncMetadatas) {
-            const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const table = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (!table)
                 continue;
             // find columns that exist in the database but does not exist in the metadata
             const droppedTableColumns = table.columns.filter((tableColumn) => {
-                return !metadata.columns.find((columnMetadata) => columnMetadata.isVirtualProperty ||
+                return !metadata.columns.find((columnMetadata) => !columnMetadata.isVirtualProperty &&
                     columnMetadata.databaseName === tableColumn.name);
             });
             if (droppedTableColumns.length === 0)
                 continue;
-            this.connection.logger.logSchemaBuild(`columns dropped in ${table.name}: ` +
+            this.dataSource.logger.logSchemaBuild(`columns dropped in ${table.name}: ` +
                 droppedTableColumns.map((column) => column.name).join(", "));
             // drop columns from the database
             await this.queryRunner.dropColumns(table, droppedTableColumns);
@@ -544,7 +550,7 @@ export class RdbmsSchemaBuilder {
      */
     async addNewColumns() {
         for (const metadata of this.entityToSyncMetadatas) {
-            const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const table = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (!table)
                 continue;
             // find which columns are new
@@ -557,10 +563,10 @@ export class RdbmsSchemaBuilder {
                 continue;
             // create columns in the database
             const newTableColumnOptions = this.metadataColumnsToTableColumnOptions(newColumnMetadatas);
-            const newTableColumns = newTableColumnOptions.map((option) => new TableColumn(option));
+            const newTableColumns = newTableColumnOptions.map((option) => new TableColumn_1.TableColumn(option));
             if (newTableColumns.length === 0)
                 continue;
-            this.connection.logger.logSchemaBuild(`new columns added: ` +
+            this.dataSource.logger.logSchemaBuild(`new columns added: ` +
                 newColumnMetadatas
                     .map((column) => column.databaseName)
                     .join(", "));
@@ -572,7 +578,7 @@ export class RdbmsSchemaBuilder {
      */
     async updatePrimaryKeys() {
         for (const metadata of this.entityToSyncMetadatas) {
-            const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const table = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (!table)
                 continue;
             const primaryMetadataColumns = metadata.columns.filter((column) => column.isPrimary);
@@ -580,7 +586,7 @@ export class RdbmsSchemaBuilder {
             if (primaryTableColumns.length !== primaryMetadataColumns.length &&
                 primaryMetadataColumns.length > 1) {
                 const changedPrimaryColumns = primaryMetadataColumns.map((primaryMetadataColumn) => {
-                    return new TableColumn(TableUtils.createTableColumnOptions(primaryMetadataColumn, this.connection.driver));
+                    return new TableColumn_1.TableColumn(TableUtils_1.TableUtils.createTableColumnOptions(primaryMetadataColumn, this.dataSource.driver));
                 });
                 await this.queryRunner.updatePrimaryKeys(table, changedPrimaryColumns);
             }
@@ -592,10 +598,10 @@ export class RdbmsSchemaBuilder {
      */
     async updateExistColumns() {
         for (const metadata of this.entityToSyncMetadatas) {
-            const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const table = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (!table)
                 continue;
-            const changedColumns = this.connection.driver.findChangedColumns(table.columns, metadata.columns);
+            const changedColumns = this.dataSource.driver.findChangedColumns(table.columns, metadata.columns);
             if (changedColumns.length === 0)
                 continue;
             // drop all foreign keys that point to this column
@@ -608,9 +614,9 @@ export class RdbmsSchemaBuilder {
             }
             // drop all composite uniques related to this column
             // Mysql does not support unique constraints.
-            if (!(DriverUtils.isMySQLFamily(this.connection.driver) ||
-                this.connection.driver.options.type === "aurora-mysql" ||
-                this.connection.driver.options.type === "spanner")) {
+            if (!(DriverUtils_1.DriverUtils.isMySQLFamily(this.dataSource.driver) ||
+                this.dataSource.driver.options.type === "aurora-mysql" ||
+                this.dataSource.driver.options.type === "spanner")) {
                 for (const changedColumn of changedColumns) {
                     await this.dropColumnCompositeUniques(this.getTablePath(metadata), changedColumn.databaseName);
                 }
@@ -618,8 +624,8 @@ export class RdbmsSchemaBuilder {
             // generate a map of new/old columns
             const newAndOldTableColumns = changedColumns.map((changedColumn) => {
                 const oldTableColumn = table.columns.find((column) => column.name === changedColumn.databaseName);
-                const newTableColumnOptions = TableUtils.createTableColumnOptions(changedColumn, this.connection.driver);
-                const newTableColumn = new TableColumn(newTableColumnOptions);
+                const newTableColumnOptions = TableUtils_1.TableUtils.createTableColumnOptions(changedColumn, this.dataSource.driver);
+                const newTableColumn = new TableColumn_1.TableColumn(newTableColumnOptions);
                 return {
                     oldColumn: oldTableColumn,
                     newColumn: newTableColumn,
@@ -627,7 +633,7 @@ export class RdbmsSchemaBuilder {
             });
             if (newAndOldTableColumns.length === 0)
                 continue;
-            this.connection.logger.logSchemaBuild(`columns changed in "${table.name}". updating: ` +
+            this.dataSource.logger.logSchemaBuild(`columns changed in "${table.name}". updating: ` +
                 changedColumns
                     .map((column) => column.databaseName)
                     .join(", "));
@@ -639,15 +645,19 @@ export class RdbmsSchemaBuilder {
      */
     async createNewIndices() {
         for (const metadata of this.entityToSyncMetadatas) {
-            const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const table = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (!table)
                 continue;
             const newIndices = metadata.indices
                 .filter((indexMetadata) => !table.indices.find((tableIndex) => tableIndex.name === indexMetadata.name) && indexMetadata.synchronize === true)
-                .map((indexMetadata) => TableIndex.create(indexMetadata));
+                .map((indexMetadata) => TableIndex_1.TableIndex.create(indexMetadata));
             if (newIndices.length === 0)
                 continue;
-            this.connection.logger.logSchemaBuild(`adding new indices ${newIndices
+            if (newIndices.find((idx) => !!idx.type &&
+                !this.dataSource.driver.supportedIndexTypes)) {
+                throw new error_1.TypeORMError(`Current database driver does not support index 'type' property`);
+            }
+            this.dataSource.logger.logSchemaBuild(`adding new indices ${newIndices
                 .map((index) => `"${index.name}"`)
                 .join(", ")} in table "${table.name}"`);
             await this.queryRunner.createIndices(table, newIndices);
@@ -658,20 +668,20 @@ export class RdbmsSchemaBuilder {
      */
     async createNewViewIndices() {
         // Only PostgreSQL supports indices for materialized views.
-        if (this.connection.options.type !== "postgres" ||
-            !DriverUtils.isPostgresFamily(this.connection.driver)) {
+        if (this.dataSource.options.type !== "postgres" ||
+            !DriverUtils_1.DriverUtils.isPostgresFamily(this.dataSource.driver)) {
             return;
         }
         const postgresQueryRunner = (this.queryRunner);
         for (const metadata of this.viewEntityToSyncMetadatas) {
             // check if view does not exist yet
-            const view = this.queryRunner.loadedViews.find((view) => {
+            const view = this.views.find((view) => {
                 const viewExpression = typeof view.expression === "string"
                     ? view.expression.trim()
-                    : view.expression(this.connection).getQuery();
+                    : view.expression(this.dataSource).getQuery();
                 const metadataExpression = typeof metadata.expression === "string"
                     ? metadata.expression.trim()
-                    : metadata.expression(this.connection).getQuery();
+                    : metadata.expression(this.dataSource).getQuery();
                 return (this.getTablePath(view) === this.getTablePath(metadata) &&
                     viewExpression === metadataExpression);
             });
@@ -679,10 +689,14 @@ export class RdbmsSchemaBuilder {
                 continue;
             const newIndices = metadata.indices
                 .filter((indexMetadata) => !view.indices.find((tableIndex) => tableIndex.name === indexMetadata.name) && indexMetadata.synchronize === true)
-                .map((indexMetadata) => TableIndex.create(indexMetadata));
+                .map((indexMetadata) => TableIndex_1.TableIndex.create(indexMetadata));
             if (newIndices.length === 0)
                 continue;
-            this.connection.logger.logSchemaBuild(`adding new indices ${newIndices
+            if (newIndices.find((idx) => !!idx.type &&
+                !this.dataSource.driver.supportedIndexTypes)) {
+                throw new error_1.TypeORMError(`Current database driver does not support index 'type' property`);
+            }
+            this.dataSource.logger.logSchemaBuild(`adding new indices ${newIndices
                 .map((index) => `"${index.name}"`)
                 .join(", ")} in view "${view.name}"`);
             await postgresQueryRunner.createViewIndices(view, newIndices);
@@ -690,19 +704,19 @@ export class RdbmsSchemaBuilder {
     }
     async createNewChecks() {
         // Mysql does not support check constraints
-        if (DriverUtils.isMySQLFamily(this.connection.driver) ||
-            this.connection.driver.options.type === "aurora-mysql")
+        if (DriverUtils_1.DriverUtils.isMySQLFamily(this.dataSource.driver) ||
+            this.dataSource.driver.options.type === "aurora-mysql")
             return;
         for (const metadata of this.entityToSyncMetadatas) {
-            const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const table = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (!table)
                 continue;
             const newChecks = metadata.checks
                 .filter((checkMetadata) => !table.checks.find((tableCheck) => tableCheck.name === checkMetadata.name))
-                .map((checkMetadata) => TableCheck.create(checkMetadata));
+                .map((checkMetadata) => TableCheck_1.TableCheck.create(checkMetadata));
             if (newChecks.length === 0)
                 continue;
-            this.connection.logger.logSchemaBuild(`adding new check constraints: ${newChecks
+            this.dataSource.logger.logSchemaBuild(`adding new check constraints: ${newChecks
                 .map((index) => `"${index.name}"`)
                 .join(", ")} in table "${table.name}"`);
             await this.queryRunner.createCheckConstraints(table, newChecks);
@@ -713,16 +727,16 @@ export class RdbmsSchemaBuilder {
      */
     async createCompositeUniqueConstraints() {
         for (const metadata of this.entityToSyncMetadatas) {
-            const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const table = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (!table)
                 continue;
             const compositeUniques = metadata.uniques
                 .filter((uniqueMetadata) => uniqueMetadata.columns.length > 1 &&
                 !table.uniques.find((tableUnique) => tableUnique.name === uniqueMetadata.name))
-                .map((uniqueMetadata) => TableUnique.create(uniqueMetadata));
+                .map((uniqueMetadata) => TableUnique_1.TableUnique.create(uniqueMetadata));
             if (compositeUniques.length === 0)
                 continue;
-            this.connection.logger.logSchemaBuild(`adding new unique constraints: ${compositeUniques
+            this.dataSource.logger.logSchemaBuild(`adding new unique constraints: ${compositeUniques
                 .map((unique) => `"${unique.name}"`)
                 .join(", ")} in table "${table.name}"`);
             await this.queryRunner.createUniqueConstraints(table, compositeUniques);
@@ -733,18 +747,18 @@ export class RdbmsSchemaBuilder {
      */
     async createNewExclusions() {
         // Only PostgreSQL supports exclusion constraints
-        if (!(this.connection.driver.options.type === "postgres"))
+        if (!(this.dataSource.driver.options.type === "postgres"))
             return;
         for (const metadata of this.entityToSyncMetadatas) {
-            const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const table = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (!table)
                 continue;
             const newExclusions = metadata.exclusions
                 .filter((exclusionMetadata) => !table.exclusions.find((tableExclusion) => tableExclusion.name === exclusionMetadata.name))
-                .map((exclusionMetadata) => TableExclusion.create(exclusionMetadata));
+                .map((exclusionMetadata) => TableExclusion_1.TableExclusion.create(exclusionMetadata));
             if (newExclusions.length === 0)
                 continue;
-            this.connection.logger.logSchemaBuild(`adding new exclusion constraints: ${newExclusions
+            this.dataSource.logger.logSchemaBuild(`adding new exclusion constraints: ${newExclusions
                 .map((exclusion) => `"${exclusion.name}"`)
                 .join(", ")} in table "${table.name}"`);
             await this.queryRunner.createExclusionConstraints(table, newExclusions);
@@ -755,7 +769,7 @@ export class RdbmsSchemaBuilder {
      */
     async createForeignKeys() {
         for (const metadata of this.entityToSyncMetadatas) {
-            const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
+            const table = this.tables.find((table) => this.getTablePath(table) === this.getTablePath(metadata));
             if (!table)
                 continue;
             const newKeys = metadata.foreignKeys.filter((foreignKey) => {
@@ -765,8 +779,8 @@ export class RdbmsSchemaBuilder {
             });
             if (newKeys.length === 0)
                 continue;
-            const dbForeignKeys = newKeys.map((foreignKeyMetadata) => TableForeignKey.create(foreignKeyMetadata, this.connection.driver));
-            this.connection.logger.logSchemaBuild(`creating a foreign keys: ${newKeys
+            const dbForeignKeys = newKeys.map((foreignKeyMetadata) => TableForeignKey_1.TableForeignKey.create(foreignKeyMetadata, this.dataSource.driver));
+            this.dataSource.logger.logSchemaBuild(`creating a foreign keys: ${newKeys
                 .map((key) => key.name)
                 .join(", ")} on table "${table.name}"`);
             await this.queryRunner.createForeignKeys(table, dbForeignKeys);
@@ -774,9 +788,11 @@ export class RdbmsSchemaBuilder {
     }
     /**
      * Drops all foreign keys where given column of the given table is being used.
+     * @param tablePath
+     * @param columnName
      */
     async dropColumnReferencedForeignKeys(tablePath, columnName) {
-        const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === tablePath);
+        const table = this.tables.find((table) => this.getTablePath(table) === tablePath);
         if (!table)
             return;
         const tablesWithFK = [];
@@ -787,7 +803,7 @@ export class RdbmsSchemaBuilder {
             tablesWithFK.push(clonedTable);
             table.removeForeignKey(columnForeignKey);
         }
-        for (const loadedTable of this.queryRunner.loadedTables) {
+        for (const loadedTable of this.tables) {
             const dependForeignKeys = loadedTable.foreignKeys.filter((foreignKey) => {
                 return (this.getTablePath(foreignKey) === tablePath &&
                     foreignKey.referencedColumnNames.indexOf(columnName) !==
@@ -802,7 +818,7 @@ export class RdbmsSchemaBuilder {
         }
         if (tablesWithFK.length > 0) {
             for (const tableWithFK of tablesWithFK) {
-                this.connection.logger.logSchemaBuild(`dropping related foreign keys of ${tableWithFK.name}: ${tableWithFK.foreignKeys
+                this.dataSource.logger.logSchemaBuild(`dropping related foreign keys of ${tableWithFK.name}: ${tableWithFK.foreignKeys
                     .map((foreignKey) => foreignKey.name)
                     .join(", ")}`);
                 await this.queryRunner.dropForeignKeys(tableWithFK, tableWithFK.foreignKeys);
@@ -811,62 +827,68 @@ export class RdbmsSchemaBuilder {
     }
     /**
      * Drops all composite indices, related to given column.
+     * @param tablePath
+     * @param columnName
      */
     async dropColumnCompositeIndices(tablePath, columnName) {
-        const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === tablePath);
+        const table = this.tables.find((table) => this.getTablePath(table) === tablePath);
         if (!table)
             return;
         const relatedIndices = table.indices.filter((index) => index.columnNames.length > 1 &&
             index.columnNames.indexOf(columnName) !== -1);
         if (relatedIndices.length === 0)
             return;
-        this.connection.logger.logSchemaBuild(`dropping related indices of "${tablePath}"."${columnName}": ${relatedIndices
+        this.dataSource.logger.logSchemaBuild(`dropping related indices of "${tablePath}"."${columnName}": ${relatedIndices
             .map((index) => index.name)
             .join(", ")}`);
         await this.queryRunner.dropIndices(table, relatedIndices);
     }
     /**
      * Drops all composite uniques, related to given column.
+     * @param tablePath
+     * @param columnName
      */
     async dropColumnCompositeUniques(tablePath, columnName) {
-        const table = this.queryRunner.loadedTables.find((table) => this.getTablePath(table) === tablePath);
+        const table = this.tables.find((table) => this.getTablePath(table) === tablePath);
         if (!table)
             return;
         const relatedUniques = table.uniques.filter((unique) => unique.columnNames.length > 1 &&
             unique.columnNames.indexOf(columnName) !== -1);
         if (relatedUniques.length === 0)
             return;
-        this.connection.logger.logSchemaBuild(`dropping related unique constraints of "${tablePath}"."${columnName}": ${relatedUniques
+        this.dataSource.logger.logSchemaBuild(`dropping related unique constraints of "${tablePath}"."${columnName}": ${relatedUniques
             .map((unique) => unique.name)
             .join(", ")}`);
         await this.queryRunner.dropUniqueConstraints(table, relatedUniques);
     }
     /**
      * Creates new columns from the given column metadatas.
+     * @param columns
      */
     metadataColumnsToTableColumnOptions(columns) {
-        return columns.map((columnMetadata) => TableUtils.createTableColumnOptions(columnMetadata, this.connection.driver));
+        return columns.map((columnMetadata) => TableUtils_1.TableUtils.createTableColumnOptions(columnMetadata, this.dataSource.driver));
     }
     /**
      * Creates typeorm service table for storing user defined Views and generate columns.
+     * @param queryRunner
      */
     async createTypeormMetadataTable(queryRunner) {
         const schema = this.currentSchema;
         const database = this.currentDatabase;
-        const typeormMetadataTable = this.connection.driver.buildTableName(this.connection.metadataTableName, schema, database);
+        const typeormMetadataTable = this.dataSource.driver.buildTableName(this.dataSource.metadataTableName, schema, database);
         // Spanner requires at least one primary key in a table.
         // Since we don't have unique column in "typeorm_metadata" table
         // and we should avoid breaking changes, we mark all columns as primary for Spanner driver.
-        const isPrimary = this.connection.driver.options.type === "spanner";
-        await queryRunner.createTable(new Table({
+        const isPrimary = this.dataSource.driver.options.type === "spanner";
+        await queryRunner.createTable(new Table_1.Table({
             database: database,
             schema: schema,
             name: typeormMetadataTable,
             columns: [
                 {
                     name: "type",
-                    type: this.connection.driver.normalizeType({
-                        type: this.connection.driver.mappedDataTypes
+                    type: this.dataSource.driver.normalizeType({
+                        type: this.dataSource.driver.mappedDataTypes
                             .metadataType,
                     }),
                     isNullable: false,
@@ -874,8 +896,8 @@ export class RdbmsSchemaBuilder {
                 },
                 {
                     name: "database",
-                    type: this.connection.driver.normalizeType({
-                        type: this.connection.driver.mappedDataTypes
+                    type: this.dataSource.driver.normalizeType({
+                        type: this.dataSource.driver.mappedDataTypes
                             .metadataDatabase,
                     }),
                     isNullable: true,
@@ -883,8 +905,8 @@ export class RdbmsSchemaBuilder {
                 },
                 {
                     name: "schema",
-                    type: this.connection.driver.normalizeType({
-                        type: this.connection.driver.mappedDataTypes
+                    type: this.dataSource.driver.normalizeType({
+                        type: this.dataSource.driver.mappedDataTypes
                             .metadataSchema,
                     }),
                     isNullable: true,
@@ -892,8 +914,8 @@ export class RdbmsSchemaBuilder {
                 },
                 {
                     name: "table",
-                    type: this.connection.driver.normalizeType({
-                        type: this.connection.driver.mappedDataTypes
+                    type: this.dataSource.driver.normalizeType({
+                        type: this.dataSource.driver.mappedDataTypes
                             .metadataTable,
                     }),
                     isNullable: true,
@@ -901,8 +923,8 @@ export class RdbmsSchemaBuilder {
                 },
                 {
                     name: "name",
-                    type: this.connection.driver.normalizeType({
-                        type: this.connection.driver.mappedDataTypes
+                    type: this.dataSource.driver.normalizeType({
+                        type: this.dataSource.driver.mappedDataTypes
                             .metadataName,
                     }),
                     isNullable: true,
@@ -910,8 +932,8 @@ export class RdbmsSchemaBuilder {
                 },
                 {
                     name: "value",
-                    type: this.connection.driver.normalizeType({
-                        type: this.connection.driver.mappedDataTypes
+                    type: this.dataSource.driver.normalizeType({
+                        type: this.dataSource.driver.mappedDataTypes
                             .metadataValue,
                     }),
                     isNullable: true,
@@ -921,5 +943,5 @@ export class RdbmsSchemaBuilder {
         }), true);
     }
 }
-
-//# sourceMappingURL=RdbmsSchemaBuilder.js.map
+exports.RdbmsSchemaBuilder = RdbmsSchemaBuilder;
+//# sourceMappingURL=RdbmsSchemaBuilder.js.map