@mikro-orm/sql 7.1.0-dev.14 → 7.1.0-dev.16

package/AbstractSqlDriver.d.ts

@@ -147,6 +147,13 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     mapPropToFieldNames<T extends object>(qb: AnyQueryBuilder<T>, prop: EntityProperty<T>, tableAlias: string, meta: EntityMetadata<T>, schema?: string, explicitFields?: readonly InternalField<T>[]): InternalField<T>[];
     /** @internal */
     createQueryBuilder<T extends object>(entityName: EntityName<T> | AnyQueryBuilder<T>, ctx?: Transaction, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): AnyQueryBuilder<T>;
+    /**
+     * Renders a `FilterQuery` predicate into a SQL fragment (without the `WHERE` keyword and
+     * without table-alias prefixes) suitable for inlining into a partial-index DDL statement.
+     * Used by `DatabaseTable.addIndex` when the user passes an object `where` on `@Index` /
+     * `@Unique`. Strings are returned unchanged.
+     */
+    renderPartialIndexWhere<T extends object>(entityName: EntityName<T>, where: string | FilterQuery<T>): string;
     protected resolveConnectionType(args: {
         ctx?: Transaction;
         connectionType?: ConnectionType;

package/AbstractSqlDriver.js

@@ -1944,6 +1944,57 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         return qb;
     }
+    /**
+     * Renders a `FilterQuery` predicate into a SQL fragment (without the `WHERE` keyword and
+     * without table-alias prefixes) suitable for inlining into a partial-index DDL statement.
+     * Used by `DatabaseTable.addIndex` when the user passes an object `where` on `@Index` /
+     * `@Unique`. Strings are returned unchanged.
+     */
+    renderPartialIndexWhere(entityName, where) {
+        if (typeof where === 'string') {
+            return where;
+        }
+        const name = Utils.className(entityName);
+        if (where == null || (Utils.isPlainObject(where) && Object.keys(where).length === 0)) {
+            throw new Error(`Cannot render partial-index predicate for entity '${name}': \`where\` is empty.`);
+        }
+        const alias = '__p';
+        const qb = this.createQueryBuilder(entityName, undefined, undefined, undefined, undefined, alias);
+        qb.where(where);
+        const sql = qb.getFormattedQuery();
+        // Relation traversal produces join clauses whose aliased identifiers can't be inlined
+        // into a CREATE INDEX ... WHERE clause — reject with a clear error rather than emitting broken DDL.
+        if (/\bjoin\b/i.test(sql.split(/\bwhere\b/i)[0])) {
+            throw new Error(`Cannot render partial-index predicate for entity '${name}': \`where\` may not traverse relations.`);
+        }
+        // Anchor at end-of-string only — the synthetic QB has no top-level order by / limit /
+        // group by / having / offset, so any such keyword inside the captured predicate is
+        // inside a subquery and must not terminate the match.
+        const match = /\bwhere\s+([\s\S]+)$/i.exec(sql);
+        if (!match) {
+            throw new Error(`Failed to render partial-index predicate for entity '${name}': ${sql}`);
+        }
+        const quote = (s) => this.platform.quoteIdentifier(s);
+        const aliasPrefix = new RegExp(`${quote(alias).replace(/[[\]]/g, '\\$&')}\\.`, 'g');
+        const stripped = match[1].replace(aliasPrefix, '').trim();
+        // Any qualified column reference remaining after the alias strip points at another table or
+        // subquery and can't be inlined into a CREATE INDEX ... WHERE predicate. Covers both
+        // QB-generated sub-aliases (quoted, e.g. `"e0"."col"`) and raw fragments with bare refs
+        // (e.g. `raw('other_table.col = 1')`). String literals are erased first so dots inside
+        // them (e.g. JSON path operands like `'$.path'`) don't trip the guard.
+        // Both patterns use a `(?!\s*\()` lookahead so schema-qualified function calls
+        // (`pg_catalog.lower(name)`, `"public".my_func(col)`) are accepted — only `<id>.<id>` not
+        // followed by `(` is treated as a cross-table column reference.
+        const withoutStrings = stripped.replace(/'(?:[^']|'')*'/g, "''");
+        const quotedIdent = String.raw `(?:"(?:[^"]|"")+"|\`(?:[^\`]|\`\`)+\`|\[(?:[^\]]|\]\])+\])`;
+        const anyIdent = `(?:${quotedIdent}|[A-Za-z_]\\w*)`;
+        const quotedCrossRef = new RegExp(`${quotedIdent}\\s*\\.\\s*${anyIdent}(?!\\s*\\()`);
+        const bareCrossRef = /\b[A-Za-z_]\w*\s*\.\s*[A-Za-z_]\w*\b(?!\s*\()/;
+        if (quotedCrossRef.test(withoutStrings) || bareCrossRef.test(withoutStrings)) {
+            throw new Error(`Cannot render partial-index predicate for entity '${name}': \`where\` references another table or subquery which cannot be inlined into a CREATE INDEX ... WHERE clause.`);
+        }
+        return stripped;
+    }
     resolveConnectionType(args) {
         if (args.ctx) {
             return 'write';

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -11,6 +11,7 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
         'current_timestamp(?)': string[];
         '0': string[];
     };
+    private static readonly PARTIAL_INDEX_RE;
     getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
@@ -22,8 +23,10 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     getAllIndexes(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<IndexDef[]>>;
     getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
     /**
-     * Build the column list for a MySQL index, with MySQL-specific handling for collation.
-     * MySQL requires collation to be specified as an expression: (column_name COLLATE collation_name)
+     * Build the column list for a MySQL index. MySQL requires collation via an expression:
+     * `(column COLLATE collation_name)`. Partial indexes (`where`) are emulated via functional
+     * indexes — requires MySQL 8.0.13+. MariaDB does not support inline functional indexes
+     * and overrides to throw at a higher level.
      */
     protected getIndexColumns(index: IndexDef): string;
     /**

package/dialects/mysql/MySqlSchemaHelper.js

@@ -7,6 +7,10 @@ export class MySqlSchemaHelper extends SchemaHelper {
         'current_timestamp(?)': ['current_timestamp(?)'],
         '0': ['0', 'false'],
     };
+    // Greedy `(.+)` so nested CASE expressions inside the predicate don't trip the match on
+    // an inner `then <col> end` — the trailing `$` anchor forces the regex engine to extend
+    // the capture to the outermost case-end boundary.
+    static PARTIAL_INDEX_RE = /^\s*\(\s*case\s+when\s+(.+)\s+then\s+`([^`]+)`\s+end\s*\)\s*$/is;
     getSchemaBeginning(charset, disableForeignKeys) {
         if (disableForeignKeys) {
             return `set names ${charset};\n${this.disableForeignKeysSQL()}\n\n`;
@@ -84,8 +88,11 @@ export class MySqlSchemaHelper extends SchemaHelper {
         const ret = {};
         for (const index of allIndexes) {
             const key = this.getTableKey(index);
+            const partialMatch = !index.column_name && typeof index.expression === 'string'
+                ? MySqlSchemaHelper.PARTIAL_INDEX_RE.exec(index.expression)
+                : null;
             const indexDef = {
-                columnNames: [index.column_name],
+                columnNames: [partialMatch ? partialMatch[2] : index.column_name],
                 keyName: index.index_name,
                 unique: !index.non_unique,
                 primary: index.index_name === 'PRIMARY',
@@ -113,7 +120,10 @@ export class MySqlSchemaHelper extends SchemaHelper {
             if (index.is_visible === 'NO') {
                 indexDef.invisible = true;
             }
-            if (!index.column_name || index.expression?.match(/ where /i)) {
+            if (partialMatch) {
+                indexDef.where = partialMatch[1].trim();
+            }
+            else if (!index.column_name || index.expression?.match(/ where /i)) {
                 indexDef.expression = index.expression; // required for the `getCreateIndexSQL()` call
                 indexDef.expression = this.getCreateIndexSQL(index.table_name, indexDef, !!index.expression);
             }
@@ -150,10 +160,15 @@ export class MySqlSchemaHelper extends SchemaHelper {
         return this.appendMySqlIndexSuffix(sql, index);
     }
     /**
-     * Build the column list for a MySQL index, with MySQL-specific handling for collation.
-     * MySQL requires collation to be specified as an expression: (column_name COLLATE collation_name)
+     * Build the column list for a MySQL index. MySQL requires collation via an expression:
+     * `(column COLLATE collation_name)`. Partial indexes (`where`) are emulated via functional
+     * indexes — requires MySQL 8.0.13+. MariaDB does not support inline functional indexes
+     * and overrides to throw at a higher level.
      */
     getIndexColumns(index) {
+        if (index.where) {
+            return this.emulatePartialIndexColumns(index);
+        }
         if (index.columns?.length) {
             return index.columns
                 .map(col => {

package/dialects/postgresql/BasePostgreSqlPlatform.d.ts

@@ -15,6 +15,7 @@ export declare class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     usesEnumCheckConstraints(): boolean;
     getEnumArrayCheckConstraintExpression(column: string, items: string[]): string;
     supportsMaterializedViews(): boolean;
+    supportsPartitionedTables(): boolean;
     supportsCustomPrimaryKeyNames(): boolean;
     getCurrentTimestampSQL(length: number): string;
     getDateTimeTypeDeclarationSQL(column: {

package/dialects/postgresql/BasePostgreSqlPlatform.js

@@ -30,6 +30,9 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     supportsMaterializedViews() {
         return true;
     }
+    supportsPartitionedTables() {
+        return true;
+    }
     supportsCustomPrimaryKeyNames() {
         return true;
     }

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

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

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -1,5 +1,6 @@
 import { DeferMode, EnumType, Type, Utils, } from '@mikro-orm/core';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
+import { normalizePartitionBound, normalizePartitionDefinition } from '../../schema/partitioning.js';
 /** PostGIS system views that should be automatically ignored */
 const POSTGIS_VIEWS = ['geography_columns', 'geometry_columns'];
 export class PostgreSqlSchemaHelper extends SchemaHelper {
@@ -12,6 +13,8 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         'null::timestamp with time zone': ['null'],
         'null::timestamp without time zone': ['null'],
     };
+    static PARTIAL_WHERE_RE = /\swhere\s+(.+)$/is;
+    static FUNCTIONAL_COL_RE = /[(): ,"'`]/;
     getSchemaBeginning(charset, disableForeignKeys) {
         if (disableForeignKeys) {
             return `set names '${charset}';\n${this.disableForeignKeysSQL()}\n\n`;
@@ -22,13 +25,22 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         return `create database ${this.quote(name)}`;
     }
     getListTablesSQL() {
+        // The `pg_inherits` anti-join compares on (schema, table) pairs so cross-schema child
+        // partitions are excluded even when their schema is not on the session `search_path`
+        // (in which case `inhrelid::regclass::text` renders as `schema.name` rather than bare `name`,
+        // breaking a plain `table_name not in (...)` predicate).
         return (`select table_name, table_schema as schema_name, ` +
             `(select pg_catalog.obj_description(c.oid) from pg_catalog.pg_class c
           where c.oid = (select ('"' || table_schema || '"."' || table_name || '"')::regclass::oid) and c.relname = table_name) as table_comment ` +
-            `from information_schema.tables ` +
+            `from information_schema.tables t ` +
             `where ${this.getIgnoredNamespacesConditionSQL('table_schema')} ` +
             `and table_name != 'geometry_columns' and table_name != 'spatial_ref_sys' and table_type != 'VIEW' ` +
-            `and table_name not in (select inhrelid::regclass::text from pg_inherits) ` +
+            `and not exists (` +
+            `select 1 from pg_inherits i ` +
+            `join pg_class c on c.oid = i.inhrelid ` +
+            `join pg_namespace n on n.oid = c.relnamespace ` +
+            `where c.relname = t.table_name and n.nspname = t.table_schema` +
+            `) ` +
             `order by table_name`);
     }
     getIgnoredViewsCondition() {
@@ -79,6 +91,23 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const dataClause = withData ? ' with data' : ' with no data';
         return `create materialized view ${viewName} as ${definition}${dataClause}`;
     }
+    createTable(table, alter) {
+        const partitioning = table.getPartitioning();
+        if (!partitioning) {
+            return super.createTable(table, alter);
+        }
+        const [createTable, ...rest] = super.createTable(table, alter);
+        const partitions = partitioning.partitions.map(partition => {
+            const partitionName = this.quote(this.getTableName(partition.name, partition.schema ?? table.schema));
+            return `create table ${partitionName} partition of ${table.getQuotedName()} ${partition.bound}`;
+        });
+        // SchemaHelper.append() always terminates the CREATE TABLE with `;`; we rely on that to splice
+        // the `partition by ...` clause in before the terminator. Use slice instead of replace() so that
+        // regex replacement tokens like `$$`, `$&`, or `$1` inside user-supplied expressions (e.g., a
+        // callback that returns a dollar-quoted literal) are not interpreted as back-references.
+        const spliced = `${createTable.slice(0, -1)} partition by ${partitioning.definition};`;
+        return [spliced, ...rest, ...partitions];
+    }
     dropMaterializedViewIfExists(name, schema) {
         return `drop materialized view if exists ${this.quote(this.getTableName(name, schema))} cascade`;
     }
@@ -118,6 +147,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const indexes = await this.getAllIndexes(connection, tables, ctx);
         const checks = await this.getAllChecks(connection, tablesBySchema, ctx);
         const fks = await this.getAllForeignKeys(connection, tablesBySchema, ctx);
+        const partitionings = await this.getPartitions(connection, tablesBySchema, ctx);
         const triggers = await this.getAllTriggers(connection, tablesBySchema);
         for (const t of tables) {
             const key = this.getTableKey(t);
@@ -130,8 +160,61 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             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, '');
@@ -165,9 +248,22 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             if (index.condeferrable) {
                 indexDef.deferMode = index.condeferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
             }
-            if (index.index_def.some((col) => /[(): ,"'`]/.exec(col)) || index.expression?.match(/ where /i)) {
+            const hasFunctionalColumns = index.index_def.some((col) => PostgreSqlSchemaHelper.FUNCTIONAL_COL_RE.exec(col));
+            const whereMatch = hasFunctionalColumns
+                ? null
+                : PostgreSqlSchemaHelper.PARTIAL_WHERE_RE.exec(index.expression ?? '');
+            if (hasFunctionalColumns) {
+                // Functional-column expression can't be diffed structurally — keep the whole CREATE
+                // statement (WHERE included) on `expression`; don't try to split the predicate.
                 indexDef.expression = index.expression;
             }
+            else if (whereMatch) {
+                let where = whereMatch[1].trim();
+                if (where.startsWith('(') && where.endsWith(')') && this.isBalancedWrap(where)) {
+                    where = where.slice(1, -1).trim();
+                }
+                indexDef.where = where;
+            }
             if (index.deferrable) {
                 indexDef.deferMode = index.initially_deferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
             }
@@ -641,6 +737,12 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         return col.join(' ');
     }
     getPreAlterTable(tableDiff, safe) {
+        if (tableDiff.changedPartitioning) {
+            const from = tableDiff.changedPartitioning.from?.definition;
+            const to = tableDiff.changedPartitioning.to?.definition;
+            const action = !from ? 'Adding' : !to ? 'Removing' : 'Changing';
+            throw new Error(`${action} partition definitions for existing PostgreSQL tables is not supported automatically (${tableDiff.name}: '${from ?? '<none>'}' -> '${to ?? '<none>'}'); create a manual migration instead`);
+        }
         const ret = [];
         const parts = tableDiff.name.split('.');
         const tableName = parts.pop();

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -5,6 +5,7 @@ import type { Column, IndexDef, Table, TableDifference, SqlTriggerDef } from '..
 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;

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;';
     }
@@ -216,10 +217,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 = {};
@@ -355,6 +356,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({
@@ -367,12 +378,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.0-dev.14",
+  "version": "7.1.0-dev.16",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.0.11"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.14"
+    "@mikro-orm/core": "7.1.0-dev.16"
   },
   "engines": {
     "node": ">= 22.17.0"

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
  */
@@ -173,6 +174,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;

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, SqlTriggerDef } from '../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, TablePartitioning, SqlTriggerDef } from '../typings.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /**
  * @internal
@@ -15,6 +15,7 @@ export declare class DatabaseTable {
         items: string[];
     }>;
     comment?: string;
+    partitioning?: TablePartitioning;
     constructor(platform: AbstractSqlPlatform, name: string, schema?: string | undefined);
     getQuotedName(): string;
     getColumns(): Column[];
@@ -22,6 +23,9 @@ 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;
@@ -67,6 +71,7 @@ export declare class DatabaseTable {
         name?: string;
         type?: string;
         expression?: string | IndexCallback<any>;
+        where?: string | Dictionary;
         deferMode?: DeferMode | `${DeferMode}`;
         options?: Dictionary;
         columns?: {
@@ -82,6 +87,7 @@ 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;

package/schema/DatabaseTable.js

@@ -1,4 +1,5 @@
 import { DecimalType, EntitySchema, isRaw, ReferenceKind, t, Type, UnknownType, Utils, } from '@mikro-orm/core';
+import { toEntityPartitionBy } from './partitioning.js';
 /**
  * @internal
  */
@@ -13,6 +14,7 @@ export class DatabaseTable {
     #platform;
     nativeEnums = {}; // for postgres
     comment;
+    partitioning;
     constructor(platform, name, schema) {
         this.name = name;
         this.schema = schema;
@@ -36,6 +38,13 @@ export class DatabaseTable {
     getChecks() {
         return this.#checks;
     }
+    getPartitioning() {
+        return this.partitioning;
+    }
+    /** @internal */
+    setPartitioning(partitioning) {
+        this.partitioning = partitioning;
+    }
     getTriggers() {
         return this.#triggers;
     }
@@ -185,6 +194,7 @@ export class DatabaseTable {
         const { fksOnColumnProps, fksOnStandaloneProps, columnFks, fkIndexes, nullableForeignKeys, skippedColumnNames } = this.foreignKeysToProps(namingStrategy, scalarPropertiesForRelations);
         const name = namingStrategy.getEntityName(this.name, this.schema);
         const schema = new EntitySchema({ name, collection: this.name, schema: this.schema, comment: this.comment });
+        schema.meta.partitionBy = toEntityPartitionBy(this.partitioning, this.name, this.schema);
         const compositeFkIndexes = {};
         const compositeFkUniques = {};
         const potentiallyUnmappedIndexes = this.#indexes.filter(index => !index.primary && // Skip primary index. Whether it's in use by scalar column or FK, it's already mapped.
@@ -204,6 +214,7 @@ export class DatabaseTable {
                 name: index.keyName,
                 deferMode: index.deferMode,
                 expression: index.expression,
+                where: index.where,
                 // Advanced index options - convert column names to property names
                 columns: index.columns?.map(col => ({
                     ...col,
@@ -234,7 +245,7 @@ export class DatabaseTable {
                 index.invisible ||
                 index.disabled ||
                 index.clustered;
-            const isTrivial = !index.deferMode && !index.expression && !hasAdvancedOptions;
+            const isTrivial = !index.deferMode && !index.expression && !index.where && !hasAdvancedOptions;
             if (isTrivial) {
                 // Index is for FK. Map to the FK prop and move on.
                 const fkForIndex = fkIndexes.get(index);
@@ -876,16 +887,25 @@ export class DatabaseTable {
         if (index.fillFactor != null && (index.fillFactor < 0 || index.fillFactor > 100)) {
             throw new Error(`fillFactor must be between 0 and 100, got ${index.fillFactor} for index '${name}' on entity '${meta.className}'`);
         }
+        // The `expression` escape hatch takes the full index definition as raw SQL; combining it
+        // with `where` is dialect-dependent (PG/Oracle/MySQL drop `where`, MSSQL appends it) so we
+        // reject the combination up-front and ask users to inline the predicate into `expression`.
+        if (index.expression && index.where != null) {
+            throw new Error(`Index '${name}' on entity '${meta.className}': cannot combine \`expression\` with \`where\` — inline the WHERE clause into the \`expression\` escape hatch, or drop \`expression\` and use structured \`properties\` + \`where\`.`);
+        }
+        const where = this.processIndexWhere(index.where, meta);
         this.#indexes.push({
             keyName: name,
             columnNames: properties,
             composite: properties.length > 1,
-            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
-            constraint: type !== 'index' && !properties.some((d) => d.includes('.')),
+            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them.
+            // Partial indexes (`where`) must use CREATE [UNIQUE] INDEX form — constraints can't carry predicates.
+            constraint: type !== 'index' && !properties.some((d) => d.includes('.')) && !where,
             primary: type === 'primary',
             unique: type !== 'index',
             type: index.type,
             expression: this.processIndexExpression(name, index.expression, meta),
+            where,
             options: index.options,
             deferMode: index.deferMode,
             columns,
@@ -896,6 +916,15 @@ export class DatabaseTable {
             clustered: index.clustered,
         });
     }
+    processIndexWhere(where, meta) {
+        if (where == null) {
+            return undefined;
+        }
+        // The driver is always an `AbstractSqlDriver` here — `DatabaseTable` is only instantiated
+        // by SQL-side schema code, so the platform's config-bound driver is guaranteed to be one.
+        const driver = this.#platform.getConfig().getDriver();
+        return driver.renderPartialIndexWhere(meta.class, where);
+    }
     addCheck(check) {
         this.#checks.push(check);
     }

package/schema/SchemaComparator.js

@@ -1,5 +1,6 @@
 import { ArrayType, BooleanType, DateTimeType, inspect, JsonType, parseJsonSafe, Utils, } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
+import { diffPartitioning } from './partitioning.js';
 /**
  * Compares two Schemas and return an instance of SchemaDifference.
  */
@@ -200,6 +201,17 @@ export class SchemaComparator {
             });
             changes++;
         }
+        if (diffPartitioning(fromTable.getPartitioning(), toTable.getPartitioning(), this.#platform.getDefaultSchemaName())) {
+            tableDifferences.changedPartitioning = {
+                from: fromTable.getPartitioning(),
+                to: toTable.getPartitioning(),
+            };
+            this.log(`table partitioning changed for ${tableDifferences.name}`, {
+                fromPartitioning: fromTable.getPartitioning(),
+                toPartitioning: toTable.getPartitioning(),
+            });
+            changes++;
+        }
         const fromTableColumns = fromTable.getColumns();
         const toTableColumns = toTable.getColumns();
         // See if all the columns in "from" table exist in "to" table
@@ -266,6 +278,19 @@ export class SchemaComparator {
             if (!this.diffIndex(index, toTableIndex)) {
                 continue;
             }
+            // Constraint-vs-index form mismatch needs drop+create with the OLD form's drop SQL,
+            // which `changedIndexes` (uses new form only) can't do. Primary keys stay on the
+            // changed path which emits `add primary key`.
+            if (!index.primary && !!index.constraint !== !!toTableIndex.constraint) {
+                tableDifferences.removedIndexes[index.keyName] = index;
+                tableDifferences.addedIndexes[index.keyName] = toTableIndex;
+                this.log(`index ${index.keyName} changed form in table ${tableDifferences.name}`, {
+                    fromTableIndex: index,
+                    toTableIndex,
+                });
+                changes += 2;
+                continue;
+            }
             tableDifferences.changedIndexes[index.keyName] = toTableIndex;
             this.log(`index ${index.keyName} changed in table ${tableDifferences.name}`, {
                 fromTableIndex: index,
@@ -572,7 +597,8 @@ export class SchemaComparator {
      * Compares index1 with index2 and returns index2 if there are any differences or false in case there are no differences.
      */
     diffIndex(index1, index2) {
-        // if one of them is a custom expression or full text index, compare only by name
+        // Opaque raw expressions (`expression` escape hatch) and full-text indexes can't be
+        // compared structurally — fall back to name-only matching.
         if (index1.expression || index2.expression || index1.type === 'fulltext' || index2.type === 'fulltext') {
             return index1.keyName !== index2.keyName;
         }
@@ -623,6 +649,11 @@ export class SchemaComparator {
         if (!!index1.clustered !== !!index2.clustered) {
             return false;
         }
+        // Compare WHERE predicate of partial indexes structurally (whitespace/quoting/casing
+        // are normalized via the same helper used for check constraints).
+        if (this.diffExpression(index1.where ?? '', index2.where ?? '')) {
+            return false;
+        }
         if (!index1.unique && !index1.primary) {
             // this is a special case: If the current key is neither primary or unique, any unique or
             // primary key will always have the same effect for the index and there cannot be any constraint

package/schema/SchemaHelper.d.ts

@@ -41,6 +41,46 @@ export declare abstract class SchemaHelper {
      * Hook for adding driver-specific index options (e.g., fill factor for PostgreSQL).
      */
     protected getCreateIndexSuffix(_index: IndexDef): string;
+    /**
+     * 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`.
+     */
+    protected getIndexWhereClause(index: IndexDef): string;
+    /**
+     * 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.
+     */
+    protected emulatePartialIndexColumns(index: IndexDef): string;
+    /**
+     * 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.
+     */
+    protected stripAutoNotNullFilter(filterDef: string, columnNames: string[], identifierPattern: RegExp): string;
+    /**
+     * 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.
+     */
+    protected get bracketQuotedIdentifiers(): boolean;
+    /**
+     * 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.
+     */
+    protected splitTopLevelAnd(s: string): string[];
+    /** Returns true iff the leading `(` matches the trailing `)` (i.e. they wrap the whole string). */
+    protected isBalancedWrap(s: string): boolean;
     /**
      * 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.

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.

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;
@@ -118,6 +123,15 @@ export interface SqlTriggerDef {
     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;
@@ -127,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>;