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

package/query/QueryBuilder.js

@@ -159,6 +159,41 @@ export class QueryBuilder {
     insert(data) {
         return this.init(QueryType.INSERT, data);
     }
+    /**
+     * Creates an INSERT ... SELECT query that copies rows from the source query.
+     *
+     * Column resolution (3 tiers):
+     * 1. No explicit select on source, no explicit columns → all cloneable columns derived from entity metadata
+     * 2. Explicit select on source, no explicit columns → columns derived from selected field names
+     * 3. Explicit `columns` option → user-provided column list
+     *
+     * @example
+     * ```ts
+     * // Clone all fields (columns auto-derived from metadata)
+     * const source = em.createQueryBuilder(User).where({ id: 1 });
+     * await em.createQueryBuilder(User).insertFrom(source).execute();
+     *
+     * // Clone with overrides via raw() aliases
+     * const source = em.createQueryBuilder(User)
+     *   .select(['name', raw("'new@email.com'").as('email')])
+     *   .where({ id: 1 });
+     * await em.createQueryBuilder(User).insertFrom(source).execute();
+     *
+     * // Explicit columns for full control
+     * await em.createQueryBuilder(User)
+     *   .insertFrom(source, { columns: ['name', 'email'] })
+     *   .execute();
+     * ```
+     */
+    insertFrom(subQuery, options) {
+        this.ensureNotFinalized();
+        this.#state.type = QueryType.INSERT;
+        this.#state.insertSubQuery = subQuery;
+        if (options?.columns) {
+            this.#state.insertColumns = Utils.asArray(options.columns);
+        }
+        return this;
+    }
     /**
      * Creates an UPDATE query with the given data.
      * Use `where()` to specify which rows to update.
@@ -686,6 +721,12 @@ export class QueryBuilder {
     hasFlag(flag) {
         return this.#state.flags.has(flag);
     }
+    /** @internal */
+    setPartitionLimit(opts) {
+        this.ensureNotFinalized();
+        this.#state.partitionLimit = opts;
+        return this;
+    }
     cache(config = true) {
         this.ensureNotFinalized();
         this.#state.cache = config;
@@ -789,12 +830,18 @@ export class QueryBuilder {
         if (this.#state.lockMode) {
             this.helper.getLockSQL(qb, this.#state.lockMode, this.#state.lockTables, this.#state.joins);
         }
-        this.processReturningStatement(qb, this.mainAlias.meta, this.#state.data, this.#state.returning);
+        this.processReturningStatement(qb, this.mainAlias.meta, this.#state.insertSubQuery ? undefined : this.#state.data, this.#state.returning);
+        if (this.#state.partitionLimit) {
+            return (this.#query.qb = this.wrapPartitionLimitSubQuery(qb));
+        }
         return (this.#query.qb = qb);
     }
     processReturningStatement(qb, meta, data, returning) {
         const usesReturningStatement = this.platform.usesReturningStatement() || this.platform.usesOutputStatement();
-        if (!meta || !data || !usesReturningStatement) {
+        if (!meta || !usesReturningStatement) {
+            return;
+        }
+        if (!data && !this.#state.insertSubQuery) {
             return;
         }
         // always respect explicit returning hint
@@ -805,13 +852,13 @@ export class QueryBuilder {
         if (this.type === QueryType.INSERT) {
             const returningProps = meta.hydrateProps
                 .filter(prop => prop.returning || (prop.persist !== false && ((prop.primary && prop.autoincrement) || prop.defaultRaw)))
-                .filter(prop => !(prop.name in data));
+                .filter(prop => !data || !(prop.name in data));
             if (returningProps.length > 0) {
                 qb.returning(Utils.flatten(returningProps.map(prop => prop.fieldNames)));
             }
             return;
         }
-        if (this.type === QueryType.UPDATE) {
+        if (this.type === QueryType.UPDATE && data) {
             const returningProps = meta.hydrateProps.filter(prop => prop.fieldNames && isRaw(data[prop.fieldNames[0]]));
             if (returningProps.length > 0) {
                 qb.returning(returningProps.flatMap((prop) => {
@@ -1603,7 +1650,14 @@ export class QueryBuilder {
                 break;
             }
             case QueryType.INSERT:
-                qb.insert(this.#state.data);
+                if (this.#state.insertSubQuery) {
+                    const columns = this.resolveInsertFromColumns();
+                    const compiled = this.#state.insertSubQuery.toQuery();
+                    qb.insertSelect(columns, raw(compiled.sql, compiled.params));
+                }
+                else {
+                    qb.insert(this.#state.data);
+                }
                 break;
             case QueryType.UPDATE:
                 qb.update(this.#state.data);
@@ -1619,6 +1673,78 @@ export class QueryBuilder {
         }
         return qb;
     }
+    /**
+     * Resolves the INSERT column list for `insertFrom()`.
+     *
+     * Tier 1: Explicit `insertColumns` from `options.columns` → map property names to field names
+     * Tier 2: Source QB has explicit select fields → derive from those
+     * Tier 3: Derive from target entity metadata (all cloneable columns), auto-populate source select
+     */
+    resolveInsertFromColumns() {
+        const meta = this.mainAlias.meta;
+        const subQuery = this.#state.insertSubQuery;
+        // Tier 1: explicit columns
+        if (this.#state.insertColumns?.length) {
+            return this.#state.insertColumns.flatMap(col => {
+                const prop = meta?.properties[col];
+                return prop?.fieldNames ?? [col];
+            });
+        }
+        // Tier 2: source QB has explicit select fields
+        const sourceFields = subQuery.state.fields;
+        if (sourceFields && subQuery.state.type === QueryType.SELECT) {
+            return sourceFields
+                .filter((field) => typeof field === 'string' || isRaw(field))
+                .flatMap((field) => {
+                if (typeof field === 'string') {
+                    // Strip alias prefix like 'a0.'
+                    const bare = field.replace(/^\w+\./, '');
+                    const prop = meta?.properties[bare];
+                    return prop?.fieldNames ?? [bare];
+                }
+                // RawQueryFragment with alias: raw('...').as('name')
+                const alias = String(field.params[field.params.length - 1]);
+                const prop = meta?.properties[alias];
+                return prop?.fieldNames ?? [alias];
+            });
+        }
+        // Tier 3: derive from metadata — all cloneable columns
+        const cloneableProps = this.getCloneableProps(meta);
+        const selectFields = [];
+        const columns = [];
+        for (const prop of cloneableProps) {
+            for (const fieldName of prop.fieldNames) {
+                columns.push(fieldName);
+                selectFields.push(fieldName);
+            }
+        }
+        // Auto-populate source select with matching fields
+        if (!sourceFields) {
+            subQuery.select(selectFields);
+        }
+        return columns;
+    }
+    /** Returns properties that are safe to clone (persistable, non-PK, non-generated). */
+    getCloneableProps(meta) {
+        return meta.props.filter(prop => {
+            if (prop.persist === false) {
+                return false;
+            }
+            if (prop.primary) {
+                return false;
+            }
+            if (!prop.fieldNames?.length) {
+                return false;
+            }
+            if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+                return false;
+            }
+            if (prop.kind === ReferenceKind.EMBEDDED && !prop.object) {
+                return false;
+            }
+            return true;
+        });
+    }
     applyDiscriminatorCondition() {
         const meta = this.mainAlias.meta;
         if (meta.root.inheritanceType !== 'sti' || !meta.discriminatorValue) {
@@ -1782,6 +1908,9 @@ export class QueryBuilder {
             (this.#state.limit > 0 || this.#state.offset > 0)) {
             this.wrapPaginateSubQuery(meta);
         }
+        if (this.#state.partitionLimit) {
+            this.preparePartitionLimit();
+        }
         if (meta &&
             (this.#state.flags.has(QueryFlag.UPDATE_SUB_QUERY) || this.#state.flags.has(QueryFlag.DELETE_SUB_QUERY))) {
             this.wrapModifySubQuery(meta);
@@ -2001,6 +2130,40 @@ export class QueryBuilder {
             [Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: raw(sql, params) },
         });
     }
+    /**
+     * Wraps the inner query (which has ROW_NUMBER in SELECT) with an outer query
+     * that filters by the __rn column to apply per-parent limiting.
+     */
+    wrapPartitionLimitSubQuery(innerQb) {
+        const { limit, offset = 0 } = this.#state.partitionLimit;
+        const rnCol = this.platform.quoteIdentifier('__rn');
+        innerQb.as(this.mainAlias.aliasName);
+        const outerQb = this.platform.createNativeQueryBuilder();
+        outerQb.select('*').from(innerQb);
+        outerQb.where(`${rnCol} > ? and ${rnCol} <= ?`, [offset, offset + limit]);
+        outerQb.orderBy(rnCol);
+        return outerQb;
+    }
+    /**
+     * Adds ROW_NUMBER() OVER (PARTITION BY ...) to the SELECT list and prepares
+     * the query state for per-parent limiting. The actual wrapping into a subquery
+     * with __rn filtering happens in getNativeQuery().
+     */
+    preparePartitionLimit() {
+        const { partitionBy } = this.#state.partitionLimit;
+        // `partitionBy` is always a declared property name, so mapper returns a string here.
+        const partitionCol = this.helper.mapper(partitionBy, this.type, undefined, null);
+        const quotedPartition = partitionCol
+            .split('.')
+            .map(e => this.platform.quoteIdentifier(e))
+            .join('.');
+        const queryOrder = this.helper.getQueryOrder(this.type, this.#state.orderBy, this.#state.populateMap, this.#state.collation);
+        const orderBySql = queryOrder.length > 0 ? Utils.unique(queryOrder).join(', ') : quotedPartition;
+        const rnAlias = this.platform.quoteIdentifier('__rn');
+        this.#state.fields.push(raw(`row_number() over (partition by ${quotedPartition} order by ${orderBySql}) as ${rnAlias}`));
+        // Moved into the OVER clause; outer query re-applies via wrapPartitionLimitSubQuery
+        this.#state.orderBy = [];
+    }
     /**
      * Computes the set of populate paths from the _populate hints.
      */

package/schema/DatabaseSchema.js

@@ -220,6 +220,20 @@ export class DatabaseSchema {
                     columnName,
                 });
             }
+            for (const trigger of meta.triggers) {
+                const body = isRaw(trigger.body)
+                    ? platform.formatQuery(trigger.body.sql, trigger.body.params)
+                    : trigger.body;
+                table.addTrigger({
+                    name: trigger.name,
+                    timing: trigger.timing,
+                    events: trigger.events,
+                    forEach: trigger.forEach ?? 'row',
+                    body: body ?? '',
+                    when: trigger.when,
+                    expression: trigger.expression,
+                });
+            }
         }
         return schema;
     }

package/schema/DatabaseTable.d.ts

@@ -1,6 +1,6 @@
 import { type Configuration, type DeferMode, type Dictionary, type EntityMetadata, type EntityProperty, type IndexCallback, type NamingStrategy } from '@mikro-orm/core';
 import type { SchemaHelper } from './SchemaHelper.js';
-import type { CheckDef, Column, ForeignKey, IndexDef } from '../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, SqlTriggerDef } from '../typings.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /**
  * @internal
@@ -22,11 +22,14 @@ export declare class DatabaseTable {
     removeColumn(name: string): void;
     getIndexes(): IndexDef[];
     getChecks(): CheckDef[];
+    getTriggers(): SqlTriggerDef[];
     /** @internal */
     setIndexes(indexes: IndexDef[]): void;
     /** @internal */
     setChecks(checks: CheckDef[]): void;
     /** @internal */
+    setTriggers(triggers: SqlTriggerDef[]): void;
+    /** @internal */
     setForeignKeys(fks: Dictionary<ForeignKey>): void;
     init(cols: Column[], indexes: IndexDef[] | undefined, checks: CheckDef[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;
     addColumn(column: Column): void;
@@ -47,6 +50,8 @@ export declare class DatabaseTable {
     hasIndex(indexName: string): boolean;
     getCheck(checkName: string): CheckDef | undefined;
     hasCheck(checkName: string): boolean;
+    getTrigger(triggerName: string): SqlTriggerDef | undefined;
+    hasTrigger(triggerName: string): boolean;
     getPrimaryKey(): IndexDef | undefined;
     hasPrimaryKey(): boolean;
     private getForeignKeyDeclaration;
@@ -78,5 +83,6 @@ export declare class DatabaseTable {
         clustered?: boolean;
     }, type: 'index' | 'unique' | 'primary'): void;
     addCheck(check: CheckDef): void;
+    addTrigger(trigger: SqlTriggerDef): void;
     toJSON(): Dictionary;
 }

package/schema/DatabaseTable.js

@@ -8,6 +8,7 @@ export class DatabaseTable {
     #columns = {};
     #indexes = [];
     #checks = [];
+    #triggers = [];
     #foreignKeys = {};
     #platform;
     nativeEnums = {}; // for postgres
@@ -35,6 +36,9 @@ export class DatabaseTable {
     getChecks() {
         return this.#checks;
     }
+    getTriggers() {
+        return this.#triggers;
+    }
     /** @internal */
     setIndexes(indexes) {
         this.#indexes = indexes;
@@ -44,6 +48,10 @@ export class DatabaseTable {
         this.#checks = checks;
     }
     /** @internal */
+    setTriggers(triggers) {
+        this.#triggers = triggers;
+    }
+    /** @internal */
     setForeignKeys(fks) {
         this.#foreignKeys = fks;
     }
@@ -598,6 +606,12 @@ export class DatabaseTable {
     hasCheck(checkName) {
         return !!this.getCheck(checkName);
     }
+    getTrigger(triggerName) {
+        return this.#triggers.find(t => t.name === triggerName);
+    }
+    hasTrigger(triggerName) {
+        return !!this.getTrigger(triggerName);
+    }
     getPrimaryKey() {
         return this.#indexes.find(i => i.primary);
     }
@@ -885,6 +899,9 @@ export class DatabaseTable {
     addCheck(check) {
         this.#checks.push(check);
     }
+    addTrigger(trigger) {
+        this.#triggers.push(trigger);
+    }
     toJSON() {
         const columns = this.#columns;
         const columnsMapped = Utils.keys(columns).reduce((o, col) => {
@@ -929,6 +946,7 @@ export class DatabaseTable {
             columns: columnsMapped,
             indexes: this.#indexes,
             checks: this.#checks,
+            triggers: this.#triggers,
             foreignKeys: this.#foreignKeys,
             nativeEnums: this.nativeEnums,
             comment: this.comment,

package/schema/SchemaComparator.d.ts

@@ -69,6 +69,7 @@ export declare class SchemaComparator {
      * @see https://github.com/mikro-orm/mikro-orm/issues/7308
      */
     private diffViewExpression;
+    private diffTrigger;
     parseJsonDefault(defaultValue?: string | null): Dictionary | string | null;
     hasSameDefaultValue(from: Column, to: Column): boolean;
     private mapColumnToProperty;

package/schema/SchemaComparator.js

@@ -176,14 +176,17 @@ export class SchemaComparator {
             addedForeignKeys: {},
             addedIndexes: {},
             addedChecks: {},
+            addedTriggers: {},
             changedColumns: {},
             changedForeignKeys: {},
             changedIndexes: {},
             changedChecks: {},
+            changedTriggers: {},
             removedColumns: {},
             removedForeignKeys: {},
             removedIndexes: {},
             removedChecks: {},
+            removedTriggers: {},
             renamedColumns: {},
             renamedIndexes: {},
             fromTable,
@@ -309,6 +312,33 @@ export class SchemaComparator {
             tableDifferences.changedChecks[check.name] = toTableCheck;
             changes++;
         }
+        const fromTableTriggers = fromTable.getTriggers();
+        const toTableTriggers = toTable.getTriggers();
+        for (const trigger of toTableTriggers) {
+            if (fromTable.hasTrigger(trigger.name)) {
+                continue;
+            }
+            tableDifferences.addedTriggers[trigger.name] = trigger;
+            this.log(`trigger ${trigger.name} added to table ${tableDifferences.name}`, { trigger });
+            changes++;
+        }
+        for (const trigger of fromTableTriggers) {
+            if (!toTable.hasTrigger(trigger.name)) {
+                tableDifferences.removedTriggers[trigger.name] = trigger;
+                this.log(`trigger ${trigger.name} removed from table ${tableDifferences.name}`);
+                changes++;
+                continue;
+            }
+            const toTableTrigger = toTable.getTrigger(trigger.name);
+            if (this.diffTrigger(trigger, toTableTrigger)) {
+                this.log(`trigger ${trigger.name} changed in table ${tableDifferences.name}`, {
+                    fromTableTrigger: trigger,
+                    toTableTrigger,
+                });
+                tableDifferences.changedTriggers[trigger.name] = toTableTrigger;
+                changes++;
+            }
+        }
         const fromForeignKeys = { ...fromTable.getForeignKeys() };
         const toForeignKeys = { ...toTable.getForeignKeys() };
         for (const fromConstraint of Object.values(fromForeignKeys)) {
@@ -714,6 +744,30 @@ export class SchemaComparator {
         }
         return true;
     }
+    diffTrigger(from, to) {
+        // Raw DDL expression cannot be meaningfully compared to introspected
+        // trigger metadata, so skip diffing when the metadata side uses it.
+        if (to.expression) {
+            // Both sides have expression — compare the raw DDL directly
+            if (from.expression) {
+                return this.diffExpression(from.expression, to.expression);
+            }
+            // Only metadata side has expression — the raw DDL cannot be compared to
+            // introspected metadata. Changes to the expression value won't be detected;
+            // drop and recreate the trigger manually to apply expression changes.
+            return false;
+        }
+        if (from.timing !== to.timing || from.forEach !== to.forEach) {
+            return true;
+        }
+        if ([...from.events].sort().join(',') !== [...to.events].sort().join(',')) {
+            return true;
+        }
+        if ((from.when ?? '') !== (to.when ?? '')) {
+            return true;
+        }
+        return this.diffExpression(from.body, to.body);
+    }
     parseJsonDefault(defaultValue) {
         /* v8 ignore next */
         if (!defaultValue) {

package/schema/SchemaHelper.d.ts

@@ -1,7 +1,7 @@
 import { type Connection, type Dictionary, type Options, type Transaction, type RawQueryFragment } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
-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 { DatabaseSchema } from './DatabaseSchema.js';
 import type { DatabaseTable } from './DatabaseTable.js';
 /** Base class for database-specific schema helpers. Provides SQL generation for DDL operations. */
@@ -84,6 +84,16 @@ export declare abstract class SchemaHelper {
     getReferencedTableName(referencedTableName: string, schema?: string): string;
     createIndex(index: IndexDef, table: DatabaseTable, createPrimary?: boolean): string;
     createCheck(table: DatabaseTable, check: CheckDef): string;
+    /**
+     * Generates SQL to create a database trigger on a table.
+     * Override in driver-specific helpers for custom DDL (e.g., PostgreSQL function wrapping).
+     */
+    createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    /**
+     * Generates SQL to drop a database trigger from a table.
+     * Override in driver-specific helpers for custom DDL.
+     */
+    dropTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
     /** @internal */
     getTableName(table: string, schema?: string): string;
     getTablesGroupedBySchemas(tables: Table[]): Map<string | undefined, Table[]>;

package/schema/SchemaHelper.js

@@ -204,6 +204,12 @@ export class SchemaHelper {
         for (const check of Object.values(diff.changedChecks)) {
             ret.push(this.dropConstraint(diff.name, check.name));
         }
+        for (const trigger of Object.values(diff.removedTriggers)) {
+            ret.push(this.dropTrigger(diff.toTable, trigger));
+        }
+        for (const trigger of Object.values(diff.changedTriggers)) {
+            ret.push(this.dropTrigger(diff.toTable, trigger));
+        }
         /* v8 ignore next */
         if (!safe && Object.values(diff.removedColumns).length > 0) {
             ret.push(this.getDropColumnsSQL(tableName, Object.values(diff.removedColumns), schemaName));
@@ -263,6 +269,12 @@ export class SchemaHelper {
         for (const check of Object.values(diff.changedChecks)) {
             ret.push(this.createCheck(diff.toTable, check));
         }
+        for (const trigger of Object.values(diff.addedTriggers)) {
+            ret.push(this.createTrigger(diff.toTable, trigger));
+        }
+        for (const trigger of Object.values(diff.changedTriggers)) {
+            ret.push(this.createTrigger(diff.toTable, trigger));
+        }
         if ('changedComment' in diff) {
             ret.push(this.alterTableComment(diff.toTable, diff.changedComment));
         }
@@ -521,6 +533,9 @@ export class SchemaHelper {
             for (const check of table.getChecks()) {
                 this.append(ret, this.createCheck(table, check));
             }
+            for (const trigger of table.getTriggers()) {
+                this.append(ret, this.createTrigger(table, trigger));
+            }
         }
         return ret;
     }
@@ -600,6 +615,33 @@ export class SchemaHelper {
     createCheck(table, check) {
         return `alter table ${table.getQuotedName()} add constraint ${this.quote(check.name)} check (${check.expression})`;
     }
+    /**
+     * Generates SQL to create a database trigger on a table.
+     * Override in driver-specific helpers for custom DDL (e.g., PostgreSQL function wrapping).
+     */
+    /* v8 ignore next 10 */
+    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 ? ` when (${trigger.when})` : '';
+        return `create trigger ${this.quote(trigger.name)} ${timing} ${events} on ${table.getQuotedName()} for each ${forEach}${when} begin ${trigger.body}; end`;
+    }
+    /**
+     * Generates SQL to drop a database trigger from a table.
+     * Override in driver-specific helpers for custom DDL.
+     */
+    dropTrigger(table, trigger) {
+        if (trigger.events.length > 1) {
+            return trigger.events
+                .map(event => `drop trigger if exists ${this.quote(`${trigger.name}_${event}`)}`)
+                .join(';\n');
+        }
+        return `drop trigger if exists ${this.quote(trigger.name)}`;
+    }
     /** @internal */
     getTableName(table, schema) {
         if (schema && schema !== this.platform.getDefaultSchemaName()) {

package/schema/SqlSchemaGenerator.js

@@ -300,11 +300,18 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 for (const check of newTable.getChecks()) {
                     this.append(sql, this.helper.createCheck(newTable, check));
                 }
+                for (const trigger of newTable.getTriggers()) {
+                    this.append(sql, this.helper.createTrigger(newTable, trigger));
+                }
                 this.append(ret, sql, true);
             }
         }
         if (options.dropTables && !options.safe) {
             for (const table of Object.values(schemaDiff.removedTables)) {
+                // Drop triggers before the table so driver-specific cleanup runs (e.g. PostgreSQL function removal)
+                for (const trigger of table.getTriggers()) {
+                    this.append(ret, this.helper.dropTrigger(table, trigger));
+                }
                 this.append(ret, this.helper.dropTableIfExists(table.name, table.schema));
             }
             if (Utils.hasObjectKeys(schemaDiff.removedTables)) {

package/typings.d.ts

@@ -108,6 +108,16 @@ export interface CheckDef<T = unknown> {
     definition?: string;
     columnName?: string;
 }
+/** Resolved trigger definition for schema operations (all callbacks resolved to strings). */
+export interface SqlTriggerDef {
+    name: string;
+    timing: 'before' | 'after' | 'instead of';
+    events: ('insert' | 'update' | 'delete' | 'truncate')[];
+    forEach: 'row' | 'statement';
+    body: string;
+    when?: string;
+    expression?: string;
+}
 export interface ColumnDifference {
     oldColumnName: string;
     column: Column;
@@ -130,6 +140,9 @@ export interface TableDifference {
     addedChecks: Dictionary<CheckDef>;
     changedChecks: Dictionary<CheckDef>;
     removedChecks: Dictionary<CheckDef>;
+    addedTriggers: Dictionary<SqlTriggerDef>;
+    changedTriggers: Dictionary<SqlTriggerDef>;
+    removedTriggers: Dictionary<SqlTriggerDef>;
     addedForeignKeys: Dictionary<ForeignKey>;
     changedForeignKeys: Dictionary<ForeignKey>;
     removedForeignKeys: Dictionary<ForeignKey>;