@mikro-orm/sql 7.1.0-dev.5 → 7.1.0-dev.50

package/dialects/mysql/MySqlSchemaHelper.js

@@ -7,12 +7,34 @@ export class MySqlSchemaHelper extends SchemaHelper {
         'current_timestamp(?)': ['current_timestamp(?)'],
         '0': ['0', 'false'],
     };
+    // Greedy `(.+)` so nested CASE expressions inside the predicate don't trip the match on
+    // an inner `then <col> end` — the trailing `$` anchor forces the regex engine to extend
+    // the capture to the outermost case-end boundary.
+    static PARTIAL_INDEX_RE = /^\s*\(\s*case\s+when\s+(.+)\s+then\s+`([^`]+)`\s+end\s*\)\s*$/is;
     getSchemaBeginning(charset, disableForeignKeys) {
         if (disableForeignKeys) {
             return `set names ${charset};\n${this.disableForeignKeysSQL()}\n\n`;
         }
         return `set names ${charset};\n\n`;
     }
+    getSetSchemaSQL(schema) {
+        return `use ${this.quote(schema)}`;
+    }
+    getResetSchemaSQL(defaultSchema) {
+        return `use ${this.quote(defaultSchema)}`;
+    }
+    supportsMigrationSchema() {
+        return true;
+    }
+    async tableExists(connection, tableName, schemaName, ctx) {
+        // MySQL "schema" = database — when none is requested, probe the connection's current DB
+        // via `schema()` rather than the base impl's `getDefaultSchemaName()` (which is undefined here).
+        const schemaClause = schemaName
+            ? `table_schema = ${this.platform.quoteValue(schemaName)}`
+            : `table_schema = schema()`;
+        const rows = await connection.execute(`select 1 from information_schema.tables where ${schemaClause} and table_name = ${this.platform.quoteValue(tableName)}`, [], 'all', ctx);
+        return rows.length > 0;
+    }
     disableForeignKeysSQL() {
         return 'set foreign_key_checks = 0;';
     }
@@ -31,7 +53,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
         return sql;
     }
     getListTablesSQL() {
-        return `select table_name as table_name, nullif(table_schema, schema()) as schema_name, table_comment as table_comment from information_schema.tables where table_type = 'BASE TABLE' and table_schema = schema()`;
+        return `select table_name as table_name, nullif(table_schema, schema()) as schema_name, table_comment as table_comment, table_collation as table_collation from information_schema.tables where table_type = 'BASE TABLE' and table_schema = schema()`;
     }
     getListViewsSQL() {
         return `select table_name as view_name, nullif(table_schema, schema()) as schema_name, view_definition from information_schema.views where table_schema = schema()`;
@@ -64,11 +86,16 @@ export class MySqlSchemaHelper extends SchemaHelper {
         const checks = await this.getAllChecks(connection, tables, ctx);
         const fks = await this.getAllForeignKeys(connection, tables, ctx);
         const enums = await this.getAllEnumDefinitions(connection, tables, ctx);
+        const triggers = await this.getAllTriggers(connection, tables);
         for (const t of tables) {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
+            table.collation = t.table_collation ?? undefined;
             const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
             table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums[key]);
+            if (triggers[key]) {
+                table.setTriggers(triggers[key]);
+            }
         }
     }
     async getAllIndexes(connection, tables, ctx) {
@@ -80,8 +107,11 @@ export class MySqlSchemaHelper extends SchemaHelper {
         const ret = {};
         for (const index of allIndexes) {
             const key = this.getTableKey(index);
+            const partialMatch = !index.column_name && typeof index.expression === 'string'
+                ? MySqlSchemaHelper.PARTIAL_INDEX_RE.exec(index.expression)
+                : null;
             const indexDef = {
-                columnNames: [index.column_name],
+                columnNames: [partialMatch ? partialMatch[2] : index.column_name],
                 keyName: index.index_name,
                 unique: !index.non_unique,
                 primary: index.index_name === 'PRIMARY',
@@ -109,7 +139,10 @@ export class MySqlSchemaHelper extends SchemaHelper {
             if (index.is_visible === 'NO') {
                 indexDef.invisible = true;
             }
-            if (!index.column_name || index.expression?.match(/ where /i)) {
+            if (partialMatch) {
+                indexDef.where = partialMatch[1].trim();
+            }
+            else if (!index.column_name || index.expression?.match(/ where /i)) {
                 indexDef.expression = index.expression; // required for the `getCreateIndexSQL()` call
                 indexDef.expression = this.getCreateIndexSQL(index.table_name, indexDef, !!index.expression);
             }
@@ -146,40 +179,43 @@ export class MySqlSchemaHelper extends SchemaHelper {
         return this.appendMySqlIndexSuffix(sql, index);
     }
     /**
-     * Build the column list for a MySQL index, with MySQL-specific handling for collation.
-     * MySQL requires collation to be specified as an expression: (column_name COLLATE collation_name)
+     * Build the column list for a MySQL index. MySQL requires collation via an expression:
+     * `(column COLLATE collation_name)`. Partial indexes (`where`) are emulated via functional
+     * indexes — requires MySQL 8.0.13+. MariaDB does not support inline functional indexes
+     * and overrides to throw at a higher level.
      */
     getIndexColumns(index) {
-        if (index.columns?.length) {
-            return index.columns
-                .map(col => {
-                const quotedName = this.quote(col.name);
-                // MySQL supports collation via expression: (column_name COLLATE collation_name)
-                // When collation is specified, wrap in parentheses as an expression
-                if (col.collation) {
-                    let expr = col.length ? `${quotedName}(${col.length})` : quotedName;
-                    expr = `(${expr} collate ${col.collation})`;
-                    // Sort order comes after the expression
-                    if (col.sort) {
-                        expr += ` ${col.sort}`;
-                    }
-                    return expr;
-                }
-                // Standard column definition without collation
-                let colDef = quotedName;
-                // MySQL supports prefix length
-                if (col.length) {
-                    colDef += `(${col.length})`;
-                }
-                // MySQL supports sort order
+        if (index.where) {
+            return this.emulatePartialIndexColumns(index);
+        }
+        return index.columnNames
+            .map(name => {
+            const col = index.columns?.find(c => c.name === name);
+            const quotedName = this.quote(name);
+            // MySQL supports collation via expression: (column_name COLLATE collation_name)
+            // When collation is specified, wrap in parentheses as an expression
+            if (col?.collation) {
+                let expr = col.length ? `${quotedName}(${col.length})` : quotedName;
+                expr = `(${expr} collate ${col.collation})`;
+                // Sort order comes after the expression
                 if (col.sort) {
-                    colDef += ` ${col.sort}`;
+                    expr += ` ${col.sort}`;
                 }
-                return colDef;
-            })
-                .join(', ');
-        }
-        return index.columnNames.map(c => this.quote(c)).join(', ');
+                return expr;
+            }
+            // Standard column definition without collation
+            let colDef = quotedName;
+            // MySQL supports prefix length
+            if (col?.length) {
+                colDef += `(${col.length})`;
+            }
+            // MySQL supports sort order
+            if (col?.sort) {
+                colDef += ` ${col.sort}`;
+            }
+            return colDef;
+        })
+            .join(', ');
     }
     /**
      * Append MySQL-specific index suffixes like INVISIBLE.
@@ -192,22 +228,25 @@ export class MySqlSchemaHelper extends SchemaHelper {
         return sql;
     }
     async getAllColumns(connection, tables, ctx) {
-        const sql = `select table_name as table_name,
-      nullif(table_schema, schema()) as schema_name,
-      column_name as column_name,
-      column_default as column_default,
-      nullif(column_comment, '') as column_comment,
-      is_nullable as is_nullable,
-      data_type as data_type,
-      column_type as column_type,
-      column_key as column_key,
-      extra as extra,
-      generation_expression as generation_expression,
-      numeric_precision as numeric_precision,
-      numeric_scale as numeric_scale,
-      ifnull(datetime_precision, character_maximum_length) length
-      from information_schema.columns where table_schema = database() and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name))})
-      order by ordinal_position`;
+        const sql = `select c.table_name as table_name,
+      nullif(c.table_schema, schema()) as schema_name,
+      c.column_name as column_name,
+      c.column_default as column_default,
+      nullif(c.column_comment, '') as column_comment,
+      c.is_nullable as is_nullable,
+      c.data_type as data_type,
+      c.column_type as column_type,
+      c.column_key as column_key,
+      c.extra as extra,
+      c.generation_expression as generation_expression,
+      c.numeric_precision as numeric_precision,
+      c.numeric_scale as numeric_scale,
+      ifnull(c.datetime_precision, c.character_maximum_length) length,
+      nullif(c.collation_name, t.table_collation) as collation_name
+      from information_schema.columns c
+      join information_schema.tables t on t.table_schema = c.table_schema and t.table_name = c.table_name
+      where c.table_schema = database() and c.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name))})
+      order by c.ordinal_position`;
         const allColumns = await connection.execute(sql, [], 'all', ctx);
         const str = (val) => (val != null ? '' + val : val);
         const extra = (val) => val.replace(/auto_increment|default_generated|(stored|virtual) generated/i, '').trim() || undefined;
@@ -238,6 +277,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
                 precision: col.numeric_precision,
                 scale: col.numeric_scale,
                 comment: col.column_comment,
+                collation: col.collation_name ?? undefined,
                 extra: extra(col.extra),
                 generated,
             });
@@ -264,6 +304,194 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
+    /** Generates SQL to create MySQL triggers. MySQL requires one trigger per event. */
+    createTrigger(table, trigger) {
+        if (trigger.expression) {
+            return trigger.expression;
+        }
+        /* v8 ignore next 3 */
+        if (trigger.timing === 'instead of') {
+            throw new Error(`MySQL does not support INSTEAD OF triggers. Use BEFORE or AFTER for trigger "${trigger.name}".`);
+        }
+        /* v8 ignore next 5 */
+        if (trigger.forEach === 'statement') {
+            throw new Error(`MySQL does not support FOR EACH STATEMENT triggers. Use FOR EACH ROW for trigger "${trigger.name}".`);
+        }
+        const timing = trigger.timing.toUpperCase();
+        const ret = [];
+        for (const event of trigger.events) {
+            const name = trigger.events.length > 1 ? `${trigger.name}_${event}` : trigger.name;
+            ret.push(`create trigger ${this.quote(name)} ${timing} ${event.toUpperCase()} on ${table.getQuotedName()} for each ROW begin ${trigger.body}; end`);
+        }
+        return ret.join(';\n');
+    }
+    createRoutine(routine) {
+        if (routine.expression) {
+            return routine.expression;
+        }
+        const name = this.platform.quoteIdentifier(routine.name);
+        // MySQL functions reject direction prefixes (function params are always IN); procedures use them.
+        const params = routine.params
+            .map(p => {
+            const dir = routine.type === 'procedure' ? `${p.direction.toUpperCase()} ` : '';
+            return `${dir}${this.platform.quoteIdentifier(p.name)} ${p.type}`;
+        })
+            .join(', ');
+        const determinism = routine.deterministic === true ? ' deterministic' : routine.deterministic === false ? ' not deterministic' : '';
+        const dataAccess = this.formatDataAccess(routine.dataAccess);
+        const security = routine.security === 'definer'
+            ? ' sql security definer'
+            : routine.security === 'invoker'
+                ? ' sql security invoker'
+                : '';
+        const comment = routine.comment ? ` comment ${this.platform.quoteValue(routine.comment)}` : '';
+        const body = this.wrapRoutineBody(routine.body ?? '');
+        if (routine.type === 'procedure') {
+            return `create procedure ${name}(${params})${determinism}${dataAccess}${security}${comment} ${body}`;
+        }
+        const returnType = routine.returns?.type ?? 'text';
+        return `create function ${name}(${params}) returns ${returnType}${determinism}${dataAccess}${security}${comment} ${body}`;
+    }
+    dropRoutine(routine) {
+        const kind = routine.type === 'procedure' ? 'procedure' : 'function';
+        return `drop ${kind} if exists ${this.platform.quoteIdentifier(routine.name)}`;
+    }
+    async getAllRoutines(connection) {
+        const sql = `
+      select
+        r.routine_name as name,
+        r.routine_schema as schema_name,
+        lower(r.routine_type) as type,
+        r.routine_definition as body,
+        r.dtd_identifier as return_type,
+        r.is_deterministic as is_deterministic,
+        r.sql_data_access as sql_data_access,
+        r.security_type as security_type,
+        r.routine_comment as comment
+      from information_schema.routines r
+      where r.routine_schema = database()
+        and r.routine_type in ('PROCEDURE', 'FUNCTION')
+    `;
+        const [rows, params] = await Promise.all([
+            connection.execute(sql),
+            this.getAllRoutineParams(connection),
+        ]);
+        return rows.map(row => ({
+            name: row.name,
+            type: row.type,
+            // MySQL has no schema namespace for routines — undefined matches the metadata side.
+            schema: undefined,
+            body: this.stripRoutineBody(row.body ?? ''),
+            deterministic: row.is_deterministic === 'YES',
+            dataAccess: this.parseDataAccess(row.sql_data_access),
+            security: row.security_type === 'DEFINER' ? 'definer' : 'invoker',
+            comment: row.comment || undefined,
+            params: params.get(row.name) ?? [],
+            returns: row.type === 'function' && row.return_type ? { type: row.return_type } : undefined,
+        }));
+    }
+    async getAllRoutineParams(connection) {
+        const sql = `
+      select
+        specific_name as routine_name,
+        parameter_name as name,
+        parameter_mode as direction,
+        dtd_identifier as type,
+        ordinal_position as position
+      from information_schema.parameters
+      where specific_schema = database()
+        and parameter_name is not null
+      order by specific_name, ordinal_position
+    `;
+        const rows = await connection.execute(sql);
+        const out = new Map();
+        for (const row of rows) {
+            if (!out.has(row.routine_name)) {
+                out.set(row.routine_name, []);
+            }
+            out.get(row.routine_name).push({
+                name: row.name,
+                type: row.type,
+                direction: row.direction.toLowerCase(),
+            });
+        }
+        return out;
+    }
+    formatDataAccess(access) {
+        switch (access) {
+            case 'no-sql':
+                return ' no sql';
+            case 'reads-sql-data':
+                return ' reads sql data';
+            case 'modifies-sql-data':
+                return ' modifies sql data';
+            case 'contains-sql':
+                return ' contains sql';
+            default:
+                return '';
+        }
+    }
+    parseDataAccess(access) {
+        return access.toLowerCase().replace(/\s+/g, '-');
+    }
+    async getAllTriggers(connection, tables) {
+        const names = tables.map(t => this.platform.quoteValue(t.table_name)).join(', ');
+        const sql = `select trigger_name as trigger_name, event_object_table as table_name, nullif(event_object_schema, schema()) as schema_name,
+      event_manipulation as event, action_timing as timing,
+      action_orientation as for_each, action_statement as body
+    from information_schema.triggers
+    where event_object_schema = database()
+      and event_object_table in (${names})
+    order by trigger_name, event_manipulation`;
+        const allTriggers = await connection.execute(sql);
+        const ret = {};
+        // First pass: collect all raw trigger names per table to detect multi-event groups.
+        // A base name is only used for grouping if multiple triggers share it (e.g. trg_multi_insert + trg_multi_update).
+        const namesByTable = new Map();
+        for (const row of allTriggers) {
+            const key = this.getTableKey(row);
+            namesByTable.set(key, [...(namesByTable.get(key) ?? []), row.trigger_name]);
+        }
+        const triggerMap = new Map();
+        for (const row of allTriggers) {
+            const key = this.getTableKey(row);
+            const eventLower = row.event.toLowerCase();
+            const tableNames = namesByTable.get(key) ?? [];
+            // Only strip event suffix when another trigger with the same base exists for this table
+            const candidateBase = row.trigger_name.endsWith(`_${eventLower}`)
+                ? row.trigger_name.slice(0, -eventLower.length - 1)
+                : null;
+            const baseName = candidateBase && tableNames.some(n => n !== row.trigger_name && n.startsWith(`${candidateBase}_`))
+                ? candidateBase
+                : row.trigger_name;
+            const dedupeKey = `${key}:${baseName}`;
+            if (triggerMap.has(dedupeKey)) {
+                const existing = triggerMap.get(dedupeKey);
+                const event = eventLower;
+                if (!existing.events.includes(event)) {
+                    existing.events.push(event);
+                }
+                continue;
+            }
+            ret[key] ??= [];
+            // Strip BEGIN/END wrapper from MySQL action_statement
+            let body = row.body ?? '';
+            const beginEndMatch = /^\s*begin\s+([\s\S]*)\s*end\s*$/i.exec(body);
+            if (beginEndMatch) {
+                body = beginEndMatch[1].trim().replace(/;\s*$/, '');
+            }
+            const trigger = {
+                name: baseName,
+                timing: row.timing.toLowerCase(),
+                events: [eventLower],
+                forEach: (row.for_each ?? 'row').toLowerCase(),
+                body,
+            };
+            ret[key].push(trigger);
+            triggerMap.set(dedupeKey, trigger);
+        }
+        return ret;
+    }
     async getAllForeignKeys(connection, tables, ctx) {
         const sql = `select k.constraint_name as constraint_name, nullif(k.table_schema, schema()) as schema_name, k.table_name as table_name, k.column_name as column_name, k.referenced_table_name as referenced_table_name, k.referenced_column_name as referenced_column_name, c.update_rule as update_rule, c.delete_rule as delete_rule
         from information_schema.key_column_usage k
