@mikro-orm/sql 7.1.0-dev.3 → 7.1.0-dev.30

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,23 +13,45 @@ 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`;
         }
         return `set names '${charset}';\n\n`;
     }
+    getSetSchemaSQL(schema) {
+        // session-level `SET` (not `SET LOCAL`) so it also works outside a transaction; the runner
+        // emits `getResetSchemaSQL` afterwards to avoid leaking onto the pooled connection
+        return `set search_path to ${this.quote(schema)}`;
+    }
+    getResetSchemaSQL(_defaultSchema) {
+        return 'reset search_path';
+    }
+    supportsMigrationSchema() {
+        return true;
+    }
     getCreateDatabaseSQL(name) {
         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 +102,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,16 +158,76 @@ 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);
+        const dbCollation = await this.getDatabaseCollation(connection, ctx);
         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 = dbCollation;
             const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
             const enums = this.getEnumDefinitions(checks[key] ?? []);
             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 +261,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;
             }
@@ -266,10 +379,12 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       is_identity,
       identity_generation,
       generation_expression,
-      pg_catalog.col_description(pgc.oid, cols.ordinal_position::int) column_comment
+      pg_catalog.col_description(pgc.oid, cols.ordinal_position::int) column_comment,
+      coll.collname as collation_name
       from information_schema.columns cols
       join pg_class pgc on cols.table_name = pgc.relname
       join pg_attribute pga on pgc.oid = pga.attrelid and cols.column_name = pga.attname
+      left join pg_collation coll on pga.attcollation = coll.oid and coll.collname <> 'default'
       where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(table_schema = ${this.platform.quoteValue(schema)} and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}))`).join(' or ')})
       order by ordinal_position`;
         const allColumns = await connection.execute(sql, [], 'all', ctx);
@@ -319,6 +434,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                         ? col.generation_expression + ' stored'
                         : undefined,
                 comment: col.column_comment,
+                collation: col.collation_name ?? undefined,
             };
             let enumKey = column.type;
             let enumEntry = nativeEnums?.[enumKey];
@@ -375,6 +491,104 @@ 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);
+    }
+    /**
+     * Resolves the real name of the implicit 'default' collation (the DB's `datcollate`),
+     * so the comparator can treat `@Property({ collation: '<datcollate>' })` as equivalent
+     * to a column that introspects as using the default.
+     */
+    async getDatabaseCollation(connection, ctx) {
+        const [row] = await connection.execute(`select datcollate as collation from pg_database where datname = current_database()`, [], 'all', ctx);
+        return row?.collation;
+    }
+    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,
@@ -505,6 +719,9 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             return o;
         }, {});
     }
+    getCollateSQL(collation) {
+        return `collate ${this.platform.quoteCollation(collation)}`;
+    }
     createTableColumn(column, table) {
         const pk = table.getPrimaryKey();
         const compositePK = pk?.composite;
@@ -537,6 +754,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 columnType += ` generated always as ${column.generated}`;
             }
             col.push(columnType);
+            Utils.runIfNotEmpty(() => col.push(this.getCollateSQL(column.collation)), column.collation);
             Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
             Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable);
         }
@@ -548,6 +766,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 +904,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;

package/dialects/sqlite/SqlitePlatform.js

@@ -24,6 +24,10 @@ export class SqlitePlatform extends AbstractSqlPlatform {
     getDateTimeTypeDeclarationSQL(column) {
         return 'datetime';
     }
+    // sqlite's datetime DDL drops precision and the current-ts expression hardcodes ms scaling
+    getDefaultVersionLength() {
+        return 0;
+    }
     getBeginTransactionSQL(options) {
         return ['begin'];
     }

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -1,15 +1,17 @@
 import { type Connection, type Transaction } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
-import type { Column, IndexDef, Table, TableDifference } from '../../typings.js';
+import type { Column, IndexDef, Table, TableDifference, SqlTriggerDef } from '../../typings.js';
 import type { DatabaseTable } from '../../schema/DatabaseTable.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
 export declare class SqliteSchemaHelper extends SchemaHelper {
+    private static readonly PARTIAL_WHERE_RE;
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
     supportsSchemaConstraints(): boolean;
     getCreateNamespaceSQL(name: string): string;
     getDropNamespaceSQL(name: string): string;
+    tableExists(connection: AbstractSqlConnection, tableName: string, _schemaName: string | undefined, ctx?: Transaction): Promise<boolean>;
     getListTablesSQL(): string;
     getAllTables(connection: AbstractSqlConnection, schemas?: string[], ctx?: Transaction): Promise<Table[]>;
     getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;
@@ -44,7 +46,8 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
      * We need to add them back so they match what we generate in DDL.
      */
     private wrapExpressionDefault;
-    private getEnumDefinitions;
+    /** Extract enum values from `IN (…)` CHECKs only — a `!= 'x'` check would otherwise be misread as a one-item enum. */
+    private extractEnumValuesFromChecks;
     getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string, ctx?: Transaction): Promise<string[]>;
     private getIndexes;
     private getChecks;
@@ -64,5 +67,9 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
      */
     getReferencedTableName(referencedTableName: string, schema?: string): string;
     alterTable(diff: TableDifference, safe?: boolean): string[];
+    /** Generates SQL to create SQLite triggers. SQLite requires one trigger per event. */
+    createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    private getTableTriggers;
+    private parseTriggerDDL;
     private getAlterTempTableSQL;
 }

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -15,6 +15,7 @@ const SPATIALITE_VIEWS = [
     'ElementaryGeometries',
 ];
 export class SqliteSchemaHelper extends SchemaHelper {
+    static PARTIAL_WHERE_RE = /\swhere\s+(.+?)\s*$/is;
     disableForeignKeysSQL() {
         return 'pragma foreign_keys = off;';
     }
@@ -30,6 +31,10 @@ export class SqliteSchemaHelper extends SchemaHelper {
     getDropNamespaceSQL(name) {
         return '';
     }
+    async tableExists(connection, tableName, _schemaName, ctx) {
+        const rows = await connection.execute(`select name from sqlite_master where type = 'table' and name = ${this.platform.quoteValue(tableName)}`, [], 'all', ctx);
+        return rows.length > 0;
+    }
     getListTablesSQL() {
         return (`select name as table_name from sqlite_master where type = 'table' and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys' ` +
             `union all select name as table_name from sqlite_temp_master where type = 'table' order by name`);
