@mikro-orm/sql 7.0.17 → 7.0.18-dev.0

package/query/QueryBuilder.js

@@ -35,6 +35,7 @@ export class QueryBuilder {
     #state = _a.createDefaultState();
     #helper;
     #query;
+    #abortOptions;
     /** @internal */
     static createDefaultState() {
         return {
@@ -159,6 +160,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 +722,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 +831,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 +853,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) => {
@@ -963,7 +1011,7 @@ export class QueryBuilder {
         if (cached?.data !== undefined) {
             return cached.data;
         }
-        const loggerContext = { id: this.em?.id, ...this.loggerContext };
+        const loggerContext = { id: this.em?.id, ...this.loggerContext, ...this.#abortOptions };
         const res = await this.getConnection().execute(query.sql, query.params, method, this.context, loggerContext);
         const meta = this.mainAlias.meta;
         if (!options.mapResults || !meta) {
@@ -1017,9 +1065,10 @@ export class QueryBuilder {
         options ??= {};
         options.mergeResults ??= true;
         options.mapResults ??= true;
+        const chunkSize = options.chunkSize ?? 100;
         const query = this.toQuery();
-        const loggerContext = { id: this.em?.id, ...this.loggerContext };
-        const res = this.getConnection().stream(query.sql, query.params, this.context, loggerContext);
+        const loggerContext = { id: this.em?.id, ...this.loggerContext, ...this.#abortOptions };
+        const res = this.getConnection().stream(query.sql, query.params, this.context, loggerContext, chunkSize);
         const meta = this.mainAlias.meta;
         if (options.rawResults || !meta) {
             yield* res;
@@ -1242,6 +1291,7 @@ export class QueryBuilder {
         qb.#state.finalized = false;
         qb.#query = undefined;
         qb.#helper = qb.createQueryBuilderHelper();
+        qb.#abortOptions = this.#abortOptions;
         return qb;
     }
     /**
@@ -1257,6 +1307,13 @@ export class QueryBuilder {
         this.loggerContext ??= {};
         return this.loggerContext;
     }
+    /**
+     * Configures cancellation behavior for this query builder. The signal is forwarded to the
+     * underlying database client; see {@apilink AbortQueryOptions} for the available strategies.
+     */
+    setAbortOptions(options) {
+        this.#abortOptions = options;
+    }
     fromVirtual(meta) {
         if (typeof meta.expression === 'string') {
             return `(${meta.expression}) as ${this.platform.quoteIdentifier(this.alias)}`;
@@ -1618,7 +1675,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);
@@ -1634,6 +1698,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) {
@@ -1797,6 +1933,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);
@@ -2016,6 +2155,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.d.ts

@@ -1,7 +1,7 @@
-import { type Configuration, type Dictionary, type EntityMetadata, type Transaction } from '@mikro-orm/core';
+import { type Configuration, type Dictionary, type EntityMetadata, type Routine, type Transaction, type Type } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
-import type { DatabaseView } from '../typings.js';
+import type { DatabaseView, SqlRoutineDef } from '../typings.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /**
  * @internal
@@ -24,6 +24,8 @@ export declare class DatabaseSchema {
     setViews(views: DatabaseView[]): void;
     getView(name: string): DatabaseView | undefined;
     hasView(name: string): boolean;
+    addRoutine(routine: SqlRoutineDef): SqlRoutineDef;
+    getRoutines(): SqlRoutineDef[];
     setNativeEnums(nativeEnums: Dictionary<{
         name: string;
         schema?: string;
@@ -43,7 +45,32 @@ export declare class DatabaseSchema {
     hasNativeEnum(name: string): boolean;
     getNamespaces(): string[];
     static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[], takeTables?: (string | RegExp)[], skipTables?: (string | RegExp)[], skipViews?: (string | RegExp)[], ctx?: Transaction): Promise<DatabaseSchema>;
+    /** Separate from `create()` so the comparator only pays for routine introspection when the user actually defined routines. SQLite/libSQL helpers return []. */
+    loadRoutines(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, schemas?: string[]): Promise<void>;
     static fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, em?: any): DatabaseSchema;
+    /** Separate from {@link fromMetadata} so the comparator only walks routines when the user defined any. */
+    addRoutinesFromMetadata(routines: readonly Routine[], platform: AbstractSqlPlatform, em?: any): void;
+    /**
+     * Normalises a routine's `returns` config to the `{ type, runtimeType, nullable }` shape the
+     * DDL side and introspection-comparator both consume. Supports both `{ type: SomeType }`
+     * (Type drives column + runtime types) and `{ runtimeType, columnType, ... }` (explicit).
+     *
+     * @internal
+     */
+    static normaliseRoutineReturns(returns: Routine['returns'], platform: AbstractSqlPlatform): {
+        type: string;
+        runtimeType: string;
+        nullable?: boolean;
+    } | undefined;
+    /**
+     * Maps a routine param's declared `type` to a dialect-specific SQL column type. A `Type`
+     * instance (when the user passed a `Type` class/instance at `type`) routes through
+     * `Type.getColumnType` so its dialect-aware mapping wins. String aliases (`'string'`,
+     * `'number'`, …) go through the platform's type registry; literal SQL types pass through.
+     *
+     * @internal
+     */
+    static resolveRoutineColumnType(type: string | Type<unknown>, platform: AbstractSqlPlatform): string;
     private static getViewDefinition;
     private static getSchemaName;
     /**

package/schema/DatabaseSchema.js

@@ -1,5 +1,6 @@
 import { ReferenceKind, isRaw, } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
+import { getTablePartitioning } from './partitioning.js';
 /**
  * @internal
  */
@@ -7,6 +8,7 @@ export class DatabaseSchema {
     name;
     #tables = [];
     #views = [];
+    #routines = [];
     #namespaces = new Set();
     #nativeEnums = {}; // for postgres
     #platform;
@@ -64,6 +66,16 @@ export class DatabaseSchema {
     hasView(name) {
         return !!this.getView(name);
     }
+    addRoutine(routine) {
+        this.#routines.push(routine);
+        if (routine.schema != null) {
+            this.#namespaces.add(routine.schema);
+        }
+        return routine;
+    }
+    getRoutines() {
+        return this.#routines;
+    }
     setNativeEnums(nativeEnums) {
         this.#nativeEnums = nativeEnums;
         for (const nativeEnum of Object.values(nativeEnums)) {
@@ -110,6 +122,10 @@ export class DatabaseSchema {
         }
         return schema;
     }
+    /** Separate from `create()` so the comparator only pays for routine introspection when the user actually defined routines. SQLite/libSQL helpers return []. */
+    async loadRoutines(connection, platform, schemas = []) {
+        this.#routines = await platform.getSchemaHelper().getAllRoutines(connection, schemas);
+    }
     static fromMetadata(metadata, platform, config, schemaName, em) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema'));
         const nativeEnums = {};
@@ -173,6 +189,9 @@ export class DatabaseSchema {
             }
             const table = schema.addTable(meta.collection, this.getSchemaName(meta, config, schemaName));
             table.comment = meta.comment;
+            if (meta.partitionBy) {
+                table.setPartitioning(getTablePartitioning(meta, this.getSchemaName(meta, config, schemaName), id => platform.quoteIdentifier(id)));
+            }
             // For TPT child entities, only use ownProps (properties defined in this entity only)
             // For all other entities (including TPT root), use all props
             const propsToProcess = meta.inheritanceType === 'tpt' && meta.tptParent && meta.ownProps ? meta.ownProps : meta.props;
@@ -220,9 +239,127 @@ 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;
     }
+    /** Separate from {@link fromMetadata} so the comparator only walks routines when the user defined any. */
+    addRoutinesFromMetadata(routines, platform, em) {
+        const resolveBody = (raw) => {
+            if (raw == null) {
+                return undefined;
+            }
+            if (typeof raw === 'string') {
+                return raw;
+            }
+            if (isRaw(raw)) {
+                return platform.formatQuery(raw.sql, raw.params);
+            }
+            return undefined;
+        };
+        const helper = platform.getSchemaHelper();
+        for (const routine of routines) {
+            const paramMap = routine.params.reduce((o, p) => {
+                o[p.name] = helper.routineParamReference(p.name);
+                return o;
+            }, {});
+            const evaluated = typeof routine.body === 'function' ? routine.body(paramMap, em) : routine.body;
+            const body = resolveBody(evaluated);
+            const returns = DatabaseSchema.normaliseRoutineReturns(routine.returns, platform);
+            this.addRoutine({
+                name: routine.name,
+                // MySQL has no schema namespace for routines, so leave undefined to align with the introspection side.
+                schema: routine.schema ?? (platform.getDefaultSchemaName() != null ? this.name : undefined),
+                type: routine.type,
+                language: routine.language,
+                comment: routine.comment,
+                security: routine.security,
+                definer: routine.definer,
+                deterministic: routine.deterministic,
+                dataAccess: routine.dataAccess,
+                body,
+                expression: routine.expression,
+                ignoreSchemaChanges: routine.ignoreSchemaChanges,
+                params: routine.params.map(p => ({
+                    name: p.name,
+                    type: DatabaseSchema.resolveRoutineColumnType(p.type, platform),
+                    direction: helper.normaliseRoutineParamDirection(p.direction),
+                    nullable: p.nullable,
+                    defaultRaw: p.defaultRaw,
+                })),
+                returns,
+            });
+        }
+    }
+    /**
+     * Normalises a routine's `returns` config to the `{ type, runtimeType, nullable }` shape the
+     * DDL side and introspection-comparator both consume. Supports both `{ type: SomeType }`
+     * (Type drives column + runtime types) and `{ runtimeType, columnType, ... }` (explicit).
+     *
+     * @internal
+     */
+    static normaliseRoutineReturns(returns, platform) {
+        if (!returns || typeof returns !== 'object') {
+            return undefined;
+        }
+        if ('runtimeType' in returns) {
+            return {
+                type: (returns.columnType ?? returns.runtimeType),
+                runtimeType: returns.runtimeType,
+                nullable: returns.nullable,
+            };
+        }
+        if ('type' in returns && returns.type) {
+            const instance = typeof returns.type === 'function' ? new returns.type() : returns.type;
+            return {
+                type: DatabaseSchema.resolveRoutineColumnType(instance, platform),
+                runtimeType: instance.runtimeType,
+                nullable: returns.nullable,
+            };
+        }
+        return undefined;
+    }
+    /**
+     * Maps a routine param's declared `type` to a dialect-specific SQL column type. A `Type`
+     * instance (when the user passed a `Type` class/instance at `type`) routes through
+     * `Type.getColumnType` so its dialect-aware mapping wins. String aliases (`'string'`,
+     * `'number'`, …) go through the platform's type registry; literal SQL types pass through.
+     *
+     * @internal
+     */
+    static resolveRoutineColumnType(type, platform) {
+        if (typeof type !== 'string') {
+            return type.getColumnType({ columnTypes: [], runtimeType: 'any' }, platform);
+        }
+        const lower = type.toLowerCase();
+        const aliases = {
+            string: 'string',
+            number: 'integer',
+            bigint: 'bigint',
+            boolean: 'boolean',
+            date: 'datetime',
+            buffer: 'blob',
+        };
+        const mappedKey = aliases[lower];
+        if (!mappedKey) {
+            return type;
+        }
+        const t = platform.getMappedType(mappedKey);
+        return t.getColumnType({ type: mappedKey, length: undefined }, platform);
+    }
     static getViewDefinition(meta, em, platform) {
         if (typeof meta.expression === 'string') {
             return meta.expression;

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, TablePartitioning, SqlTriggerDef } from '../typings.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /**
  * @internal
@@ -15,6 +15,14 @@ export declare class DatabaseTable {
         items: string[];
     }>;
     comment?: string;
+    partitioning?: TablePartitioning;
+    /**
+     * Effective collation the column defaults to when no explicit `COLLATE` is set on a column.
+     * For MySQL/MariaDB this is the table collation; for PostgreSQL and MSSQL this is the database default;
+     * SQLite has no configurable default. Used by `SchemaComparator.diffCollation` to avoid flapping
+     * when a property explicitly names the default collation.
+     */
+    collation?: string;
     constructor(platform: AbstractSqlPlatform, name: string, schema?: string | undefined);
     getQuotedName(): string;
     getColumns(): Column[];
@@ -22,11 +30,17 @@ export declare class DatabaseTable {
     removeColumn(name: string): void;
     getIndexes(): IndexDef[];
     getChecks(): CheckDef[];
+    getPartitioning(): TablePartitioning | undefined;
+    /** @internal */
+    setPartitioning(partitioning?: TablePartitioning): void;
+    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 +61,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;
@@ -62,6 +78,7 @@ export declare class DatabaseTable {
         name?: string;
         type?: string;
         expression?: string | IndexCallback<any>;
+        where?: string | Dictionary;
         deferMode?: DeferMode | `${DeferMode}`;
         options?: Dictionary;
         columns?: {
@@ -77,6 +94,8 @@ export declare class DatabaseTable {
         disabled?: boolean;
         clustered?: boolean;
     }, type: 'index' | 'unique' | 'primary'): void;
+    private processIndexWhere;
     addCheck(check: CheckDef): void;
+    addTrigger(trigger: SqlTriggerDef): void;
     toJSON(): Dictionary;
 }