@mikro-orm/sql 7.0.0-dev.174 → 7.0.0-dev.176

package/dialects/postgresql/BasePostgreSqlPlatform.d.ts

@@ -12,6 +12,7 @@ export declare class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     usesCascadeStatement(): boolean;
     supportsNativeEnums(): boolean;
     usesEnumCheckConstraints(): boolean;
+    supportsMaterializedViews(): boolean;
     supportsCustomPrimaryKeyNames(): boolean;
     getCurrentTimestampSQL(length: number): string;
     getDateTimeTypeDeclarationSQL(column: {

package/dialects/postgresql/BasePostgreSqlPlatform.js

@@ -22,6 +22,9 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     usesEnumCheckConstraints() {
         return true;
     }
+    supportsMaterializedViews() {
+        return true;
+    }
     supportsCustomPrimaryKeyNames() {
         return true;
     }

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -19,6 +19,11 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     getListTablesSQL(): string;
     getListViewsSQL(): string;
     loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection): Promise<void>;
+    getListMaterializedViewsSQL(): string;
+    loadMaterializedViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
+    createMaterializedView(name: string, schema: string | undefined, definition: string, withData?: boolean): string;
+    dropMaterializedViewIfExists(name: string, schema?: string): string;
+    refreshMaterializedView(name: string, schema?: string, concurrently?: boolean): string;
     getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
     private getIgnoredNamespacesConditionSQL;
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -44,6 +44,33 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             }
         }
     }
+    getListMaterializedViewsSQL() {
+        return `select matviewname as view_name, schemaname as schema_name, definition as view_definition `
+            + `from pg_matviews `
+            + `where ${this.getIgnoredNamespacesConditionSQL('schemaname')} `
+            + `order by matviewname`;
+    }
+    async loadMaterializedViews(schema, connection, schemaName) {
+        const views = await connection.execute(this.getListMaterializedViewsSQL());
+        for (const view of views) {
+            const definition = view.view_definition?.trim().replace(/;$/, '') ?? '';
+            if (definition) {
+                schema.addView(view.view_name, view.schema_name, definition, true);
+            }
+        }
+    }
+    createMaterializedView(name, schema, definition, withData = true) {
+        const viewName = this.quote(this.getTableName(name, schema));
+        const dataClause = withData ? ' with data' : ' with no data';
+        return `create materialized view ${viewName} as ${definition}${dataClause}`;
+    }
+    dropMaterializedViewIfExists(name, schema) {
+        return `drop materialized view if exists ${this.quote(this.getTableName(name, schema))} cascade`;
+    }
+    refreshMaterializedView(name, schema, concurrently = false) {
+        const concurrent = concurrently ? ' concurrently' : '';
+        return `refresh materialized view${concurrent} ${this.quote(this.getTableName(name, schema))}`;
+    }
     async getNamespaces(connection) {
         const sql = `select schema_name from information_schema.schemata `
             + `where ${this.getIgnoredNamespacesConditionSQL()} `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.174",
+  "version": "7.0.0-dev.176",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "type": "module",
   "exports": {
@@ -56,6 +56,6 @@
     "@mikro-orm/core": "^6.6.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.174"
+    "@mikro-orm/core": "7.0.0-dev.176"
   }
 }

package/query/QueryBuilder.d.ts

@@ -136,7 +136,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     /**
      * @internal
      */
-    constructor(entityName: EntityName<Entity> | QueryBuilder<Entity, any, any>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Transaction | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager | undefined, loggerContext?: (LoggingOptions & Dictionary) | undefined);
+    constructor(entityName: EntityName<Entity> | QueryBuilder<Entity, any, any, any>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Transaction | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager | undefined, loggerContext?: (LoggingOptions & Dictionary) | undefined);
     select(fields: Field<Entity> | Field<Entity>[], distinct?: boolean): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     addSelect(fields: Field<Entity> | Field<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     distinct(): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
@@ -352,7 +352,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     private ensureFromClause;
     private ensureNotFinalized;
 }