@@ -100,8 +105,10 @@ export class SqliteSchemaHelper extends SchemaHelper {
             const checks = await this.getChecks(connection, table.name, table.schema, ctx);
             const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema, ctx);
             const fks = await this.getForeignKeys(connection, table.name, table.schema, ctx);
-            const enums = await this.getEnumDefinitions(connection, table.name, table.schema, ctx);
+            const enums = this.extractEnumValuesFromChecks(checks);
+            const triggers = await this.getTableTriggers(connection, table.name);
             table.init(cols, indexes, checks, pks, fks, enums);
+            table.setTriggers(triggers);
         }
     }
     createTable(table, alter) {
@@ -140,6 +147,9 @@ export class SqliteSchemaHelper extends SchemaHelper {
         for (const index of table.getIndexes()) {
             this.append(ret, this.createIndex(index, table));
         }
+        for (const trigger of table.getTriggers()) {
+            this.append(ret, this.createTrigger(table, trigger));
+        }
         return ret;
     }
     createTableColumn(column, table, _changedProperties) {
@@ -159,6 +169,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
             col.push(`check (${checks[check].expression})`);
             checks.splice(check, 1);
         }
+        Utils.runIfNotEmpty(() => col.push(this.getCollateSQL(column.collation)), column.collation);
         Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
         Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable && !column.generated);
         Utils.runIfNotEmpty(() => col.push('primary key'), column.primary);
@@ -211,10 +222,10 @@ export class SqliteSchemaHelper extends SchemaHelper {
         if (index.columnNames.some(column => column.includes('.'))) {
             // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
             const columns = this.platform.getJsonIndexDefinition(index);
-            return `${sqlPrefix} (${columns.join(', ')})`;
+            return `${sqlPrefix} (${columns.join(', ')})${this.getIndexWhereClause(index)}`;
         }
         // Use getIndexColumns to support advanced options like sort order and collation
-        return `${sqlPrefix} (${this.getIndexColumns(index)})`;
+        return `${sqlPrefix} (${this.getIndexColumns(index)})${this.getIndexWhereClause(index)}`;
     }
     parseTableDefinition(sql, cols) {
         const columns = {};
@@ -285,6 +296,17 @@ export class SqliteSchemaHelper extends SchemaHelper {
                     generated = `${match[2]} ${storage}`;
                 }
             }
