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

package/schema/SchemaHelper.js

@@ -110,7 +110,7 @@ export class SchemaHelper {
             // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
             sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName}`;
             const columns = this.platform.getJsonIndexDefinition(index);
-            return `${sql} (${columns.join(', ')})${this.getCreateIndexSuffix(index)}${defer}`;
+            return `${sql} (${columns.join(', ')})${this.getCreateIndexSuffix(index)}${this.getIndexWhereClause(index)}${defer}`;
         }
         // Build column list with advanced options
         const columns = this.getIndexColumns(index);
@@ -119,7 +119,7 @@ export class SchemaHelper {
         if (index.include?.length) {
             sql += ` include (${index.include.map(c => this.quote(c)).join(', ')})`;
         }
-        return sql + this.getCreateIndexSuffix(index) + defer;
+        return sql + this.getCreateIndexSuffix(index) + this.getIndexWhereClause(index) + defer;
     }
     /**
      * Hook for adding driver-specific index options (e.g., fill factor for PostgreSQL).
@@ -127,6 +127,153 @@ export class SchemaHelper {
     getCreateIndexSuffix(_index) {
         return '';
     }
+    /**
+     * Default emits ` where <predicate>` for partial indexes. Only Oracle overrides this to
+     * return `''` (it emulates partials via CASE-WHEN columns). MySQL sidesteps the whole path
+     * with its own `getCreateIndexSQL` that never calls this, and MariaDB refuses the feature
+     * entirely via an override on `getIndexColumns`.
+     */
+    getIndexWhereClause(index) {
+        return index.where ? ` where ${index.where}` : '';
+    }
+    /**
+     * Wraps each indexed column in `(CASE WHEN <predicate> THEN <col> END)` for dialects that
+     * emulate partial indexes via functional indexes (MySQL/MariaDB/Oracle). Combined with NULL
+     * being treated as distinct in unique indexes, this enforces uniqueness only where the
+     * predicate holds. Throws if combined with the advanced `columns` option.
+     */
+    emulatePartialIndexColumns(index) {
+        if (index.columns?.length) {
+            throw new Error(`Index '${index.keyName}': combining \`where\` with advanced \`columns\` options is not supported when emulating a partial index via functional expressions; use plain \`properties\` (or \`columnNames\`).`);
+        }
+        const predicate = index.where;
+        return index.columnNames.map(c => `(case when ${predicate} then ${this.quote(c)} end)`).join(', ');
+    }
+    /**
+     * Strips `<col> IS NOT NULL` clauses (with the dialect's identifier quoting) from an
+     * introspected partial-index predicate when the column matches one of the index's own
+     * columns. MikroORM auto-emits this guard for unique indexes on nullable columns
+     * (MSSQL, Oracle) — it's an internal artifact, not user intent.
+     *
+     * Strips at most one guard per column (the tail-most occurrence), matching how MikroORM
+     * appends a single guard per index column. This preserves user intent when they redundantly
+     * include the same `<col> IS NOT NULL` in their predicate — the guard we added is removed,
+     * their copy survives.
+     */
+    stripAutoNotNullFilter(filterDef, columnNames, identifierPattern) {
+        // Peel off any number of balanced wrapping paren layers. Introspection sources differ
+        // (MSSQL `filter_definition` wraps once, Oracle `INDEX_EXPRESSIONS` typically not at all),
+        // and a user `where` round-tripped through a dialect that double-wraps would otherwise slip
+        // past the auto-NOT-NULL recognizer below.
+        let inner = filterDef.trim();
+        while (inner.startsWith('(') && inner.endsWith(')') && this.isBalancedWrap(inner)) {
+            inner = inner.slice(1, -1).trim();
+        }
+        const clauses = this.splitTopLevelAnd(inner);
+        const autoCol = (clause) => {
+            let trimmed = clause.trim();
+            while (trimmed.startsWith('(') && trimmed.endsWith(')') && this.isBalancedWrap(trimmed)) {
+                trimmed = trimmed.slice(1, -1).trim();
+            }
+            const match = identifierPattern.exec(trimmed);
+            return match && columnNames.includes(match[1]) ? match[1] : null;
+        };
+        const seen = new Set();
+        const kept = [];
+        for (let i = clauses.length - 1; i >= 0; i--) {
+            const col = autoCol(clauses[i]);
+            if (col && !seen.has(col)) {
+                seen.add(col);
+                continue;
+            }
+            kept.unshift(clauses[i]);
+        }
+        return kept.join(' and ').trim();
+    }
+    /**
+     * Whether `[…]` is a quoted identifier (MSSQL convention). Other dialects either reuse
+     * `[` for array literals/constructors or never produce it in introspected predicates,
+     * so the default is `false` and the MSSQL helper opts in.
+     */
+    get bracketQuotedIdentifiers() {
+        return false;
+    }
+    /**
+     * Splits on top-level ` AND ` (case-insensitive), ignoring matches that sit inside string
+     * literals, quoted identifiers, or parenthesized groups — so a predicate like
+     * `'foo AND bar' = col` or `(a AND b) OR c` is not mis-split.
+     */
+    splitTopLevelAnd(s) {
+        const parts = [];
+        let depth = 0;
+        let quote = null;
+        let start = 0;
+        let i = 0;
+        while (i < s.length) {
+            const c = s[i];
+            if (quote) {
+                // Handle SQL's doubled-delimiter escape inside quoted strings/identifiers:
+                // `'` → `''`, `"` → `""`, `` ` `` → ```` `` ````, MSSQL `]` → `]]`.
+                if (c === quote && s[i + 1] === quote) {
+                    i += 2;
+                    continue;
+                }
+                if (c === quote) {
+                    quote = null;
+                }
+                i++;
+                continue;
+            }
+            if (c === "'" || c === '"' || c === '`') {
+                quote = c;
+                i++;
+                continue;
+            }
+            if (c === '[' && this.bracketQuotedIdentifiers) {
+                quote = ']';
+                i++;
+                continue;
+            }
+            if (c === '(') {
+                depth++;
+                i++;
+                continue;
+            }
+            if (c === ')') {
+                depth--;
+                i++;
+                continue;
+            }
+            if (depth === 0 && /\s/.test(c)) {
+                const m = /^\s+and\s+/i.exec(s.slice(i));
+                if (m) {
+                    parts.push(s.slice(start, i).trim());
+                    i += m[0].length;
+                    start = i;
+                    continue;
+                }
+            }
+            i++;
+        }
+        parts.push(s.slice(start).trim());
+        return parts.filter(p => p.length > 0);
+    }
+    /** Returns true iff the leading `(` matches the trailing `)` (i.e. they wrap the whole string). */
+    isBalancedWrap(s) {
+        let depth = 0;
+        for (let i = 0; i < s.length; i++) {
+            if (s[i] === '(') {
+                depth++;
+            }
+            else if (s[i] === ')') {
+                depth--;
+                if (depth === 0 && i < s.length - 1) {
+                    return false;
+                }
+            }
+        }
+        return depth === 0;
+    }
     /**
      * Build the column list for an index, supporting advanced options like sort order, nulls ordering, and collation.
      * Note: Prefix length is only supported by MySQL/MariaDB which override this method.
@@ -204,6 +351,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 +416,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 +680,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 +762,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/schema/partitioning.d.ts

@@ -0,0 +1,13 @@
+import { splitCommaSeparatedIdentifiers, type EntityMetadata, type EntityPartitionBy } from '@mikro-orm/core';
+import type { TablePartitioning } from '../typings.js';
+export { splitCommaSeparatedIdentifiers };
+/** @internal */
+export declare function normalizePartitionDefinition(value: string): string;
+/** @internal */
+export declare function normalizePartitionBound(value: string): string;
+/** @internal */
+export declare const getTablePartitioning: (meta: EntityMetadata, tableSchema: string | undefined, quoteIdentifier?: (id: string) => string) => TablePartitioning | undefined;
+/** @internal */
+export declare const diffPartitioning: (from: TablePartitioning | undefined, to: TablePartitioning | undefined, defaultSchema: string | undefined) => boolean;
+/** @internal */
+export declare const toEntityPartitionBy: (partitioning: TablePartitioning | undefined, parentTableName?: string, parentSchema?: string) => EntityPartitionBy | undefined;

