@mikro-orm/sql 7.1.0-dev.2 → 7.1.0-dev.21

package/dialects/mysql/MySqlNativeQueryBuilder.js

@@ -3,6 +3,17 @@ import { NativeQueryBuilder } from '../../query/NativeQueryBuilder.js';
 /** @internal */
 export class MySqlNativeQueryBuilder extends NativeQueryBuilder {
     compileInsert() {
+        if (this.options.insertSubQuery) {
+            super.compileInsert();
+            // Inject 'ignore' after 'insert' for MySQL's INSERT IGNORE ... SELECT syntax
+            if (this.options.onConflict?.ignore) {
+                const insertIdx = this.parts.indexOf('insert');
+                if (insertIdx >= 0) {
+                    this.parts.splice(insertIdx + 1, 0, 'ignore');
+                }
+            }
+            return;
+        }
         if (!this.options.data) {
             throw new Error('No data provided');
         }

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 } from '../../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef } from '../../typings.js';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
@@ -11,6 +11,7 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
         'current_timestamp(?)': string[];
         '0': string[];
     };
+    private static readonly PARTIAL_INDEX_RE;
     getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
@@ -22,8 +23,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;
     /**
@@ -32,6 +35,9 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     protected appendMySqlIndexSuffix(sql: string, index: IndexDef): string;
     getAllColumns(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<Column[]>>;
     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;
+    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[];
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column): string;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -7,6 +7,10 @@ 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`;
@@ -64,11 +68,15 @@ 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);
             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 +88,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 +120,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,10 +160,15 @@ 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.where) {
+            return this.emulatePartialIndexColumns(index);
+        }
         if (index.columns?.length) {
             return index.columns
                 .map(col => {
@@ -264,6 +283,85 @@ 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');
+    }
+    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

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/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;

package/dialects/postgresql/BasePostgreSqlPlatform.js

@@ -30,6 +30,9 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     supportsMaterializedViews() {
         return true;
     }
+    supportsPartitionedTables() {
+        return true;
+    }
     supportsCustomPrimaryKeyNames() {
         return true;
     }
@@ -90,18 +93,27 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     }
     normalizeColumnType(type, options) {
         const simpleType = this.extractSimpleType(type);
-        if (['int', 'int4', 'integer'].includes(simpleType)) {
+        if (['int', 'int4', 'integer', 'serial'].includes(simpleType)) {
             return this.getIntegerTypeDeclarationSQL({});
         }
-        if (['bigint', 'int8'].includes(simpleType)) {
+        if (['bigint', 'int8', 'bigserial'].includes(simpleType)) {
             return this.getBigIntTypeDeclarationSQL({});
         }
-        if (['smallint', 'int2'].includes(simpleType)) {
+        if (['smallint', 'int2', 'smallserial'].includes(simpleType)) {
             return this.getSmallIntTypeDeclarationSQL({});
         }
         if (['boolean', 'bool'].includes(simpleType)) {
             return this.getBooleanTypeDeclarationSQL();
         }
+        if (['double', 'double precision', 'float8'].includes(simpleType)) {
+            return this.getDoubleDeclarationSQL();
+        }
+        if (['real', 'float4'].includes(simpleType)) {
+            return this.getFloatDeclarationSQL();
+        }
+        if (['timestamptz', 'timestamp with time zone'].includes(simpleType)) {
+            return this.getDateTimeTypeDeclarationSQL(options);
+        }
         if (['varchar', 'character varying'].includes(simpleType)) {
             return this.getVarcharTypeDeclarationSQL(options);
         }
@@ -114,6 +126,12 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
         if (['interval'].includes(simpleType)) {
             return this.getIntervalTypeDeclarationSQL(options);
         }
+        // TimeType.getColumnType drops the timezone qualifier, so detect tz aliases from the original column type.
+        const originalType = options.columnTypes?.[0]?.toLowerCase() ?? type;
+        if (/^timetz\b/.test(originalType) || /^time\s+with\s+time\s+zone\b/.test(originalType)) {
+            const length = options.length ?? this.getDefaultDateTimeLength();
+            return `timetz(${length})`;
+        }
         return super.normalizeColumnType(type, options);
     }
     getMappedType(type) {

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -1,7 +1,7 @@
 import { type Dictionary, type Transaction } from '@mikro-orm/core';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
-import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, TablePartitioning, SqlTriggerDef } from '../../typings.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
 import type { DatabaseTable } from '../../schema/DatabaseTable.js';
 export declare class PostgreSqlSchemaHelper extends SchemaHelper {
@@ -14,6 +14,8 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
         'null::timestamp with time zone': string[];
         'null::timestamp without time zone': string[];
     };
+    private static readonly PARTIAL_WHERE_RE;
+    private static readonly FUNCTIONAL_COL_RE;
     getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
     getCreateDatabaseSQL(name: string): string;
     getListTablesSQL(): string;
@@ -23,11 +25,22 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     getListMaterializedViewsSQL(): string;
     loadMaterializedViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string, ctx?: Transaction): Promise<void>;
     createMaterializedView(name: string, schema: string | undefined, definition: string, withData?: boolean): string;
+    createTable(table: DatabaseTable, alter?: boolean): string[];
     dropMaterializedViewIfExists(name: string, schema?: string): string;
     refreshMaterializedView(name: string, schema?: string, concurrently?: boolean): string;
     getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;
     private getIgnoredNamespacesConditionSQL;
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[], ctx?: Transaction): Promise<void>;
+    /**
+     * Introspects direct partitions only: the `pg_inherits` join surfaces a parent's children but
+     * does not recurse into sub-partitioning (e.g. hash-of-range). Declarative `partitionBy`
+     * metadata does not express multi-level partitioning either, so grandchildren are intentionally
+     * invisible to schema diffing.
+     *
+     * Entries with an undefined schema bucket are resolved against `current_schema()` so they do
+     * not match same-named tables in unrelated schemas.
+     */
+    getPartitions(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<TablePartitioning>>;
     getAllIndexes(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<IndexDef[]>>;
     /**
      * Parses column definitions from the full CREATE INDEX expression.
@@ -49,6 +62,13 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
         items: string[];
     }>, ctx?: Transaction): Promise<Dictionary<Column[]>>;
     getAllChecks(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<CheckDef[]>>;
+    /** Generates SQL to create a PostgreSQL trigger and its associated function. */
+    createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    /** Generates SQL to drop a PostgreSQL trigger and its associated function. */
+    dropTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    private getSchemaQualifiedTriggerFnName;
+    getAllTriggers(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<SqlTriggerDef[]>>;
+    private getTriggersSQL;
     getAllForeignKeys(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<Dictionary<ForeignKey>>>;
     getNativeEnumDefinitions(connection: AbstractSqlConnection, schemas: string[], ctx?: Transaction): Promise<Dictionary<{
         name: string;

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -1,5 +1,6 @@
 import { DeferMode, EnumType, Type, Utils, } from '@mikro-orm/core';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
+import { normalizePartitionBound, normalizePartitionDefinition } from '../../schema/partitioning.js';
 /** PostGIS system views that should be automatically ignored */
 const POSTGIS_VIEWS = ['geography_columns', 'geometry_columns'];
 export class PostgreSqlSchemaHelper extends SchemaHelper {
@@ -12,6 +13,8 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         'null::timestamp with time zone': ['null'],
         'null::timestamp without time zone': ['null'],
     };
+    static PARTIAL_WHERE_RE = /\swhere\s+(.+)$/is;
+    static FUNCTIONAL_COL_RE = /[(): ,"'`]/;
     getSchemaBeginning(charset, disableForeignKeys) {
         if (disableForeignKeys) {
             return `set names '${charset}';\n${this.disableForeignKeysSQL()}\n\n`;
@@ -22,13 +25,22 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         return `create database ${this.quote(name)}`;
     }
     getListTablesSQL() {
+        // The `pg_inherits` anti-join compares on (schema, table) pairs so cross-schema child
+        // partitions are excluded even when their schema is not on the session `search_path`
+        // (in which case `inhrelid::regclass::text` renders as `schema.name` rather than bare `name`,
+        // breaking a plain `table_name not in (...)` predicate).
         return (`select table_name, table_schema as schema_name, ` +
             `(select pg_catalog.obj_description(c.oid) from pg_catalog.pg_class c
           where c.oid = (select ('"' || table_schema || '"."' || table_name || '"')::regclass::oid) and c.relname = table_name) as table_comment ` +
-            `from information_schema.tables ` +
+            `from information_schema.tables t ` +
             `where ${this.getIgnoredNamespacesConditionSQL('table_schema')} ` +
             `and table_name != 'geometry_columns' and table_name != 'spatial_ref_sys' and table_type != 'VIEW' ` +
-            `and table_name not in (select inhrelid::regclass::text from pg_inherits) ` +
+            `and not exists (` +
+            `select 1 from pg_inherits i ` +
+            `join pg_class c on c.oid = i.inhrelid ` +
+            `join pg_namespace n on n.oid = c.relnamespace ` +
+            `where c.relname = t.table_name and n.nspname = t.table_schema` +
+            `) ` +
             `order by table_name`);
     }
     getIgnoredViewsCondition() {
@@ -79,6 +91,23 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const dataClause = withData ? ' with data' : ' with no data';
         return `create materialized view ${viewName} as ${definition}${dataClause}`;
     }
+    createTable(table, alter) {
+        const partitioning = table.getPartitioning();
+        if (!partitioning) {
+            return super.createTable(table, alter);
+        }
+        const [createTable, ...rest] = super.createTable(table, alter);
+        const partitions = partitioning.partitions.map(partition => {
+            const partitionName = this.quote(this.getTableName(partition.name, partition.schema ?? table.schema));
+            return `create table ${partitionName} partition of ${table.getQuotedName()} ${partition.bound}`;
+        });
+        // SchemaHelper.append() always terminates the CREATE TABLE with `;`; we rely on that to splice
+        // the `partition by ...` clause in before the terminator. Use slice instead of replace() so that
+        // regex replacement tokens like `$$`, `$&`, or `$1` inside user-supplied expressions (e.g., a
+        // callback that returns a dollar-quoted literal) are not interpreted as back-references.
+        const spliced = `${createTable.slice(0, -1)} partition by ${partitioning.definition};`;
+        return [spliced, ...rest, ...partitions];
+    }
     dropMaterializedViewIfExists(name, schema) {
         return `drop materialized view if exists ${this.quote(this.getTableName(name, schema))} cascade`;
     }
@@ -118,6 +147,8 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const indexes = await this.getAllIndexes(connection, tables, ctx);
         const checks = await this.getAllChecks(connection, tablesBySchema, ctx);
         const fks = await this.getAllForeignKeys(connection, tablesBySchema, ctx);
+        const partitionings = await this.getPartitions(connection, tablesBySchema, ctx);
+        const triggers = await this.getAllTriggers(connection, tablesBySchema);
         for (const t of tables) {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
@@ -126,8 +157,64 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             if (columns[key]) {
                 table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums);
             }
+            if (triggers[key]) {
+                table.setTriggers(triggers[key]);
+            }
+            table.setPartitioning(partitionings[key]);
         }
     }
+    /**
+     * Introspects direct partitions only: the `pg_inherits` join surfaces a parent's children but
+     * does not recurse into sub-partitioning (e.g. hash-of-range). Declarative `partitionBy`
+     * metadata does not express multi-level partitioning either, so grandchildren are intentionally
+     * invisible to schema diffing.
+     *
+     * Entries with an undefined schema bucket are resolved against `current_schema()` so they do
+     * not match same-named tables in unrelated schemas.
+     */
+    async getPartitions(connection, tablesBySchemas, ctx) {
+        // Collapse every (schema, table) pair into a single `values (...)` relation and join against
+        // the catalog, instead of building an OR-tree of per-schema `in (...)` predicates. This keeps
+        // the query size O(pairs) rather than O(schemas × predicate_overhead) and stays sargable when
+        // many schemas are in play.
+        const pairs = [...tablesBySchemas.entries()].flatMap(([schema, tables]) => tables.map(t => {
+            const schemaLiteral = schema == null ? 'null::text' : `${this.platform.quoteValue(schema)}::text`;
+            return `(${schemaLiteral}, ${this.platform.quoteValue(t.table_name)})`;
+        }));
+        if (pairs.length === 0) {
+            return {};
+        }
+        const sql = `with targets(schema_name, table_name) as (values ${pairs.join(', ')})
+      select parent_ns.nspname as schema_name,
+      parent.relname as table_name,
+      pg_get_partkeydef(parent.oid) as partition_definition,
+      child_ns.nspname as partition_schema_name,
+      child.relname as partition_name,
+      pg_get_expr(child.relpartbound, child.oid) as partition_bound
+      from targets
+      join pg_class parent on parent.relname = targets.table_name
+      join pg_namespace parent_ns on parent_ns.oid = parent.relnamespace
+        and parent_ns.nspname = coalesce(targets.schema_name, current_schema())
+      join pg_partitioned_table partitioned on partitioned.partrelid = parent.oid
+      left join pg_inherits inherits on inherits.inhparent = parent.oid
+      left join pg_class child on child.oid = inherits.inhrelid
+      left join pg_namespace child_ns on child_ns.oid = child.relnamespace
+      order by parent_ns.nspname, parent.relname, child_ns.nspname, child.relname`;
+        const rows = await connection.execute(sql, [], 'all', ctx);
+        const ret = {};
+        for (const row of rows) {
+            const key = this.getTableKey(row);
+            ret[key] ??= { definition: normalizePartitionDefinition(row.partition_definition), partitions: [] };
+            if (row.partition_name && row.partition_bound) {
+                ret[key].partitions.push({
+                    name: row.partition_name,
+                    schema: row.partition_schema_name,
+                    bound: normalizePartitionBound(row.partition_bound),
+                });
+            }
+        }
+        return ret;
+    }
     async getAllIndexes(connection, tables, ctx) {
         const sql = this.getIndexesSQL(tables);
         const unquote = (str) => str.replace(/['"`]/g, '');
@@ -161,9 +248,22 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             if (index.condeferrable) {
                 indexDef.deferMode = index.condeferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
             }
-            if (index.index_def.some((col) => /[(): ,"'`]/.exec(col)) || index.expression?.match(/ where /i)) {
+            const hasFunctionalColumns = index.index_def.some((col) => PostgreSqlSchemaHelper.FUNCTIONAL_COL_RE.exec(col));
+            const whereMatch = hasFunctionalColumns
+                ? null
+                : PostgreSqlSchemaHelper.PARTIAL_WHERE_RE.exec(index.expression ?? '');
+            if (hasFunctionalColumns) {
+                // Functional-column expression can't be diffed structurally — keep the whole CREATE
+                // statement (WHERE included) on `expression`; don't try to split the predicate.
                 indexDef.expression = index.expression;
             }
+            else if (whereMatch) {
+                let where = whereMatch[1].trim();
+                if (where.startsWith('(') && where.endsWith(')') && this.isBalancedWrap(where)) {
+                    where = where.slice(1, -1).trim();
+                }
+                indexDef.where = where;
+            }
             if (index.deferrable) {
                 indexDef.deferMode = index.initially_deferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
             }
@@ -375,6 +475,95 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
+    /** Generates SQL to create a PostgreSQL trigger and its associated function. */
+    createTrigger(table, trigger) {
+        if (trigger.expression) {
+            return trigger.expression;
+        }
+        const timing = trigger.timing.toUpperCase();
+        const events = trigger.events.map(e => e.toUpperCase()).join(' OR ');
+        const forEach = trigger.forEach === 'statement' ? 'STATEMENT' : 'ROW';
+        const when = trigger.when ? `\n  when (${trigger.when})` : '';
+        const fnName = this.getSchemaQualifiedTriggerFnName(table, trigger);
+        const triggerName = this.platform.quoteIdentifier(trigger.name);
+        const fnSql = `create or replace function ${fnName}() returns trigger as $$ begin ${trigger.body}; end; $$ language plpgsql`;
+        const triggerSql = `create trigger ${triggerName} ${timing} ${events} on ${table.getQuotedName()} for each ${forEach}${when} execute function ${fnName}()`;
+        return `${fnSql};\n${triggerSql}`;
+    }
+    /** Generates SQL to drop a PostgreSQL trigger and its associated function. */
+    dropTrigger(table, trigger) {
+        const triggerName = this.platform.quoteIdentifier(trigger.name);
+        const fnName = this.getSchemaQualifiedTriggerFnName(table, trigger);
+        return `drop trigger if exists ${triggerName} on ${table.getQuotedName()};\ndrop function if exists ${fnName}()`;
+    }
+    getSchemaQualifiedTriggerFnName(table, trigger) {
+        const rawName = `${table.name}_${trigger.name}_fn`;
+        const defaultSchema = this.platform.getDefaultSchemaName();
+        if (table.schema && table.schema !== defaultSchema) {
+            return `${this.platform.quoteIdentifier(table.schema)}.${this.platform.quoteIdentifier(rawName)}`;
+        }
+        return this.platform.quoteIdentifier(rawName);
+    }
+    async getAllTriggers(connection, tablesBySchemas) {
+        const sql = this.getTriggersSQL(tablesBySchemas);
+        const allTriggers = await connection.execute(sql);
+        const ret = {};
+        const triggerMap = new Map();
+        for (const row of allTriggers) {
+            const key = this.getTableKey(row);
+            const dedupeKey = `${key}:${row.trigger_name}`;
+            if (triggerMap.has(dedupeKey)) {
+                // Same trigger with multiple events — merge events
+                const existing = triggerMap.get(dedupeKey);
+                const event = row.event.toLowerCase();
+                if (!existing.events.includes(event)) {
+                    existing.events.push(event);
+                }
+                continue;
+            }
+            ret[key] ??= [];
+            // prosrc includes the full function body between $$ delimiters (e.g. " begin RETURN NEW; end;")
+            // Strip the begin/end wrapper to get just the trigger body for round-trip comparison
+            let body = (row.function_body ?? '').trim();
+            const beginEndMatch = /^\s*begin\s+([\s\S]*?)\s*end;?\s*$/i.exec(body);
+            if (beginEndMatch) {
+                body = beginEndMatch[1].trim().replace(/;\s*$/, '');
+            }
+            const trigger = {
+                name: row.trigger_name,
+                timing: row.timing.toLowerCase(),
+                events: [row.event.toLowerCase()],
+                forEach: row.for_each.toLowerCase(),
+                body,
+                when: row.when_clause ?? undefined,
+            };
+            ret[key].push(trigger);
+            triggerMap.set(dedupeKey, trigger);
+        }
+        return ret;
+    }
+    getTriggersSQL(tablesBySchemas) {
+        const conditions = [];
+        for (const [schema, tables] of tablesBySchemas) {
+            const names = tables.map(t => this.platform.quoteValue(t.table_name)).join(', ');
+            const schemaName = this.platform.quoteValue(schema ?? this.platform.getDefaultSchemaName());
+            conditions.push(`(t.event_object_schema = ${schemaName} and t.event_object_table in (${names}))`);
+        }
+        // Function lookup uses the '{table}_{trigger}_fn' convention from createTrigger().
+        // External triggers with different function names will have NULL body;
+        // use the `expression` escape hatch for those.
+        return `select t.trigger_name, t.event_object_schema as schema_name, t.event_object_table as table_name,
+      t.event_manipulation as event, t.action_timing as timing,
+      t.action_orientation as for_each,
+      t.action_condition as when_clause,
+      pg_get_functiondef(p.oid) as function_def,
+      p.prosrc as function_body
+    from information_schema.triggers t
+    left join pg_namespace n on n.nspname = t.event_object_schema
+    left join pg_proc p on p.proname = t.event_object_table || '_' || t.trigger_name || '_fn' and p.pronamespace = n.oid
+    where (${conditions.join(' or ')})
+    order by t.trigger_name, t.event_manipulation`;
+    }
     async getAllForeignKeys(connection, tablesBySchemas, ctx) {
         const sql = `select nsp1.nspname schema_name, cls1.relname table_name, nsp2.nspname referenced_schema_name,
       cls2.relname referenced_table_name, a.attname column_name, af.attname referenced_column_name, conname constraint_name,
@@ -548,6 +737,12 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         return col.join(' ');
     }
     getPreAlterTable(tableDiff, safe) {
+        if (tableDiff.changedPartitioning) {
+            const from = tableDiff.changedPartitioning.from?.definition;
+            const to = tableDiff.changedPartitioning.to?.definition;
+            const action = !from ? 'Adding' : !to ? 'Removing' : 'Changing';
+            throw new Error(`${action} partition definitions for existing PostgreSQL tables is not supported automatically (${tableDiff.name}: '${from ?? '<none>'}' -> '${to ?? '<none>'}'); create a manual migration instead`);
+        }
         const ret = [];
         const parts = tableDiff.name.split('.');
         const tableName = parts.pop();
@@ -680,7 +875,8 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         if (index.primary || (index.unique && index.constraint)) {
             return `alter table ${this.quote(table)} drop constraint ${this.quote(oldIndexName)}`;
         }
-        return `drop index ${this.quote(oldIndexName)}`;
+        const [schemaName] = this.splitTableName(table);
+        return `drop index ${this.quote(schemaName, oldIndexName)}`;
     }
     /**
      * Build the column list for a PostgreSQL index.

package/dialects/sqlite/SqlitePlatform.d.ts

@@ -15,6 +15,7 @@ export declare class SqlitePlatform extends AbstractSqlPlatform {
     getDateTimeTypeDeclarationSQL(column: {
         length: number;
     }): string;
+    getDefaultVersionLength(): number;
     getBeginTransactionSQL(options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;