typeorm 0.3.11-dev.66acec8 → 0.3.11-dev.6ba48bd

package/browser/driver/postgres/PostgresQueryRunner.js

@@ -1448,6 +1448,9 @@ export class PostgresQueryRunner extends BaseQueryRunner {
             : table.foreignKeys.find((fk) => fk.name === foreignKeyOrName);
         if (!foreignKey)
             throw new TypeORMError(`Supplied foreign key was not found in table ${table.name}`);
+        if (!foreignKey.name) {
+            foreignKey.name = this.connection.namingStrategy.foreignKeyName(table, foreignKey.columnNames, this.getTablePath(foreignKey), foreignKey.referencedColumnNames);
+        }
         const up = this.dropForeignKeySql(table, foreignKey);
         const down = this.createForeignKeySql(table, foreignKey);
         await this.executeQueries(up, down);
@@ -1476,6 +1479,21 @@ export class PostgresQueryRunner extends BaseQueryRunner {
         await this.executeQueries(up, down);
         table.addIndex(index);
     }
+    /**
+     * Create a new view index.
+     */
+    async createViewIndex(viewOrName, index) {
+        const view = InstanceChecker.isView(viewOrName)
+            ? viewOrName
+            : await this.getCachedView(viewOrName);
+        // new index may be passed without name. In this case we generate index name manually.
+        if (!index.name)
+            index.name = this.generateIndexName(view, index);
+        const up = this.createViewIndexSql(view, index);
+        const down = this.dropIndexSql(view, index);
+        await this.executeQueries(up, down);
+        view.addIndex(index);
+    }
     /**
      * Creates a new indices
      */
@@ -1484,6 +1502,14 @@ export class PostgresQueryRunner extends BaseQueryRunner {
             await this.createIndex(tableOrName, index);
         }
     }
+    /**
+     * Creates new view indices
+     */
+    async createViewIndices(viewOrName, indices) {
+        for (const index of indices) {
+            await this.createViewIndex(viewOrName, index);
+        }
+    }
     /**
      * Drops an index from the table.
      */
@@ -1504,6 +1530,26 @@ export class PostgresQueryRunner extends BaseQueryRunner {
         await this.executeQueries(up, down);
         table.removeIndex(index);
     }
+    /**
+     * Drops an index from a view.
+     */
+    async dropViewIndex(viewOrName, indexOrName) {
+        const view = InstanceChecker.isView(viewOrName)
+            ? viewOrName
+            : await this.getCachedView(viewOrName);
+        const index = InstanceChecker.isTableIndex(indexOrName)
+            ? indexOrName
+            : view.indices.find((i) => i.name === indexOrName);
+        if (!index)
+            throw new TypeORMError(`Supplied index ${indexOrName} was not found in view ${view.name}`);
+        // old index may be passed without name. In this case we generate index name manually.
+        if (!index.name)
+            index.name = this.generateIndexName(view, index);
+        const up = this.dropIndexSql(view, index);
+        const down = this.createViewIndexSql(view, index);
+        await this.executeQueries(up, down);
+        view.removeIndex(index);
+    }
     /**
      * Drops an indices from the table.
      */
@@ -1602,12 +1648,41 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                 return `("t"."schema" = '${schema}' AND "t"."name" = '${tableName}')`;
             })
                 .join(" OR ");
