@mikro-orm/sql 7.0.7-dev.1 → 7.0.7-dev.11

package/AbstractSqlPlatform.d.ts

@@ -36,6 +36,8 @@ export declare abstract class AbstractSqlPlatform extends Platform {
     quoteJsonKey(key: string): string;
     getJsonIndexDefinition(index: IndexDef): string[];
     supportsUnionWhere(): boolean;
+    /** Whether the platform supports `count(distinct col1, col2)` with multiple columns. If false, a subquery wrapper is used instead. */
+    supportsMultiColumnCountDistinct(): boolean;
     supportsSchemas(): boolean;
     /** @inheritDoc */
     generateCustomOrder(escapedColumn: string, values: unknown[]): string;

package/AbstractSqlPlatform.js

@@ -91,6 +91,10 @@ export class AbstractSqlPlatform extends Platform {
     supportsUnionWhere() {
         return true;
     }
+    /** Whether the platform supports `count(distinct col1, col2)` with multiple columns. If false, a subquery wrapper is used instead. */
+    supportsMultiColumnCountDistinct() {
+        return false;
+    }
     supportsSchemas() {
         return false;
     }

package/dialects/mssql/MsSqlNativeQueryBuilder.js

@@ -137,13 +137,18 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
         this.parts[this.parts.length - 1] += ';';
     }
     compileSelect() {
+        const wrapCountSubquery = this.needsCountSubquery();
+        if (wrapCountSubquery) {
+            this.parts.push(`select count(*) as ${this.quote('count')} from (`);
+        }
         this.parts.push('select');
-        if (this.options.limit != null && this.options.offset == null) {
+        // skip top(?) inside the count subquery — it would limit the distinct rows before counting
+        if (this.options.limit != null && this.options.offset == null && !wrapCountSubquery) {
             this.parts.push(`top (?)`);
             this.params.push(this.options.limit);
         }
         this.addHintComment();
-        this.parts.push(`${this.getFields()} from ${this.getTableName()}`);
+        this.parts.push(`${this.getFields(wrapCountSubquery)} from ${this.getTableName()}`);
         this.addLockClause();
         if (this.options.joins) {
             for (const join of this.options.joins) {
@@ -163,21 +168,27 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
             this.parts.push(`having ${this.options.having.sql}`);
             this.params.push(...this.options.having.params);
         }
-        if (this.options.orderBy) {
-            this.parts.push(`order by ${this.options.orderBy}`);
-        }
-        if (this.options.offset != null) {
-            /* v8 ignore next */
-            if (!this.options.orderBy) {
-                throw new Error('Order by clause is required for pagination');
+        if (!wrapCountSubquery) {
+            if (this.options.orderBy) {
+                this.parts.push(`order by ${this.options.orderBy}`);
             }
-            this.parts.push(`offset ? rows`);
-            this.params.push(this.options.offset);
-            if (this.options.limit != null) {
-                this.parts.push(`fetch next ? rows only`);
-                this.params.push(this.options.limit);
+            if (this.options.offset != null) {
+                /* v8 ignore next */
+                if (!this.options.orderBy) {
+                    throw new Error('Order by clause is required for pagination');
+                }
+                this.parts.push(`offset ? rows`);
+                this.params.push(this.options.offset);
+                if (this.options.limit != null) {
+                    this.parts.push(`fetch next ? rows only`);
+                    this.params.push(this.options.limit);
+                }
             }
         }
+        if (wrapCountSubquery) {
+            const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+            this.parts.push(`)${asKeyword}${this.quote('dcnt')}`);
+        }
     }
     addLockClause() {
         if (!this.options.lockMode ||

package/dialects/mysql/BaseMySqlPlatform.d.ts

@@ -14,6 +14,7 @@ export declare class BaseMySqlPlatform extends AbstractSqlPlatform {
         readonly "desc nulls first": "is not null";
         readonly "desc nulls last": "is null";
     };
+    supportsMultiColumnCountDistinct(): boolean;
     /** @internal */
     createNativeQueryBuilder(): MySqlNativeQueryBuilder;
     getDefaultCharset(): string;

package/dialects/mysql/BaseMySqlPlatform.js

@@ -18,6 +18,9 @@ export class BaseMySqlPlatform extends AbstractSqlPlatform {
         [QueryOrder.desc_nulls_first]: 'is not null',
         [QueryOrder.desc_nulls_last]: 'is null',
     };
+    supportsMultiColumnCountDistinct() {
+        return true;
+    }
     /** @internal */
     createNativeQueryBuilder() {
         return new MySqlNativeQueryBuilder(this);

package/dialects/oracledb/OracleNativeQueryBuilder.js

@@ -213,9 +213,13 @@ export class OracleNativeQueryBuilder extends NativeQueryBuilder {
         }
     }
     compileSelect() {
+        const wrapCountSubquery = this.needsCountSubquery();
+        if (wrapCountSubquery) {
+            this.parts.push(`select count(*) as ${this.quote('count')} from (`);
+        }
         this.parts.push('select');
         this.addHintComment();
-        this.parts.push(`${this.getFields()} from ${this.getTableName()}`);
+        this.parts.push(`${this.getFields(wrapCountSubquery)} from ${this.getTableName()}`);
         if (this.options.joins) {
             for (const join of this.options.joins) {
                 this.parts.push(join.sql);
@@ -234,16 +238,22 @@ export class OracleNativeQueryBuilder extends NativeQueryBuilder {
             this.parts.push(`having ${this.options.having.sql}`);
             this.params.push(...this.options.having.params);
         }
-        if (this.options.orderBy) {
-            this.parts.push(`order by ${this.options.orderBy}`);
-        }
-        if (this.options.offset != null) {
-            this.parts.push(`offset ? rows`);
-            this.params.push(this.options.offset);
+        if (!wrapCountSubquery) {
+            if (this.options.orderBy) {
+                this.parts.push(`order by ${this.options.orderBy}`);
+            }
+            if (this.options.offset != null) {
+                this.parts.push(`offset ? rows`);
+                this.params.push(this.options.offset);
+            }
+            if (this.options.limit != null) {
+                this.parts.push(`fetch next ? rows only`);
+                this.params.push(this.options.limit);
+            }
         }
-        if (this.options.limit != null) {
-            this.parts.push(`fetch next ? rows only`);
-            this.params.push(this.options.limit);
+        if (wrapCountSubquery) {
+            const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+            this.parts.push(`)${asKeyword}${this.quote('dcnt')}`);
         }
     }
 }

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -51,17 +51,26 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         }
     }
     getListMaterializedViewsSQL() {
-        return (`select matviewname as view_name, schemaname as schema_name, definition as view_definition ` +
+        return (`select matviewname as view_name, schemaname as schema_name, definition as view_definition, ispopulated as is_populated ` +
             `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 (views.length === 0) {
+            return;
+        }
+        const tables = views.map(v => ({ table_name: v.view_name, schema_name: v.schema_name }));
+        const indexes = await this.getAllIndexes(connection, tables);
+        for (let i = 0; i < views.length; i++) {
+            const definition = views[i].view_definition?.trim().replace(/;$/, '') ?? '';
             if (definition) {
-                schema.addView(view.view_name, view.schema_name, definition, true);
+                const dbView = schema.addView(views[i].view_name, views[i].schema_name, definition, true, views[i].is_populated);
+                const key = this.getTableKey(tables[i]);
+                if (indexes[key]?.length) {
+                    dbView.indexes = indexes[key];
+                }
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.7-dev.1",
+  "version": "7.0.7-dev.11",
   "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.",
   "keywords": [
     "data-mapper",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.0.6"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.7-dev.1"
+    "@mikro-orm/core": "7.0.7-dev.11"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/NativeQueryBuilder.d.ts

@@ -121,7 +121,9 @@ export declare class NativeQueryBuilder implements Subquery {
     as(alias: string): this;
     toRaw(): RawQueryFragment;
     protected compileSelect(): void;
-    protected getFields(): string;
+    /** Whether this COUNT query needs a subquery wrapper for multi-column distinct. */
+    protected needsCountSubquery(): boolean;
+    protected getFields(countSubquery?: boolean): string;
     protected compileInsert(): void;
     protected addOutputClause(type: 'inserted' | 'deleted'): void;
     protected processInsertData(): string[];

package/query/NativeQueryBuilder.js

@@ -281,9 +281,13 @@ export class NativeQueryBuilder {
         return raw(sql, params);
     }
     compileSelect() {
+        const wrapCountSubquery = this.needsCountSubquery();
+        if (wrapCountSubquery) {
+            this.parts.push(`select count(*) as ${this.quote('count')} from (`);
+        }
         this.parts.push('select');
         this.addHintComment();
-        this.parts.push(`${this.getFields()} from ${this.getTableName()}`);
+        this.parts.push(`${this.getFields(wrapCountSubquery)} from ${this.getTableName()}`);
         if (this.options.joins) {
             for (const join of this.options.joins) {
                 this.parts.push(join.sql);
@@ -302,23 +306,40 @@ export class NativeQueryBuilder {
             this.parts.push(`having ${this.options.having.sql}`);
             this.params.push(...this.options.having.params);
         }
-        if (this.options.orderBy) {
-            this.parts.push(`order by ${this.options.orderBy}`);
-        }
-        if (this.options.limit != null) {
-            this.parts.push(`limit ?`);
-            this.params.push(this.options.limit);
+        if (!wrapCountSubquery) {
+            if (this.options.orderBy) {
+                this.parts.push(`order by ${this.options.orderBy}`);
+            }
+            if (this.options.limit != null) {
+                this.parts.push(`limit ?`);
+                this.params.push(this.options.limit);
+            }
+            if (this.options.offset != null) {
+                this.parts.push(`offset ?`);
+                this.params.push(this.options.offset);
+            }
         }
-        if (this.options.offset != null) {
-            this.parts.push(`offset ?`);
-            this.params.push(this.options.offset);
+        if (wrapCountSubquery) {
+            const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+            this.parts.push(`)${asKeyword}${this.quote('dcnt')}`);
         }
     }
-    getFields() {
+    /** Whether this COUNT query needs a subquery wrapper for multi-column distinct. */
+    needsCountSubquery() {
+        return (this.type === QueryType.COUNT &&
+            !!this.options.distinct &&
+            this.options.select.length > 1 &&
+            !this.platform.supportsMultiColumnCountDistinct());
+    }
+    getFields(countSubquery) {
         if (!this.options.select || this.options.select.length === 0) {
             throw new Error('No fields selected');
         }
         let fields = this.options.select.map(field => this.quote(field)).join(', ');
+        // count subquery emits just `distinct col1, col2` — the outer wrapper adds count(*)
+        if (countSubquery) {
+            return `distinct ${fields}`;
+        }
         if (this.options.distinct) {
             fields = `distinct ${fields}`;
         }

package/schema/DatabaseSchema.js

@@ -147,7 +147,27 @@ 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, meta.materialized, meta.withData);
+                    const view = schema.addView(meta.collection, this.getSchemaName(meta, config, schemaName), viewDefinition, meta.materialized, meta.withData);
+                    if (meta.materialized) {
+                        // Use a DatabaseTable to resolve property names → field names for indexes.
+                        // addIndex only needs meta + table name, not actual columns.
+                        const indexTable = new DatabaseTable(platform, meta.collection, this.getSchemaName(meta, config, schemaName));
+                        meta.indexes.forEach(index => indexTable.addIndex(meta, index, 'index'));
+                        meta.uniques.forEach(index => indexTable.addIndex(meta, index, 'unique'));
+                        const pkProps = meta.props.filter(prop => prop.primary);
+                        indexTable.addIndex(meta, { properties: pkProps.map(prop => prop.name) }, 'primary');
+                        // Materialized views don't have primary keys or constraints in the DB,
+                        // convert to match what PostgreSQL stores.
+                        view.indexes = indexTable.getIndexes().map(idx => {
+                            if (idx.primary) {
+                                return { ...idx, primary: false, unique: true, constraint: false };
+                            }
+                            if (idx.constraint) {
+                                return { ...idx, constraint: false };
+                            }
+                            return idx;
+                        });
+                    }
                 }
                 continue;
             }

package/schema/SchemaComparator.d.ts

@@ -1,7 +1,7 @@
 import { type Dictionary } from '@mikro-orm/core';
 import type { Column, ForeignKey, IndexDef, SchemaDifference, TableDifference } from '../typings.js';
 import type { DatabaseSchema } from './DatabaseSchema.js';
-import type { DatabaseTable } from './DatabaseTable.js';
+import { DatabaseTable } from './DatabaseTable.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /**
  * Compares two Schemas and return an instance of SchemaDifference.

package/schema/SchemaComparator.js

@@ -1,4 +1,5 @@
 import { ArrayType, BooleanType, DateTimeType, inspect, JsonType, parseJsonSafe, Utils, } from '@mikro-orm/core';
+import { DatabaseTable } from './DatabaseTable.js';
 /**
  * Compares two Schemas and return an instance of SchemaDifference.
  */
@@ -114,15 +115,16 @@ export class SchemaComparator {
                 }
             }
         }
-        // Compare views
+        // Compare views — prefer schema-qualified lookup to avoid matching
+        // views with the same name in different schemas
         for (const toView of toSchema.getViews()) {
             const viewName = toView.schema ? `${toView.schema}.${toView.name}` : toView.name;
-            if (!fromSchema.hasView(toView.name) && !fromSchema.hasView(viewName)) {
+            if (!fromSchema.hasView(viewName) && !fromSchema.hasView(toView.name)) {
                 diff.newViews[viewName] = toView;
                 this.log(`view ${viewName} added`);
             }
             else {
-                const fromView = fromSchema.getView(toView.name) ?? fromSchema.getView(viewName);
+                const fromView = fromSchema.getView(viewName) ?? fromSchema.getView(toView.name);
                 if (fromView && this.diffViewExpression(fromView.definition, toView.definition)) {
                     diff.changedViews[viewName] = { from: fromView, to: toView };
                     this.log(`view ${viewName} changed`);
@@ -132,11 +134,34 @@ export class SchemaComparator {
         // Check for removed views
         for (const fromView of fromSchema.getViews()) {
             const viewName = fromView.schema ? `${fromView.schema}.${fromView.name}` : fromView.name;
-            if (!toSchema.hasView(fromView.name) && !toSchema.hasView(viewName)) {
+            if (!toSchema.hasView(viewName) && !toSchema.hasView(fromView.name)) {
                 diff.removedViews[viewName] = fromView;
                 this.log(`view ${viewName} removed`);
             }
         }
+        // Diff materialized view indexes using the existing table diff infrastructure.
+        // Build transient DatabaseTable objects from view indexes so diffTable handles
+        // added/removed/changed/renamed index detection and alterTable emits correct DDL.
+        for (const toView of toSchema.getViews()) {
+            if (!toView.materialized || toView.withData === false) {
+                continue;
+            }
+            const viewName = toView.schema ? `${toView.schema}.${toView.name}` : toView.name;
+            // New or definition-changed views have indexes handled during create/recreate
+            if (diff.newViews[viewName] || diff.changedViews[viewName]) {
+                continue;
+            }
+            // If we get here, the view exists in fromSchema (otherwise it would be in diff.newViews)
+            const fromView = fromSchema.getView(viewName) ?? fromSchema.getView(toView.name);
+            const fromTable = new DatabaseTable(this.#platform, fromView.name, fromView.schema);
+            fromTable.init([], fromView.indexes ?? [], [], []);
+            const toTable = new DatabaseTable(this.#platform, toView.name, toView.schema);
+            toTable.init([], toView.indexes ?? [], [], []);
+            const tableDiff = this.diffTable(fromTable, toTable);
+            if (tableDiff) {
+                diff.changedTables[viewName] = tableDiff;
+            }
+        }
         return diff;
     }
     /**

package/schema/SchemaHelper.d.ts

@@ -84,7 +84,8 @@ export declare abstract class SchemaHelper {
     getReferencedTableName(referencedTableName: string, schema?: string): string;
     createIndex(index: IndexDef, table: DatabaseTable, createPrimary?: boolean): string;
     createCheck(table: DatabaseTable, check: CheckDef): string;
-    protected getTableName(table: string, schema?: string): string;
+    /** @internal */
+    getTableName(table: string, schema?: string): string;
     getTablesGroupedBySchemas(tables: Table[]): Map<string | undefined, Table[]>;
     get options(): NonNullable<Options['schemaGenerator']>;
     protected processComment(comment: string): string;

package/schema/SchemaHelper.js

@@ -593,6 +593,7 @@ export class SchemaHelper {
     createCheck(table, check) {
         return `alter table ${table.getQuotedName()} add constraint ${this.quote(check.name)} check (${check.expression})`;
     }
+    /** @internal */
     getTableName(table, schema) {
         if (schema && schema !== this.platform.getDefaultSchemaName()) {
             return `${schema}.${table}`;

package/schema/SqlSchemaGenerator.d.ts

@@ -62,6 +62,7 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
      * Uses topological sort based on view definition string matching.
      */
     private sortViewsByDependencies;
+    private appendViewCreation;
     private escapeRegExp;
 }
 export { SqlSchemaGenerator as SchemaGenerator };

package/schema/SqlSchemaGenerator.js

@@ -89,16 +89,9 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 this.append(ret, fks, true);
             }
         }
-        // Create views after tables (views may depend on tables)
-        // Sort views by dependencies (views depending on other views come later)
         const sortedViews = this.sortViewsByDependencies(toSchema.getViews());
         for (const view of sortedViews) {
-            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);
-            }
+            this.appendViewCreation(ret, view);
         }
         return this.wrapSchema(ret, options);
     }
@@ -338,27 +331,14 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 this.append(ret, sql);
             }
         }
-        // Create new views after all table changes are done
-        // Sort views by dependencies (views depending on other views come later)
         const sortedNewViews = this.sortViewsByDependencies(Object.values(schemaDiff.newViews));
         for (const view of sortedNewViews) {
-            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);
-            }
+            this.appendViewCreation(ret, view);
         }
-        // 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) {
-            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);
-            }
+            this.appendViewCreation(ret, view);
         }
         return this.wrapSchema(ret, options);
     }
@@ -511,6 +491,22 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         // Sort and map back to views
         return calc.sort().map(index => indexToView.get(index));
     }
+    appendViewCreation(ret, view) {
+        if (view.materialized) {
+            this.append(ret, this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true));
+            // Skip indexes for WITH NO DATA views — they have no data to index yet.
+            // Indexes will be created on the next schema:update after REFRESH populates data.
+            if (view.withData !== false) {
+                const viewName = this.helper.getTableName(view.name, view.schema);
+                for (const index of view.indexes ?? []) {
+                    this.append(ret, this.helper.getCreateIndexSQL(viewName, index));
+                }
+            }
+        }
+        else {
+            this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
+        }
+    }
     escapeRegExp(string) {
         return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     }

package/typings.d.ts

@@ -142,6 +142,8 @@ export interface DatabaseView {
     materialized?: boolean;
     /** For materialized views, whether data was populated on creation. */
     withData?: boolean;
+    /** Indexes on the materialized view. Only materialized views support indexes. */
+    indexes?: IndexDef[];
 }
 export interface SchemaDifference {
     newNamespaces: Set<string>;