package/schema/partitioning.js

@@ -0,0 +1,326 @@
+import { splitCommaSeparatedIdentifiers } from '@mikro-orm/core';
+export { splitCommaSeparatedIdentifiers };
+const skipQuotedLiteral = (value, start) => {
+    let i = start + 1;
+    while (i < value.length) {
+        if (value[i] === "'") {
+            if (value[i + 1] === "'") {
+                i += 2;
+                continue;
+            }
+            return i;
+        }
+        i++;
+    }
+    // Unterminated literal — point past the end so callers' `slice(start, end + 1)` includes
+    // the full remaining tail instead of dropping its last character.
+    return value.length;
+};
+/**
+ * Apply `transform` only to segments of `value` that lie outside single-quoted
+ * SQL literals, leaving literal content (including escaped `''`) untouched.
+ */
+const mapOutsideLiterals = (value, transform) => {
+    let ret = '';
+    let buffer = '';
+    let i = 0;
+    while (i < value.length) {
+        if (value[i] === "'") {
+            ret += transform(buffer);
+            buffer = '';
+            const end = skipQuotedLiteral(value, i);
+            ret += value.slice(i, end + 1);
+            i = end + 1;
+            continue;
+        }
+        buffer += value[i];
+        i++;
+    }
+    return ret + transform(buffer);
+};
+const collapseWhitespace = (value) => value.replace(/\s+/g, ' ');
+const normalizeWhitespace = (value) => mapOutsideLiterals(value, collapseWhitespace).trim();
+const stripDoubleQuotes = (value) => mapOutsideLiterals(value, s => s.replaceAll('"', ''));
+const normalizeQuotedIdentifiers = (value) => stripDoubleQuotes(normalizeWhitespace(value));
+const findMatchingParenthesis = (value, start) => {
+    let depth = 0;
+    for (let i = start; i < value.length; i++) {
+        if (value[i] === "'") {
+            i = skipQuotedLiteral(value, i);
+            continue;
+        }
+        if (value[i] === '(') {
+            depth++;
+            continue;
+        }
+        if (value[i] === ')') {
+            depth--;
+            if (depth === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+};
+const normalizePartitionLiterals = (value) => value
+    // PG pg_get_expr output often tacks `::text` onto string literals inside expressions; drop it
+    // so the catalog shape matches user-provided bounds. This applies symmetrically to both
+    // user metadata and catalog reads, so diffing converges. If a user intentionally writes a
+    // `::text` cast in a bound literal it will be stripped on both sides as well.
+    .replace(/('(?:[^']|'')*')::text\b/gi, '$1')
+    // Strip the `00:00:00` time component so catalog round-trips (timestamp[tz] bounds formatted
+    // via the session TimeZone) match user metadata that omitted the time part. Only collapse
+    // when we can confidently attribute the literal to a timestamp column: either a numeric
+    // offset is present (timestamptz catalog output) or an explicit `::timestamp[tz]` cast
+    // follows the literal. Bare `'YYYY-MM-DD 00:00:00'` without offset/cast could just as easily
+    // be a text/varchar list-partition value, and collapsing it would produce false-negative
+    // diffs.
+    .replace(/'(\d{4}-\d{2}-\d{2}) 00:00:00[+-]\d{2}(?::\d{2})?'/g, "'$1'")
+    .replace(/'(\d{4}-\d{2}-\d{2}) 00:00:00'(?=\s*::\s*timestamp(?:tz)?(?:\s+(?:with|without)\s+time\s+zone)?\b)/gi, "'$1'");
+const unwrapOuterParentheses = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) {
+        return trimmed;
+    }
+    if (findMatchingParenthesis(trimmed, 0) !== trimmed.length - 1) {
+        return trimmed;
+    }
+    return trimmed.slice(1, -1).trim();
+};
+const unwrapAllOuterParentheses = (value) => {
+    let current = value.trim();
+    while (current.startsWith('(')) {
+        const unwrapped = unwrapOuterParentheses(current);
+        if (unwrapped === current) {
+            break;
+        }
+        current = unwrapped;
+    }
+    return current;
+};
+const normalizePartitionSqlFragment = (value) => {
+    const normalized = stripDoubleQuotes(normalizeWhitespace(normalizePartitionLiterals(value)));
+    let ret = '';
+    for (let i = 0; i < normalized.length; i++) {
+        if (normalized[i] === "'") {
+            const end = skipQuotedLiteral(normalized, i);
+            ret += normalized.slice(i, end + 1);
+            i = end;
+            continue;
+        }
+        if (normalized[i] === '(') {
+            const end = findMatchingParenthesis(normalized, i);
+            if (end === -1) {
+                ret += normalized.slice(i);
+                break;
+            }
+            const inner = unwrapAllOuterParentheses(normalizePartitionSqlFragment(normalized.slice(i + 1, end)));
+            ret += `(${inner})`;
+            i = end;
+            continue;
+        }
+        ret += normalized[i];
+    }
+    return normalizeWhitespace(unwrapAllOuterParentheses(ret));
+};
+const unquoteIdentifier = (value) => {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed.slice(1, -1).replaceAll('""', '"');
+    }
+    return trimmed;
+};
+/**
+ * Split a user-supplied partition name into `{ schema, name }`. Supports bare (`child`),
+ * schema-qualified (`schema.child`), and quoted (`"my.schema"."child"`) forms. Dots inside
+ * double-quoted identifiers are part of the identifier and do not split.
+ */
+const splitPartitionName = (name) => {
+    let depth = 0;
+    for (let i = 0; i < name.length; i++) {
+        const ch = name[i];
+        if (ch === '"') {
+            if (name[i + 1] === '"') {
+                i++;
+                continue;
+            }
+            depth = depth === 0 ? 1 : 0;
+            continue;
+        }
+        if (ch === '.' && depth === 0) {
+            return {
+                schema: unquoteIdentifier(name.slice(0, i)),
+                name: unquoteIdentifier(name.slice(i + 1)),
+            };
+        }
+    }
+    return { name: unquoteIdentifier(name) };
+};
+const resolvePartitionKey = (meta, key, quoteIdentifier) => {
+    const trimmed = key.trim().replaceAll('"', '');
+    if (!trimmed) {
+        throw new Error(`Entity ${meta.className} has invalid partitionBy option: empty partition key`);
+    }
+    const prop = meta.root.properties[trimmed] ??
+        Object.values(meta.root.properties).find(candidate => candidate.fieldNames?.length === 1 && candidate.fieldNames[0] === trimmed);
+    if (!prop) {
+        throw new Error(`Entity ${meta.className} has invalid partitionBy option: unknown partition key '${key.trim()}'`);
+    }
+    if (prop.fieldNames?.length !== 1) {
+        throw new Error(`Entity ${meta.className} has invalid partitionBy option: partition key '${key.trim()}' maps to multiple columns ('${prop.fieldNames?.join("', '")}'); list them explicitly as partition keys`);
+    }
+    return quoteIdentifier(prop.fieldNames[0]);
+};
+/**
+ * Resolve the partition expression to a SQL fragment. Column-reference forms (array of keys
+ * or a clean comma-list of identifiers) are rewritten to the backing `fieldNames` and passed
+ * through `quoteIdentifier`. The callback form and the raw-SQL fallback (anything that isn't
+ * a clean identifier list, e.g. `date_trunc('day', created_at)`) are emitted verbatim — the
+ * user owns identifier quoting inside a raw expression.
+ */
+const resolvePartitionExpression = (meta, expression, quoteIdentifier) => {
+    if (typeof expression === 'function') {
+        return normalizeWhitespace(expression(meta.createSchemaColumnMappingObject()));
+    }
+    if (Array.isArray(expression)) {
+        return expression.map(key => resolvePartitionKey(meta, key, quoteIdentifier)).join(', ');
+    }
+    const trimmed = expression.trim();
+    const keys = splitCommaSeparatedIdentifiers(trimmed);
+    if (keys) {
+        return keys.map(key => resolvePartitionKey(meta, key, quoteIdentifier)).join(', ');
+    }
+    return trimmed;
+};
+const createPartitionDefinition = (type, expression) => `${type.toLowerCase()} (${normalizeWhitespace(expression)})`;
+/** @internal */
+export function normalizePartitionDefinition(value) {
+    const normalized = normalizeWhitespace(value);
+    const match = /^(\w+)\s*(.*)$/.exec(normalized);
+    const rawType = match ? match[1] : normalized;
+    const type = rawType.toLowerCase();
+    const expression = match ? match[2].trim() : '';
+    if (!expression) {
+        return type;
+    }
+    if (!expression.startsWith('(')) {
+        return `${type} ${normalizePartitionSqlFragment(expression)}`;
+    }
+    return `${type} (${normalizePartitionSqlFragment(unwrapAllOuterParentheses(expression))})`;
+}
+const PARTITION_BOUND_KEYWORDS = /\b(for values|with|in|from|to|minvalue|maxvalue|null)\b/gi;
+/** @internal */
+export function normalizePartitionBound(value) {
+    const normalized = normalizeWhitespace(value);
+    if (!normalized) {
+        return '';
+    }
+    if (/^default$/i.test(normalized)) {
+        return 'default';
+    }
+    // Prepend `for values` if the caller passed a bare `with/in/from … to …` clause, then lowercase
+    // PG bound keywords outside quoted literals (so `FROM (MINVALUE) TO ('hello TO world')` becomes
+    // `from (minvalue) to ('hello TO world')` with the inner TO inside the literal preserved).
+    // PG's `pg_get_expr` emits `MINVALUE`/`MAXVALUE`/`NULL` in uppercase, so case-folding them here
+    // prevents a perpetual diff against user-supplied lowercase bounds.
+    const prefixed = /^for values\b/i.test(normalized) ? normalized : `for values ${normalized}`;
+    const lowered = mapOutsideLiterals(prefixed, segment => segment.replace(PARTITION_BOUND_KEYWORDS, match => match.toLowerCase()));
+    return normalizePartitionSqlFragment(lowered);
+}
+const createPartitionBound = (value) => normalizePartitionBound(value);
+const createHashPartitions = (tableName, tableSchema, partitions) => {
+    const count = typeof partitions === 'number' ? partitions : partitions.length;
+    return Array.from({ length: count }, (_, remainder) => {
+        const bound = normalizePartitionBound(`with (modulus ${count}, remainder ${remainder})`);
+        if (typeof partitions === 'number') {
+            return { name: `${tableName}_${remainder}`, schema: tableSchema, bound };
+        }
+        const { name, schema } = splitPartitionName(partitions[remainder]);
+        return { name, schema: schema ?? tableSchema, bound };
+    });
+};
+const createExplicitPartitions = (tableName, tableSchema, partitions) => partitions.map((partition, index) => {
+    const resolvedName = partition.name ?? `${tableName}_${index}`;
+    const { name, schema } = splitPartitionName(resolvedName);
+    return {
+        name,
+        schema: schema ?? tableSchema,
+        bound: createPartitionBound(partition.values),
+    };
+});
+/** @internal */
+export const getTablePartitioning = (meta, tableSchema, quoteIdentifier = id => id) => {
+    if (!meta.partitionBy) {
+        return undefined;
+    }
+    const definition = createPartitionDefinition(meta.partitionBy.type, resolvePartitionExpression(meta, meta.partitionBy.expression, quoteIdentifier));
+    const partitions = meta.partitionBy.type === 'hash'
+        ? createHashPartitions(meta.tableName, tableSchema, meta.partitionBy.partitions)
+        : createExplicitPartitions(meta.tableName, tableSchema, meta.partitionBy.partitions);
+    return { definition, partitions };
+};
+/** @internal */
+export const diffPartitioning = (from, to, defaultSchema) => {
+    if (!from && !to) {
+        return false;
+    }
+    if (!from || !to) {
+        return true;
+    }
+    if (normalizeQuotedIdentifiers(normalizePartitionDefinition(from.definition)) !==
+        normalizeQuotedIdentifiers(normalizePartitionDefinition(to.definition))) {
+        return true;
+    }
+    if (from.partitions.length !== to.partitions.length) {
+        return true;
+    }
+    const normalizeSchema = (schema) => (schema && schema !== defaultSchema ? schema : '');
+    const serializePartition = (partition) => `${normalizeSchema(partition.schema)}.${partition.name}:${normalizeQuotedIdentifiers(normalizePartitionBound(partition.bound))}`;
+    const fromPartitions = from.partitions.map(serializePartition).sort();
+    const toPartitions = to.partitions.map(serializePartition).sort();
+    return fromPartitions.some((partition, index) => partition !== toPartitions[index]);
+};
+const SUPPORTED_PARTITION_TYPES = ['hash', 'list', 'range'];
+const isSupportedPartitionType = (value) => SUPPORTED_PARTITION_TYPES.includes(value);
+/** @internal */
+export const toEntityPartitionBy = (partitioning, parentTableName, parentSchema) => {
+    if (!partitioning) {
+        return undefined;
+    }
+    const normalizedDefinition = normalizePartitionDefinition(partitioning.definition);
+    const normalizedPartitions = partitioning.partitions.map(partition => ({
+        ...partition,
+        bound: normalizePartitionBound(partition.bound),
+    }));
+    // Split the leading type keyword off of the definition without using `split(' ')`, which would
+    // shatter quoted literals containing spaces. Match a bareword prefix followed by whitespace.
+    const [, rawType = normalizedDefinition, rawExpression = ''] = /^(\S+)(?:\s+([\s\S]*))?$/.exec(normalizeWhitespace(normalizedDefinition)) ?? [];
+    const type = rawType.toLowerCase();
+    if (!isSupportedPartitionType(type)) {
+        throw new Error(`Unsupported partition type '${rawType}' in definition '${partitioning.definition}'`);
+    }
+    const expression = unwrapOuterParentheses(rawExpression);
+    const qualify = (partition) => partition.schema && partition.schema !== parentSchema ? `${partition.schema}.${partition.name}` : partition.name;
+    if (type === 'hash') {
+        // Collapse to a bare count when catalog names follow the default
+        // `${parentTableName}_${remainder}` pattern and live in the parent's schema, or when we have
+        // no parent context to compare against (backwards-compatible behavior for callers that pass
+        // just the `TablePartitioning`). Otherwise preserve the explicit name array so the next DDL
+        // generation reproduces the same children.
+        const usesDefaultShape = parentTableName == null ||
+            normalizedPartitions.every((p, i) => p.name === `${parentTableName}_${i}` && (!p.schema || p.schema === parentSchema));
+        return {
+            type,
+            expression,
+            partitions: usesDefaultShape ? normalizedPartitions.length : normalizedPartitions.map(qualify),
+        };
+    }
+    return {
+        type,
+        expression,
+        partitions: normalizedPartitions.map(partition => ({
+            name: qualify(partition),
+            values: partition.bound === 'default' ? 'default' : partition.bound.replace(/^for values\s+/i, ''),
+        })),
+    };
+};