@@ -319,10 +547,13 @@ export class MySqlSchemaHelper extends SchemaHelper {
         const col = this.createTableColumn(column, table, changedProperties);
         return [`alter table ${table.getQuotedName()} modify ${col}`];
     }
+    // MySQL MODIFY/CHANGE resets omitted column attributes to the table default, so collation must
+    // be re-emitted on rename and comment-only paths to preserve a non-default column collation.
     getColumnDeclarationSQL(col) {
         let ret = col.type;
         ret += col.unsigned ? ' unsigned' : '';
         ret += col.autoincrement ? ' auto_increment' : '';
+        ret += col.collation ? ` ${this.getCollateSQL(col.collation)}` : '';
         ret += ' ';
         ret += col.nullable ? 'null' : 'not null';
         ret += col.default ? ' default ' + col.default : '';

package/dialects/oracledb/OracleDialect.d.ts

@@ -46,7 +46,7 @@ declare class OracleConnection implements DatabaseConnection {
         sql: string;
         bindParams: unknown[];
     };
-    streamQuery<R>(compiledQuery: CompiledQuery, _chunkSize?: number): AsyncIterableIterator<QueryResult<R>>;
+    streamQuery<R>(compiledQuery: CompiledQuery, chunkSize?: number): AsyncIterableIterator<QueryResult<R>>;
     get connection(): OraclePoolConnection;
 }
 declare class OracleDriver implements Driver {

package/dialects/oracledb/OracleDialect.js

@@ -66,13 +66,14 @@ class OracleConnection {
             bindParams: query.parameters,
         };
     }