+        const constraintsCondition = viewNames.length === 0
+            ? "1=1"
+            : viewNames
+                .map((tableName) => this.driver.parseTableName(tableName))
+                .map(({ schema, tableName }) => {
+                if (!schema) {
+                    schema =
+                        this.driver.options.schema || currentSchema;
+                }
+                return `("ns"."nspname" = '${schema}' AND "t"."relname" = '${tableName}')`;
+            })
+                .join(" OR ");
+        const indicesSql = `SELECT "ns"."nspname" AS "table_schema", "t"."relname" AS "table_name", "i"."relname" AS "constraint_name", "a"."attname" AS "column_name", ` +
+            `CASE "ix"."indisunique" WHEN 't' THEN 'TRUE' ELSE'FALSE' END AS "is_unique", pg_get_expr("ix"."indpred", "ix"."indrelid") AS "condition", ` +
+            `"types"."typname" AS "type_name" ` +
+            `FROM "pg_class" "t" ` +
+            `INNER JOIN "pg_index" "ix" ON "ix"."indrelid" = "t"."oid" ` +
+            `INNER JOIN "pg_attribute" "a" ON "a"."attrelid" = "t"."oid"  AND "a"."attnum" = ANY ("ix"."indkey") ` +
+            `INNER JOIN "pg_namespace" "ns" ON "ns"."oid" = "t"."relnamespace" ` +
+            `INNER JOIN "pg_class" "i" ON "i"."oid" = "ix"."indexrelid" ` +
+            `INNER JOIN "pg_type" "types" ON "types"."oid" = "a"."atttypid" ` +
+            `LEFT JOIN "pg_constraint" "cnst" ON "cnst"."conname" = "i"."relname" ` +
+            `WHERE "t"."relkind" IN ('m') AND "cnst"."contype" IS NULL AND (${constraintsCondition})`;
         const query = `SELECT "t".* FROM ${this.escapePath(this.getTypeormMetadataTableName())} "t" ` +
             `INNER JOIN "pg_catalog"."pg_class" "c" ON "c"."relname" = "t"."name" ` +
             `INNER JOIN "pg_namespace" "n" ON "n"."oid" = "c"."relnamespace" AND "n"."nspname" = "t"."schema" ` +
             `WHERE "t"."type" IN ('${MetadataTableType.VIEW}', '${MetadataTableType.MATERIALIZED_VIEW}') ${viewsCondition ? `AND (${viewsCondition})` : ""}`;
         const dbViews = await this.query(query);
+        const dbIndices = await this.query(indicesSql);
         return dbViews.map((dbView) => {
+            // find index constraints of table, group them by constraint name and build TableIndex.
+            const tableIndexConstraints = OrmUtils.uniq(dbIndices.filter((dbIndex) => {
+                return (dbIndex["table_name"] === dbView["name"] &&
+                    dbIndex["table_schema"] === dbView["schema"]);
+            }), (dbIndex) => dbIndex["constraint_name"]);
             const view = new View();
             const schema = dbView["schema"] === currentSchema &&
                 !this.driver.options.schema
@@ -1619,6 +1694,22 @@ export class PostgresQueryRunner extends BaseQueryRunner {
             view.expression = dbView["value"];
             view.materialized =
                 dbView["type"] === MetadataTableType.MATERIALIZED_VIEW;
+            view.indices = tableIndexConstraints.map((constraint) => {
+                const indices = dbIndices.filter((index) => {
+                    return (index["table_schema"] === constraint["table_schema"] &&
+                        index["table_name"] === constraint["table_name"] &&
+                        index["constraint_name"] ===
+                            constraint["constraint_name"]);
+                });
+                return new TableIndex({
+                    view: view,
+                    name: constraint["constraint_name"],
+                    columnNames: indices.map((i) => i["column_name"]),
+                    isUnique: constraint["is_unique"] === "TRUE",
+                    where: constraint["condition"],
+                    isFulltext: false,
+                });
+            });
             return view;
         });
     }
@@ -2315,6 +2406,15 @@ export class PostgresQueryRunner extends BaseQueryRunner {
             .join(", ");
         return new Query(`CREATE ${index.isUnique ? "UNIQUE " : ""}INDEX "${index.name}" ON ${this.escapePath(table)} ${index.isSpatial ? "USING GiST " : ""}(${columns}) ${index.where ? "WHERE " + index.where : ""}`);
     }
+    /**
+     * Builds create view index sql.
+     */
+    createViewIndexSql(view, index) {
+        const columns = index.columnNames
+            .map((columnName) => `"${columnName}"`)
+            .join(", ");
+        return new Query(`CREATE ${index.isUnique ? "UNIQUE " : ""}INDEX "${index.name}" ON ${this.escapePath(view)} (${columns}) ${index.where ? "WHERE " + index.where : ""}`);
+    }
     /**
      * Builds drop index sql.
      */