-export interface RunQueryBuilder<Entity extends object> extends Omit<QueryBuilder<Entity, any, any>, 'getResult' | 'getSingleResult' | 'getResultList' | 'where'> {
+export interface RunQueryBuilder<Entity extends object> extends Omit<QueryBuilder<Entity, any, any, any>, 'getResult' | 'getSingleResult' | 'getResultList' | 'where'> {
     where(cond: QBFilterQuery<Entity> | string, params?: keyof typeof GroupOperator | any[], operator?: keyof typeof GroupOperator): this;
     execute<Result = QueryResult<Entity>>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<Result>;
 }

package/schema/DatabaseSchema.d.ts

@@ -18,7 +18,7 @@ export declare class DatabaseSchema {
     getTables(): DatabaseTable[];
     getTable(name: string): DatabaseTable | undefined;
     hasTable(name: string): boolean;
-    addView(name: string, schema: string | undefined | null, definition: string): DatabaseView;
+    addView(name: string, schema: string | undefined | null, definition: string, materialized?: boolean, withData?: boolean): DatabaseView;
     getViews(): DatabaseView[];
     getView(name: string): DatabaseView | undefined;
     hasView(name: string): boolean;

package/schema/DatabaseSchema.js

@@ -34,9 +34,9 @@ export class DatabaseSchema {
     hasTable(name) {
         return !!this.getTable(name);
     }
-    addView(name, schema, definition) {
+    addView(name, schema, definition, materialized, withData) {
         const namespaceName = schema ?? this.name;
-        const view = { name, schema: namespaceName, definition };
+        const view = { name, schema: namespaceName, definition, materialized, withData };
         this.views.push(view);
         if (namespaceName != null) {
             this.namespaces.add(namespaceName);
@@ -85,6 +85,10 @@ export class DatabaseSchema {
         await platform.getSchemaHelper().loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined);
         // Load views from database
         await platform.getSchemaHelper().loadViews(schema, connection);
+        // Load materialized views (PostgreSQL only)
+        if (platform.supportsMaterializedViews()) {
+            await platform.getSchemaHelper().loadMaterializedViews(schema, connection, schemaName);
+        }
         return schema;
     }
     static fromMetadata(metadata, platform, config, schemaName, em) {
@@ -124,7 +128,7 @@ export class DatabaseSchema {
             if (meta.view) {
                 const viewDefinition = this.getViewDefinition(meta, em, platform);
                 if (viewDefinition) {
-                    schema.addView(meta.collection, this.getSchemaName(meta, config, schemaName), viewDefinition);
+                    schema.addView(meta.collection, this.getSchemaName(meta, config, schemaName), viewDefinition, meta.materialized, meta.withData);
                 }
                 continue;
             }

package/schema/SchemaHelper.d.ts

@@ -79,4 +79,9 @@ export declare abstract class SchemaHelper {
     dropTableIfExists(name: string, schema?: string): string;
     createView(name: string, schema: string | undefined, definition: string): string;
     dropViewIfExists(name: string, schema?: string): string;
+    createMaterializedView(name: string, schema: string | undefined, definition: string, withData?: boolean): string;
+    dropMaterializedViewIfExists(name: string, schema?: string): string;
+    refreshMaterializedView(name: string, schema?: string, concurrently?: boolean): string;
+    getListMaterializedViewsSQL(): string;
+    loadMaterializedViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
 }

package/schema/SchemaHelper.js

@@ -558,4 +558,19 @@ export class SchemaHelper {
         }
         return sql;
     }
+    createMaterializedView(name, schema, definition, withData = true) {
+        throw new Error('Not supported by given driver');
+    }
+    dropMaterializedViewIfExists(name, schema) {
+        throw new Error('Not supported by given driver');
+    }
+    refreshMaterializedView(name, schema, concurrently = false) {
+        throw new Error('Not supported by given driver');
+    }
+    getListMaterializedViewsSQL() {
+        throw new Error('Not supported by given driver');
+    }
+    async loadMaterializedViews(schema, connection, schemaName) {
+        throw new Error('Not supported by given driver');
+    }
 }

package/schema/SqlSchemaGenerator.js

@@ -91,7 +91,12 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         // Sort views by dependencies (views depending on other views come later)
         const sortedViews = this.sortViewsByDependencies(toSchema.getViews());
         for (const view of sortedViews) {
-            this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
+            if (view.materialized) {
+                this.append(ret, this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true));
+            }
+            else {
+                this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
+            }
         }
         return this.wrapSchema(ret, options);
     }
@@ -141,7 +146,12 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         const targetSchema = this.getTargetSchema(options.schema);
         const sortedViews = this.sortViewsByDependencies(targetSchema.getViews()).reverse();
         for (const view of sortedViews) {
-            this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
+            if (view.materialized) {
+                this.append(ret, this.helper.dropMaterializedViewIfExists(view.name, view.schema));
+            }
+            else {
+                this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
+            }
         }
         // remove FKs explicitly if we can't use a cascading statement and we don't disable FK checks (we need this for circular relations)
         for (const meta of metadata) {
@@ -235,7 +245,12 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         if (options.dropTables && !options.safe) {
             const sortedRemovedViews = this.sortViewsByDependencies(Object.values(schemaDiff.removedViews)).reverse();
             for (const view of sortedRemovedViews) {
-                this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
+                if (view.materialized) {
+                    this.append(ret, this.helper.dropMaterializedViewIfExists(view.name, view.schema));
+                }
+                else {
+                    this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
+                }
             }
         }
         // Drop changed views (they will be recreated after table changes)
@@ -243,7 +258,12 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         const changedViewsFrom = Object.values(schemaDiff.changedViews).map(v => v.from);
         const sortedChangedViewsFrom = this.sortViewsByDependencies(changedViewsFrom).reverse();
         for (const view of sortedChangedViewsFrom) {
-            this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
+            if (view.materialized) {
+                this.append(ret, this.helper.dropMaterializedViewIfExists(view.name, view.schema));
+            }
+            else {
+                this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
+            }
         }
         if (!options.safe && this.options.createForeignKeyConstraints) {
             for (const orphanedForeignKey of schemaDiff.orphanedForeignKeys) {
@@ -304,13 +324,23 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         // Sort views by dependencies (views depending on other views come later)
         const sortedNewViews = this.sortViewsByDependencies(Object.values(schemaDiff.newViews));
         for (const view of sortedNewViews) {
-            this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
+            if (view.materialized) {
+                this.append(ret, this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true));
+            }
+            else {
+                this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
+            }
         }
         // Recreate changed views (also sorted by dependencies)
         const changedViews = Object.values(schemaDiff.changedViews).map(v => v.to);
         const sortedChangedViews = this.sortViewsByDependencies(changedViews);
         for (const view of sortedChangedViews) {
-            this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
+            if (view.materialized) {
+                this.append(ret, this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true));
+            }
+            else {
+                this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
+            }
         }
         return this.wrapSchema(ret, options);
     }