package/typings.d.ts

@@ -71,6 +71,11 @@ export interface IndexDef {
     primary: boolean;
     composite?: boolean;
     expression?: string;
+    /**
+     * WHERE predicate for partial indexes, normalized to a SQL fragment after metadata
+     * resolution and introspection. Mutually exclusive with `expression`.
+     */
+    where?: string;
     options?: Dictionary;
     type?: string | Readonly<{
         indexType?: string;
@@ -108,6 +113,25 @@ 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 TablePartition {
+    name: string;
+    schema?: string;
+    bound: string;
+}
+export interface TablePartitioning {
+    definition: string;
+    partitions: TablePartition[];
+}
 export interface ColumnDifference {
     oldColumnName: string;
     column: Column;
@@ -117,6 +141,10 @@ export interface ColumnDifference {
 export interface TableDifference {
     name: string;
     changedComment?: string;
+    changedPartitioning?: {
+        from?: TablePartitioning;
+        to?: TablePartitioning;
+    };
     fromTable: DatabaseTable;
     toTable: DatabaseTable;
     addedColumns: Dictionary<Column>;
@@ -130,6 +158,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>;
@@ -233,7 +264,7 @@ export interface ICriteriaNode<T extends object> {
     shouldInline(payload: any): boolean;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
     shouldRename(payload: any): boolean;
-    renameFieldToPK<T>(qb: IQueryBuilder<T>, ownerAlias?: string): string;
+    renameFieldToPK<T>(qb: IQueryBuilder<T>, ownerAlias?: string, options?: ICriteriaNodeProcessOptions): string;
     getPath(opts?: {
         addIndex?: boolean;
     }): string;