+            // Strip string literals first (their contents could contain unbalanced parens), then
+            // repeatedly strip the innermost balanced `(...)` until none remain — a single pass would
+            // only remove the innermost level, leaving `collate` tokens inside nested CHECK/default
+            // expressions exposed to the column-collation regex.
+            let cleanDef = (columnDefinitions[col.name]?.definition ?? '').replace(/'[^']*'/g, '').replace(/"[^"]*"/g, '');
+            let prev;
+            do {
+                prev = cleanDef;
+                cleanDef = cleanDef.replace(/\([^()]*\)/g, '');
+            } while (cleanDef !== prev);
+            const collationMatch = /\bcollate\s+([`"']?)([\w\-.]+)\1/i.exec(cleanDef);
             return {
                 name: col.name,
                 type: col.type,
@@ -295,6 +317,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
                 unsigned: false,
                 autoincrement: !composite && col.pk && this.platform.isNumericColumn(mappedType) && hasAutoincrement,
                 generated,
+                collation: collationMatch ? collationMatch[2] : undefined,
             };
         });
     }
@@ -321,23 +344,23 @@ export class SqliteSchemaHelper extends SchemaHelper {
         // everything else is an expression that had its outer parens stripped
         return `(${value})`;
     }
-    async getEnumDefinitions(connection, tableName, schemaName, ctx) {
-        const prefix = this.getSchemaPrefix(schemaName);
-        const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
-        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get', ctx);
-        const checkConstraints = [...(tableDefinition.sql.match(/[`["'][^`\]"']+[`\]"'] text check \(.*?\)/gi) ?? [])];
-        return checkConstraints.reduce((o, item) => {
-            // check constraints are defined as (note that last closing paren is missing):
-            // `type` text check (`type` in ('local', 'global')
-            const match = /[`["']([^`\]"']+)[`\]"'] text check \(.* \((.*)\)/i.exec(item);
-            /* v8 ignore next */
-            if (match) {
-                o[match[1]] = match[2]
-                    .split(/,(?=\s*'(?:[^']|'')*'(?:\s*\)|$))/)
-                    .map((item) => /^\(?'((?:[^']|'')*)'/.exec(item.trim())[1].replace(/''/g, "'"));
+    /** Extract enum values from `IN (…)` CHECKs only — a `!= 'x'` check would otherwise be misread as a one-item enum. */
+    extractEnumValuesFromChecks(checks) {
+        const result = {};
+        for (const check of checks) {
+            if (!check.columnName || typeof check.expression !== 'string') {
+                continue;
             }
-            return o;
-        }, {});
+            const inClause = /\bin\s*\(([^)]*)\)/i.exec(check.expression);
+            if (!inClause) {
+                continue;
+            }
+            const items = [...inClause[1].matchAll(/'((?:[^']|'')*)'/g)].map(m => m[1].replace(/''/g, "'"));
+            if (items.length > 0) {
+                result[check.columnName] = items;
+            }
+        }
+        return result;
     }
     async getPrimaryKeys(connection, indexes, tableName, schemaName, ctx) {
         const prefix = this.getSchemaPrefix(schemaName);
@@ -350,6 +373,16 @@ export class SqliteSchemaHelper extends SchemaHelper {
         const sql = `pragma ${prefix}table_info(\`${tableName}\`)`;
         const cols = await connection.execute(sql, [], 'all', ctx);
         const indexes = await connection.execute(`pragma ${prefix}index_list(\`${tableName}\`)`, [], 'all', ctx);
+        // sqlite_master.sql holds the original CREATE INDEX statement — the only place a partial
+        // index's WHERE predicate is preserved (PRAGMA index_* don't expose it).
+        const indexSqls = await connection.execute(`select name, sql from ${prefix}sqlite_master where type = 'index' and tbl_name = ?`, [tableName], 'all', ctx);
+        const wherePredicates = new Map();
+        for (const row of indexSqls) {
+            const match = row.sql && SqliteSchemaHelper.PARTIAL_WHERE_RE.exec(row.sql);
+            if (match) {
+                wherePredicates.set(row.name, match[1].trim());
+            }
+        }
         const ret = [];
         for (const col of cols.filter(c => c.pk)) {
             ret.push({
@@ -362,12 +395,14 @@ export class SqliteSchemaHelper extends SchemaHelper {
         }
         for (const index of indexes.filter(index => !this.isImplicitIndex(index.name))) {
             const res = await connection.execute(`pragma ${prefix}index_info(\`${index.name}\`)`, [], 'all', ctx);
+            const where = wherePredicates.get(index.name);
             ret.push(...res.map(row => ({
                 columnNames: [row.name],
                 keyName: index.name,
                 unique: !!index.unique,
                 constraint: !!index.unique,
                 primary: false,
+                ...(where ? { where } : {}),
             })));
         }
         return this.mapIndexes(ret);
@@ -501,8 +536,102 @@ export class SqliteSchemaHelper extends SchemaHelper {
                 this.append(ret, this.getRenameIndexSQL(diff.name, index, oldIndexName));
             }
         }
+        for (const trigger of Object.values(diff.removedTriggers)) {
+            this.append(ret, this.dropTrigger(diff.toTable, trigger));
+        }
+        for (const trigger of Object.values(diff.changedTriggers)) {
+            this.append(ret, this.dropTrigger(diff.toTable, trigger));
+            this.append(ret, this.createTrigger(diff.toTable, trigger));
+        }
+        for (const trigger of Object.values(diff.addedTriggers)) {
+            this.append(ret, this.createTrigger(diff.toTable, trigger));
+        }
         return ret;
     }
+    /** Generates SQL to create SQLite triggers. SQLite requires one trigger per event. */
+    createTrigger(table, trigger) {
+        if (trigger.expression) {
+            return trigger.expression;
+        }
+        const timing = trigger.timing.toUpperCase();
+        const forEach = trigger.forEach === 'statement' ? 'STATEMENT' : 'ROW';
+        const ret = [];
+        for (const event of trigger.events) {
+            const name = trigger.events.length > 1 ? `${trigger.name}_${event}` : trigger.name;
+            const when = trigger.when ? `\n  when ${trigger.when}` : '';
+            ret.push(`create trigger ${this.quote(name)} ${timing} ${event.toUpperCase()} on ${table.getQuotedName()} for each ${forEach}${when} begin ${trigger.body}; end`);
+        }
+        return ret.join(';\n');
+    }
+    async getTableTriggers(connection, tableName) {
+        const rows = await connection.execute(`select name, sql from sqlite_master where type = 'trigger' and tbl_name = ?`, [tableName]);
+        // First pass: parse all triggers and collect names to detect multi-event groups
+        const parsedRows = [];
+        for (const row of rows) {
+            /* v8 ignore next 3 */
+            if (!row.sql) {
+                continue;
+            }
+            const parsed = this.parseTriggerDDL(row.sql, row.name);
+            if (parsed) {
+                parsedRows.push({ name: row.name, parsed });
+            }
+        }
+        const allNames = parsedRows.map(r => r.name);
+        const triggers = [];
+        const triggerMap = new Map();
+        for (const { name, parsed } of parsedRows) {
+            // Only strip event suffix when another trigger with the same base exists
+            const eventLower = parsed.events[0];
+            const candidateBase = name.endsWith(`_${eventLower}`) ? name.slice(0, -eventLower.length - 1) : null;
+            const baseName = candidateBase && allNames.some(n => n !== name && n.startsWith(`${candidateBase}_`)) ? candidateBase : name;
+            if (triggerMap.has(baseName)) {
+                const existing = triggerMap.get(baseName);
+                if (!existing.events.includes(parsed.events[0])) {
+                    existing.events.push(parsed.events[0]);
+                }
+                continue;
+            }
+            const trigger = { ...parsed, name: baseName };
+            triggers.push(trigger);
+            triggerMap.set(baseName, trigger);
+        }
+        return triggers;
+    }
+    parseTriggerDDL(sql, name) {
+        // Split at the last top-level BEGIN to separate header from body,
+        // so that a WHEN clause containing the word "begin" in a string literal doesn't confuse parsing.
+        const beginIdx = sql.search(/\bbegin\b(?=[^]*$)/i);
+        /* v8 ignore next 3 */
+        if (beginIdx === -1) {
+            return null;
+        }
+        const header = sql.slice(0, beginIdx);
+        const bodyPart = sql.slice(beginIdx);
+        const headerMatch = /create\s+trigger\s+["`]?\w+["`]?\s+(before|after|instead\s+of)\s+(insert|update|delete)\s+on\s+["`]?\w+["`]?\s*(?:for\s+each\s+(row|statement))?\s*(?:when\s+([\s\S]*?))?\s*$/i.exec(header);
+        /* v8 ignore next 3 */
+        if (!headerMatch) {
+            return null;
+        }
+        const bodyMatch = /^begin\s+([\s\S]*?)\s*end/i.exec(bodyPart);
+        /* v8 ignore next 3 */
+        if (!bodyMatch) {
+            return null;
+        }
+        const timing = headerMatch[1].toLowerCase();
+        const event = headerMatch[2].toLowerCase();
+        const forEach = (headerMatch[3]?.toLowerCase() ?? 'row');
+        const when = headerMatch[4]?.trim() || undefined;
+        const body = bodyMatch[1].trim().replace(/;\s*$/, '');
+        return {
+            name,
+            timing,
+            events: [event],
+            forEach,
+            body,
+            when,
+        };
+    }
     getAlterTempTableSQL(changedTable) {
         const tempName = `${changedTable.toTable.name}__temp_alter`;
         const quotedName = this.quote(changedTable.toTable.name);