@mikro-orm/sql 7.1.0-dev.9 → 7.1.0

package/README.md

@@ -2,7 +2,7 @@
   <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
 </h1>
 
-TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite (including libSQL), MSSQL and Oracle databases.
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL (including CockroachDB and PGlite), SQLite (including libSQL), MSSQL and Oracle databases.
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
@@ -19,6 +19,7 @@ Install a driver package for your database:
 
 ```sh
 npm install @mikro-orm/postgresql   # PostgreSQL
+npm install @mikro-orm/pglite       # PGlite (embedded PostgreSQL in WASM)
 npm install @mikro-orm/mysql        # MySQL
 npm install @mikro-orm/mariadb      # MariaDB
 npm install @mikro-orm/sqlite       # SQLite

package/SqlEntityManager.d.ts

@@ -1,4 +1,4 @@
-import { type EntitySchemaWithMeta, EntityManager, type AnyEntity, type ConnectionType, type CountByOptions, type Dictionary, type EntityData, type EntityKey, type EntityName, type EntityRepository, type FilterQuery, type GetRepository, type LoggingOptions, type QueryResult, type RawQueryFragment } from '@mikro-orm/core';
+import { type AbortQueryOptions, type EntitySchemaWithMeta, EntityManager, type AnyEntity, type ConnectionType, type CountByOptions, type Dictionary, type EntityData, type EntityKey, type EntityName, type EntityRepository, type FilterQuery, type GetRepository, type LoggingOptions, type QueryResult, type RawQueryFragment } from '@mikro-orm/core';
 import type { AbstractSqlDriver } from './AbstractSqlDriver.js';
 import type { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 import type { QueryBuilder } from './query/QueryBuilder.js';
@@ -6,6 +6,13 @@ import type { SqlEntityRepository } from './SqlEntityRepository.js';
 import type { Kysely } from 'kysely';
 import type { InferClassEntityDB, InferKyselyDB } from './typings.js';
 import { type MikroKyselyPluginOptions } from './plugin/index.js';
+/** Options for the modern signature of `SqlEntityManager.execute()`. */
+export interface EmExecuteOptions extends AbortQueryOptions {
+    /** Result shape — `'all'` for rows, `'get'` for a single row, `'run'` for affected count. Defaults to `'all'`. */
+    method?: 'all' | 'get' | 'run';
+    /** Logger context payload forwarded to `Logger.logQuery`. */
+    loggerContext?: LoggingOptions;
+}
 /** Options for `SqlEntityManager.getKysely()`. */
 export interface GetKyselyOptions extends MikroKyselyPluginOptions {
     /** Connection type to use (`'read'` or `'write'`). */
@@ -24,11 +31,43 @@ export declare class SqlEntityManager<Driver extends AbstractSqlDriver = Abstrac
      */
     qb<Entity extends object, RootAlias extends string = never>(entityName: EntityName<Entity>, alias?: RootAlias, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<Entity, RootAlias>;
     /**
-     * Returns configured Kysely instance.
+     * Returns a configured Kysely instance bound to this EntityManager.
+     *
+     * When the EntityManager is inside a transaction (e.g. within `em.transactional(...)`, or after
+     * `em.begin()`), the returned Kysely instance automatically uses the transaction context, so any
+     * queries executed via Kysely's own `.execute()` / `.executeTakeFirst*()` participate in the
+     * current transaction.
+     *
+     * If you need a Kysely instance that is **not** bound to the current transaction (e.g. to perform
+     * a side query against the pool while inside a transactional block), fork the EntityManager first:
+     *
+     * ```ts
+     * await em.transactional(async em => {
+     *   // bound to the current transaction
+     *   await em.getKysely().selectFrom('user').selectAll().execute();
+     *
+     *   // bound to the pool, runs outside the transaction
+     *   await em.fork().getKysely().selectFrom('audit_log').selectAll().execute();
+     * });
+     * ```
+     *
+     * The `options.type` (`'read'` / `'write'`) is only honored outside a transaction — inside a
+     * transaction the connection is already pinned.
      */
     getKysely<TDB = undefined, TOptions extends GetKyselyOptions = GetKyselyOptions>(options?: TOptions): Kysely<TDB extends undefined ? InferKyselyDB<EntitiesFromManager<this>, TOptions> & InferClassEntityDB<AllEntitiesFromManager<this>, TOptions> : TDB>;
-    /** Executes a raw SQL query, using the current transaction context if available. */
+    /**
+     * Executes a raw SQL query, using the current transaction context if available. The fork-level
+     * `signal` / `inflightQueryAbortStrategy` (set via `em.fork({ signal })`) is applied automatically.
+     * For per-call cancellation use the options-bag overload below.
+     */
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: any[], method?: 'all' | 'get' | 'run', loggerContext?: LoggingOptions): Promise<T>;
+    /**
+     * Executes a raw SQL query with an options bag carrying `method`, `loggerContext`, `signal`
+     * and `inflightQueryAbortStrategy`. Per-call `signal` / `inflightQueryAbortStrategy` override
+     * the fork-level defaults set via `em.fork({ signal })`. The current transaction context is
+     * applied automatically.
+     */
+    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params: any[], options: EmExecuteOptions): Promise<T>;
     /**
      * @inheritDoc
      */
@@ -36,6 +75,6 @@ export declare class SqlEntityManager<Driver extends AbstractSqlDriver = Abstrac
     getRepository<T extends object, U extends EntityRepository<T> = SqlEntityRepository<T>>(entityName: EntityName<T>): GetRepository<T, U>;
     protected applyDiscriminatorCondition<Entity extends object>(entityName: EntityName<Entity>, where: FilterQuery<Entity>): FilterQuery<Entity>;
 }
-type EntitiesFromManager<TEntityManager extends EntityManager<any>> = NonNullable<TEntityManager['~entities']> extends any[] ? Extract<NonNullable<TEntityManager['~entities']>[number], EntitySchemaWithMeta> : never;
-type AllEntitiesFromManager<TEntityManager extends EntityManager<any>> = NonNullable<TEntityManager['~entities']> extends any[] ? NonNullable<TEntityManager['~entities']>[number] : never;
+type EntitiesFromManager<TEntityManager extends EntityManager<any>> = NonNullable<TEntityManager['~entities']> extends readonly any[] ? Extract<NonNullable<TEntityManager['~entities']>[number], EntitySchemaWithMeta> : never;
+type AllEntitiesFromManager<TEntityManager extends EntityManager<any>> = NonNullable<TEntityManager['~entities']> extends readonly any[] ? NonNullable<TEntityManager['~entities']>[number] : never;
 export {};

package/SqlEntityManager.js

@@ -9,7 +9,9 @@ export class SqlEntityManager extends EntityManager {
      */
     createQueryBuilder(entityName, alias, type, loggerContext) {
         const context = this.getContext(false);
-        return this.driver.createQueryBuilder(entityName, context.getTransactionContext(), type, true, loggerContext ?? context.loggerContext, alias, this);
+        const qb = this.driver.createQueryBuilder(entityName, context.getTransactionContext(), type, true, loggerContext ?? context.loggerContext, alias, this);
+        qb.setAbortOptions(context.getAbortOptions());
+        return qb;
     }
     /**
      * Shortcut for `createQueryBuilder()`
@@ -18,10 +20,33 @@ export class SqlEntityManager extends EntityManager {
         return this.createQueryBuilder(entityName, alias, type, loggerContext);
     }
     /**
-     * Returns configured Kysely instance.
+     * Returns a configured Kysely instance bound to this EntityManager.
+     *
+     * When the EntityManager is inside a transaction (e.g. within `em.transactional(...)`, or after
+     * `em.begin()`), the returned Kysely instance automatically uses the transaction context, so any
+     * queries executed via Kysely's own `.execute()` / `.executeTakeFirst*()` participate in the
+     * current transaction.
+     *
+     * If you need a Kysely instance that is **not** bound to the current transaction (e.g. to perform
+     * a side query against the pool while inside a transactional block), fork the EntityManager first:
+     *
+     * ```ts
+     * await em.transactional(async em => {
+     *   // bound to the current transaction
+     *   await em.getKysely().selectFrom('user').selectAll().execute();
+     *
+     *   // bound to the pool, runs outside the transaction
+     *   await em.fork().getKysely().selectFrom('audit_log').selectAll().execute();
+     * });
+     * ```
+     *
+     * The `options.type` (`'read'` / `'write'`) is only honored outside a transaction — inside a
+     * transaction the connection is already pinned.
      */
     getKysely(options = {}) {
-        let kysely = this.getConnection(options.type).getClient();
+        const context = this.getContext(false);
+        const ctx = context.getTransactionContext();
+        let kysely = ctx ?? this.getConnection(options.type).getClient();
         if (options.columnNamingStrategy != null ||
             options.tableNamingStrategy != null ||
             options.processOnCreateHooks != null ||
@@ -31,9 +56,19 @@ export class SqlEntityManager extends EntityManager {
         }
         return kysely;
     }
-    /** Executes a raw SQL query, using the current transaction context if available. */
-    async execute(query, params = [], method = 'all', loggerContext) {
-        return this.getDriver().execute(query, params, method, this.getContext(false).getTransactionContext(), loggerContext);
+    async execute(query, params = [], methodOrOptions = 'all', loggerContext) {
+        const opts = typeof methodOrOptions === 'string' ? { method: methodOrOptions, loggerContext } : methodOrOptions;
+        const context = this.getContext(false);
+        // Per-field fallback to fork-level abort, matching `EntityManager.prepareOptions` semantics.
+        const fork = context.getAbortOptions();
+        const hasAbort = opts.signal != null || opts.inflightQueryAbortStrategy != null || fork != null;
+        // Connection layer carries abort piggy-backed on `loggerContext`; merge only when needed.
+        const merged = hasAbort || opts.loggerContext ? { ...opts.loggerContext } : undefined;
+        if (merged && hasAbort) {
+            merged.signal = opts.signal ?? fork?.signal;
+            merged.inflightQueryAbortStrategy = opts.inflightQueryAbortStrategy ?? fork?.inflightQueryAbortStrategy;
+        }
+        return this.getDriver().execute(query, params, opts.method ?? 'all', context.getTransactionContext(), merged);
     }
     /**
      * @inheritDoc

package/SqlMikroORM.d.ts

@@ -0,0 +1,23 @@
+import { type AnyEntity, type EntityClass, type EntityManager, type EntityManagerType, type EntitySchema, type IDatabaseDriver, MikroORM, type Options } from '@mikro-orm/core';
+import type { AbstractSqlDriver } from './AbstractSqlDriver.js';
+import type { SqlEntityManager } from './SqlEntityManager.js';
+/** Configuration options shared by all SQL drivers. */
+export type SqlOptions<D extends AbstractSqlDriver = AbstractSqlDriver, EM extends SqlEntityManager<D> = SqlEntityManager<D>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = Partial<Options<D, EM, Entities>>;
+/**
+ * Creates a type-safe configuration object for any SQL driver. The driver class
+ * must be passed via `options.driver` (e.g. `SqliteDriver`, `MySqlDriver`, …).
+ */
+export declare function defineSqlConfig<D extends AbstractSqlDriver = AbstractSqlDriver, EM extends SqlEntityManager<D> = SqlEntityManager<D>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Partial<Options<D, EM, Entities>>): Partial<Options<D, EM, Entities>>;
+/**
+ * Generic entry point for SQL drivers. Use this when consuming `@mikro-orm/sql`
+ * directly with a Kysely dialect; for the bundled driver packages prefer
+ * `@mikro-orm/sqlite`, `@mikro-orm/postgresql`, etc.
+ *
+ * @inheritDoc
+ */
+export declare class SqlMikroORM<D extends AbstractSqlDriver = AbstractSqlDriver, EM extends SqlEntityManager<D> = SqlEntityManager<D>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends MikroORM<D, EM, Entities> {
+    /**
+     * @inheritDoc
+     */
+    static init<D extends IDatabaseDriver = AbstractSqlDriver, EM extends EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Partial<Options<D, EM, Entities>>): Promise<MikroORM<D, EM, Entities>>;
+}

package/SqlMikroORM.js

@@ -0,0 +1,23 @@
+import { defineConfig, MikroORM, } from '@mikro-orm/core';
+/**
+ * Creates a type-safe configuration object for any SQL driver. The driver class
+ * must be passed via `options.driver` (e.g. `SqliteDriver`, `MySqlDriver`, …).
+ */
+export function defineSqlConfig(options) {
+    return defineConfig(options);
+}
+/**
+ * Generic entry point for SQL drivers. Use this when consuming `@mikro-orm/sql`
+ * directly with a Kysely dialect; for the bundled driver packages prefer
+ * `@mikro-orm/sqlite`, `@mikro-orm/postgresql`, etc.
+ *
+ * @inheritDoc
+ */
+export class SqlMikroORM extends MikroORM {
+    /**
+     * @inheritDoc
+     */
+    static async init(options) {
+        return super.init(options);
+    }
+}

package/dialects/mysql/BaseMySqlPlatform.d.ts

@@ -35,11 +35,9 @@ export declare class BaseMySqlPlatform extends AbstractSqlPlatform {
     getDefaultMappedType(type: string): Type<unknown>;
     isNumericColumn(mappedType: Type<unknown>): boolean;
     supportsUnsigned(): boolean;
-    /**
-     * Returns the default name of index for the given columns
-     * cannot go past 64 character length for identifiers in MySQL
-     */
-    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
+    /** MySQL/MariaDB identifier limit. */
+    getMaxIdentifierLength(): number;
+    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence' | 'check'): string;
     getDefaultPrimaryName(tableName: string, columns: string[]): string;
     supportsCreatingFullTextIndex(): boolean;
     getFullTextWhereClause(): string;

package/dialects/mysql/BaseMySqlPlatform.js

@@ -1,4 +1,4 @@
-import { Utils, QueryOrder, DecimalType, DoubleType, } from '@mikro-orm/core';
+import { QueryOrder, DecimalType, DoubleType, } from '@mikro-orm/core';
 import { MySqlSchemaHelper } from './MySqlSchemaHelper.js';
 import { MySqlExceptionConverter } from './MySqlExceptionConverter.js';
 import { AbstractSqlPlatform } from '../../AbstractSqlPlatform.js';
@@ -86,19 +86,15 @@ export class BaseMySqlPlatform extends AbstractSqlPlatform {
     supportsUnsigned() {
         return true;
     }
-    /**
-     * Returns the default name of index for the given columns
-     * cannot go past 64 character length for identifiers in MySQL
-     */
+    /** MySQL/MariaDB identifier limit. */
+    getMaxIdentifierLength() {
+        return 64;
+    }
     getIndexName(tableName, columns, type) {
         if (type === 'primary') {
             return this.getDefaultPrimaryName(tableName, columns);
         }
-        const indexName = super.getIndexName(tableName, columns, type);
-        if (indexName.length > 64) {
-            return `${indexName.substring(0, 56 - type.length)}_${Utils.hash(indexName, 5)}_${type}`;
-        }
-        return indexName;
+        return super.getIndexName(tableName, columns, type);
     }
     getDefaultPrimaryName(tableName, columns) {
         return 'PRIMARY'; // https://dev.mysql.com/doc/refman/8.0/en/create-table.html#create-table-indexes-keys

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -1,5 +1,5 @@
 import { type Dictionary, type Transaction, type Type } from '@mikro-orm/core';
-import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef } from '../../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef, SqlRoutineDef } from '../../typings.js';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
@@ -11,7 +11,12 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
         'current_timestamp(?)': string[];
         '0': string[];
     };
+    private static readonly PARTIAL_INDEX_RE;
     getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
+    getSetSchemaSQL(schema: string): string;
+    getResetSchemaSQL(defaultSchema: string): string;
+    supportsMigrationSchema(): boolean;
+    tableExists(connection: AbstractSqlConnection, tableName: string, schemaName: string | undefined, ctx?: Transaction): Promise<boolean>;
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
     finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;
@@ -22,8 +27,10 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     getAllIndexes(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<IndexDef[]>>;
     getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
     /**
-     * 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.
      */
     protected getIndexColumns(index: IndexDef): string;
     /**
@@ -34,6 +41,12 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     getAllChecks(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<CheckDef[]>>;
     /** Generates SQL to create MySQL triggers. MySQL requires one trigger per event. */
     createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    createRoutine(routine: SqlRoutineDef): string;
+    dropRoutine(routine: SqlRoutineDef): string;
+    getAllRoutines(connection: AbstractSqlConnection): Promise<SqlRoutineDef[]>;
+    private getAllRoutineParams;
+    private formatDataAccess;
+    private parseDataAccess;
     getAllTriggers(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<SqlTriggerDef[]>>;
     getAllForeignKeys(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<Dictionary<ForeignKey>>>;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];

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()`;
@@ -68,6 +90,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
         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]) {
@@ -84,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',
@@ -113,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);
             }
@@ -150,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.
@@ -196,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;
@@ -242,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,
             });
@@ -289,6 +325,115 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }
         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,
@@ -402,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 {