-    async *streamQuery(compiledQuery, _chunkSize) {
+    async *streamQuery(compiledQuery, chunkSize) {
         const { sql, bindParams } = this.formatQuery(compiledQuery);
         const result = await this.#connection.execute(sql, bindParams, {
             resultSet: true,
             autoCommit: compiledQuery.autoCommit,
             outFormat: OUT_FORMAT_OBJECT,
             ...this.#executeOptions,
+            ...(chunkSize != null ? { fetchArraySize: chunkSize } : {}),
         });
         const rs = result.resultSet;
         try {

package/dialects/postgresql/BasePostgreSqlEntityManager.d.ts

@@ -0,0 +1,19 @@
+import { type EntityName } from '@mikro-orm/core';
+import { SqlEntityManager } from '../../SqlEntityManager.js';
+import type { AbstractSqlDriver } from '../../AbstractSqlDriver.js';
+/**
+ * Shared base class for PostgreSQL-flavoured entity managers (`pg`, `pglite`).
+ * Adds Postgres-only helpers on top of `SqlEntityManager`.
+ */
+export declare class BasePostgreSqlEntityManager<Driver extends AbstractSqlDriver = AbstractSqlDriver> extends SqlEntityManager<Driver> {
+    /**
+     * Refreshes a materialized view.
+     *
+     * @param entityName - The entity name or class of the materialized view
+     * @param options - Optional settings
+     * @param options.concurrently - If true, refreshes the view concurrently (requires a unique index on the view)
+     */
+    refreshMaterializedView<Entity extends object>(entityName: EntityName<Entity>, options?: {
+        concurrently?: boolean;
+    }): Promise<void>;
+}

package/dialects/postgresql/BasePostgreSqlEntityManager.js

@@ -0,0 +1,24 @@
+import { SqlEntityManager } from '../../SqlEntityManager.js';
+/**
+ * Shared base class for PostgreSQL-flavoured entity managers (`pg`, `pglite`).
+ * Adds Postgres-only helpers on top of `SqlEntityManager`.
+ */
+export class BasePostgreSqlEntityManager extends SqlEntityManager {
+    /**
+     * Refreshes a materialized view.
+     *
+     * @param entityName - The entity name or class of the materialized view
+     * @param options - Optional settings
+     * @param options.concurrently - If true, refreshes the view concurrently (requires a unique index on the view)
+     */
+    async refreshMaterializedView(entityName, options) {
+        const meta = this.getMetadata(entityName);
+        if (!meta.view || !meta.materialized) {
+            throw new Error(`Entity ${meta.className} is not a materialized view`);
+        }
+        const helper = this.getDriver().getPlatform().getSchemaHelper();
+        const schema = meta.schema ?? this.config.get('schema');
+        const sql = helper.refreshMaterializedView(meta.tableName, schema, options?.concurrently);
+        await this.execute(sql);
+    }
+}

package/dialects/postgresql/BasePostgreSqlPlatform.d.ts

@@ -15,6 +15,7 @@ export declare class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     usesEnumCheckConstraints(): boolean;
     getEnumArrayCheckConstraintExpression(column: string, items: string[]): string;
     supportsMaterializedViews(): boolean;
+    supportsPartitionedTables(): boolean;
     supportsCustomPrimaryKeyNames(): boolean;
     getCurrentTimestampSQL(length: number): string;
     getDateTimeTypeDeclarationSQL(column: {
@@ -46,6 +47,7 @@ export declare class BasePostgreSqlPlatform extends AbstractSqlPlatform {
         precision?: number;
         scale?: number;
         autoincrement?: boolean;
+        columnTypes?: string[];
     }): string;
     getMappedType(type: string): Type<unknown>;
     getRegExpOperator(val?: unknown, flags?: string): string;
@@ -69,6 +71,12 @@ export declare class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     }): string[];
     marshallArray(values: string[]): string;
     unmarshallArray(value: string): string[];
+    escape(value: any): string;
+    /**
+     * Ported from PostgreSQL 9.2.4 source code (`src/interfaces/libpq/fe-exec.c`),
+     * matching `pg.Client.prototype.escapeLiteral` so we don't need a `pg` dep here.
+     */
+    private escapeLiteral;
     getVarcharTypeDeclarationSQL(column: {
         length?: number;
     }): string;
@@ -92,11 +100,8 @@ export declare class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     getDefaultMappedType(type: string): Type<unknown>;
     supportsSchemas(): boolean;
     getDefaultSchemaName(): string | undefined;
-    /**
-     * Returns the default name of index for the given columns
-     * cannot go past 63 character length for identifiers in MySQL
-     */
-    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
+    /** Postgres identifier limit (NAMEDATALEN - 1). */
+    getMaxIdentifierLength(): number;
     getDefaultPrimaryName(tableName: string, columns: string[]): string;
     /**
      * @inheritDoc
@@ -110,4 +115,5 @@ export declare class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     }[]): string;
     getJsonArrayElementPropertySQL(alias: string, property: string, type: string): string;
     getDefaultClientUrl(): string;
+    caseInsensitiveCollationNames(): boolean;
 }