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

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -1,5 +1,6 @@
 import { DeferMode, EnumType, Type, Utils, } from '@mikro-orm/core';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
+import { normalizePartitionBound, normalizePartitionDefinition } from '../../schema/partitioning.js';
 /** PostGIS system views that should be automatically ignored */
 const POSTGIS_VIEWS = ['geography_columns', 'geometry_columns'];
 export class PostgreSqlSchemaHelper extends SchemaHelper {
@@ -12,23 +13,45 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         'null::timestamp with time zone': ['null'],
         'null::timestamp without time zone': ['null'],
     };
+    static PARTIAL_WHERE_RE = /\swhere\s+(.+)$/is;
+    static FUNCTIONAL_COL_RE = /[(): ,"'`]/;
     getSchemaBeginning(charset, disableForeignKeys) {
         if (disableForeignKeys) {
             return `set names '${charset}';\n${this.disableForeignKeysSQL()}\n\n`;
         }
         return `set names '${charset}';\n\n`;
     }
+    getSetSchemaSQL(schema) {
+        // session-level `SET` (not `SET LOCAL`) so it also works outside a transaction; the runner
+        // emits `getResetSchemaSQL` afterwards to avoid leaking onto the pooled connection
+        return `set search_path to ${this.quote(schema)}`;
+    }
+    getResetSchemaSQL(_defaultSchema) {
+        return 'reset search_path';
+    }
+    supportsMigrationSchema() {
+        return true;
+    }
     getCreateDatabaseSQL(name) {
         return `create database ${this.quote(name)}`;
     }
     getListTablesSQL() {
+        // The `pg_inherits` anti-join compares on (schema, table) pairs so cross-schema child
+        // partitions are excluded even when their schema is not on the session `search_path`
+        // (in which case `inhrelid::regclass::text` renders as `schema.name` rather than bare `name`,
+        // breaking a plain `table_name not in (...)` predicate).
         return (`select table_name, table_schema as schema_name, ` +
             `(select pg_catalog.obj_description(c.oid) from pg_catalog.pg_class c
           where c.oid = (select ('"' || table_schema || '"."' || table_name || '"')::regclass::oid) and c.relname = table_name) as table_comment ` +
-            `from information_schema.tables ` +
+            `from information_schema.tables t ` +
             `where ${this.getIgnoredNamespacesConditionSQL('table_schema')} ` +
             `and table_name != 'geometry_columns' and table_name != 'spatial_ref_sys' and table_type != 'VIEW' ` +
-            `and table_name not in (select inhrelid::regclass::text from pg_inherits) ` +
+            `and not exists (` +
+            `select 1 from pg_inherits i ` +
+            `join pg_class c on c.oid = i.inhrelid ` +
+            `join pg_namespace n on n.oid = c.relnamespace ` +
+            `where c.relname = t.table_name and n.nspname = t.table_schema` +
+            `) ` +
             `order by table_name`);
     }
     getIgnoredViewsCondition() {
@@ -79,6 +102,23 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const dataClause = withData ? ' with data' : ' with no data';
         return `create materialized view ${viewName} as ${definition}${dataClause}`;
     }
+    createTable(table, alter) {
+        const partitioning = table.getPartitioning();
+        if (!partitioning) {
+            return super.createTable(table, alter);
+        }
+        const [createTable, ...rest] = super.createTable(table, alter);
+        const partitions = partitioning.partitions.map(partition => {
+            const partitionName = this.quote(this.getTableName(partition.name, partition.schema ?? table.schema));
+            return `create table ${partitionName} partition of ${table.getQuotedName()} ${partition.bound}`;
+        });
+        // SchemaHelper.append() always terminates the CREATE TABLE with `;`; we rely on that to splice
+        // the `partition by ...` clause in before the terminator. Use slice instead of replace() so that
+        // regex replacement tokens like `$$`, `$&`, or `$1` inside user-supplied expressions (e.g., a
+        // callback that returns a dollar-quoted literal) are not interpreted as back-references.
+        const spliced = `${createTable.slice(0, -1)} partition by ${partitioning.definition};`;
+        return [spliced, ...rest, ...partitions];
+    }
     dropMaterializedViewIfExists(name, schema) {
         return `drop materialized view if exists ${this.quote(this.getTableName(name, schema))} cascade`;
     }
@@ -118,16 +158,76 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const indexes = await this.getAllIndexes(connection, tables, ctx);
         const checks = await this.getAllChecks(connection, tablesBySchema, ctx);
         const fks = await this.getAllForeignKeys(connection, tablesBySchema, ctx);
+        const partitionings = await this.getPartitions(connection, tablesBySchema, ctx);
+        const triggers = await this.getAllTriggers(connection, tablesBySchema);
+        const dbCollation = await this.getDatabaseCollation(connection, ctx);
         for (const t of tables) {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
+            table.collation = dbCollation;
             const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
             const enums = this.getEnumDefinitions(checks[key] ?? []);
             if (columns[key]) {
                 table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums);
             }
+            if (triggers[key]) {
+                table.setTriggers(triggers[key]);
+            }
+            table.setPartitioning(partitionings[key]);
         }
     }
+    /**
+     * Introspects direct partitions only: the `pg_inherits` join surfaces a parent's children but
+     * does not recurse into sub-partitioning (e.g. hash-of-range). Declarative `partitionBy`
+     * metadata does not express multi-level partitioning either, so grandchildren are intentionally
+     * invisible to schema diffing.
+     *
+     * Entries with an undefined schema bucket are resolved against `current_schema()` so they do
+     * not match same-named tables in unrelated schemas.
+     */
+    async getPartitions(connection, tablesBySchemas, ctx) {
+        // Collapse every (schema, table) pair into a single `values (...)` relation and join against
+        // the catalog, instead of building an OR-tree of per-schema `in (...)` predicates. This keeps
+        // the query size O(pairs) rather than O(schemas × predicate_overhead) and stays sargable when
+        // many schemas are in play.
+        const pairs = [...tablesBySchemas.entries()].flatMap(([schema, tables]) => tables.map(t => {
+            const schemaLiteral = schema == null ? 'null::text' : `${this.platform.quoteValue(schema)}::text`;
+            return `(${schemaLiteral}, ${this.platform.quoteValue(t.table_name)})`;
+        }));
+        if (pairs.length === 0) {
+            return {};
+        }
+        const sql = `with targets(schema_name, table_name) as (values ${pairs.join(', ')})
+      select parent_ns.nspname as schema_name,
+      parent.relname as table_name,
+      pg_get_partkeydef(parent.oid) as partition_definition,
+      child_ns.nspname as partition_schema_name,
+      child.relname as partition_name,
+      pg_get_expr(child.relpartbound, child.oid) as partition_bound
+      from targets
+      join pg_class parent on parent.relname = targets.table_name
+      join pg_namespace parent_ns on parent_ns.oid = parent.relnamespace
+        and parent_ns.nspname = coalesce(targets.schema_name, current_schema())
+      join pg_partitioned_table partitioned on partitioned.partrelid = parent.oid
+      left join pg_inherits inherits on inherits.inhparent = parent.oid
+      left join pg_class child on child.oid = inherits.inhrelid
+      left join pg_namespace child_ns on child_ns.oid = child.relnamespace
+      order by parent_ns.nspname, parent.relname, child_ns.nspname, child.relname`;
+        const rows = await connection.execute(sql, [], 'all', ctx);
+        const ret = {};
+        for (const row of rows) {
+            const key = this.getTableKey(row);
+            ret[key] ??= { definition: normalizePartitionDefinition(row.partition_definition), partitions: [] };
+            if (row.partition_name && row.partition_bound) {
+                ret[key].partitions.push({
+                    name: row.partition_name,
+                    schema: row.partition_schema_name,
+                    bound: normalizePartitionBound(row.partition_bound),
+                });
+            }
+        }
+        return ret;
+    }
     async getAllIndexes(connection, tables, ctx) {
         const sql = this.getIndexesSQL(tables);
         const unquote = (str) => str.replace(/['"`]/g, '');
@@ -161,9 +261,22 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             if (index.condeferrable) {
                 indexDef.deferMode = index.condeferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
             }
-            if (index.index_def.some((col) => /[(): ,"'`]/.exec(col)) || index.expression?.match(/ where /i)) {
+            const hasFunctionalColumns = index.index_def.some((col) => PostgreSqlSchemaHelper.FUNCTIONAL_COL_RE.exec(col));
+            const whereMatch = hasFunctionalColumns
+                ? null
+                : PostgreSqlSchemaHelper.PARTIAL_WHERE_RE.exec(index.expression ?? '');
+            if (hasFunctionalColumns) {
+                // Functional-column expression can't be diffed structurally — keep the whole CREATE
+                // statement (WHERE included) on `expression`; don't try to split the predicate.
                 indexDef.expression = index.expression;
             }
+            else if (whereMatch) {
+                let where = whereMatch[1].trim();
+                if (where.startsWith('(') && where.endsWith(')') && this.isBalancedWrap(where)) {
+                    where = where.slice(1, -1).trim();
+                }
+                indexDef.where = where;
+            }
             if (index.deferrable) {
                 indexDef.deferMode = index.initially_deferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
             }
@@ -266,10 +379,12 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       is_identity,
       identity_generation,
       generation_expression,
-      pg_catalog.col_description(pgc.oid, cols.ordinal_position::int) column_comment
+      pg_catalog.col_description(pgc.oid, cols.ordinal_position::int) column_comment,
+      coll.collname as collation_name
       from information_schema.columns cols
       join pg_class pgc on cols.table_name = pgc.relname
       join pg_attribute pga on pgc.oid = pga.attrelid and cols.column_name = pga.attname
+      left join pg_collation coll on pga.attcollation = coll.oid and coll.collname <> 'default'
       where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(table_schema = ${this.platform.quoteValue(schema)} and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}))`).join(' or ')})
       order by ordinal_position`;
         const allColumns = await connection.execute(sql, [], 'all', ctx);
@@ -319,6 +434,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                         ? col.generation_expression + ' stored'
                         : undefined,
                 comment: col.column_comment,
+                collation: col.collation_name ?? undefined,
             };
             let enumKey = column.type;
             let enumEntry = nativeEnums?.[enumKey];
@@ -375,6 +491,104 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
+    /** Generates SQL to create a PostgreSQL trigger and its associated function. */
+    createTrigger(table, trigger) {
+        if (trigger.expression) {
+            return trigger.expression;
+        }
+        const timing = trigger.timing.toUpperCase();
+        const events = trigger.events.map(e => e.toUpperCase()).join(' OR ');
+        const forEach = trigger.forEach === 'statement' ? 'STATEMENT' : 'ROW';
+        const when = trigger.when ? `\n  when (${trigger.when})` : '';
+        const fnName = this.getSchemaQualifiedTriggerFnName(table, trigger);
+        const triggerName = this.platform.quoteIdentifier(trigger.name);
+        const fnSql = `create or replace function ${fnName}() returns trigger as $$ begin ${trigger.body}; end; $$ language plpgsql`;
+        const triggerSql = `create trigger ${triggerName} ${timing} ${events} on ${table.getQuotedName()} for each ${forEach}${when} execute function ${fnName}()`;
+        return `${fnSql};\n${triggerSql}`;
+    }
+    /** Generates SQL to drop a PostgreSQL trigger and its associated function. */
+    dropTrigger(table, trigger) {
+        const triggerName = this.platform.quoteIdentifier(trigger.name);
+        const fnName = this.getSchemaQualifiedTriggerFnName(table, trigger);
+        return `drop trigger if exists ${triggerName} on ${table.getQuotedName()};\ndrop function if exists ${fnName}()`;
+    }
+    getSchemaQualifiedTriggerFnName(table, trigger) {
+        const rawName = `${table.name}_${trigger.name}_fn`;
+        const defaultSchema = this.platform.getDefaultSchemaName();
+        if (table.schema && table.schema !== defaultSchema) {
+            return `${this.platform.quoteIdentifier(table.schema)}.${this.platform.quoteIdentifier(rawName)}`;
+        }
+        return this.platform.quoteIdentifier(rawName);
+    }
+    /**
+     * Resolves the real name of the implicit 'default' collation (the DB's `datcollate`),
+     * so the comparator can treat `@Property({ collation: '<datcollate>' })` as equivalent
+     * to a column that introspects as using the default.
+     */
+    async getDatabaseCollation(connection, ctx) {
+        const [row] = await connection.execute(`select datcollate as collation from pg_database where datname = current_database()`, [], 'all', ctx);
+        return row?.collation;
+    }
+    async getAllTriggers(connection, tablesBySchemas) {
+        const sql = this.getTriggersSQL(tablesBySchemas);
+        const allTriggers = await connection.execute(sql);
+        const ret = {};
+        const triggerMap = new Map();
+        for (const row of allTriggers) {
+            const key = this.getTableKey(row);
+            const dedupeKey = `${key}:${row.trigger_name}`;
+            if (triggerMap.has(dedupeKey)) {
+                // Same trigger with multiple events — merge events
+                const existing = triggerMap.get(dedupeKey);
+                const event = row.event.toLowerCase();
+                if (!existing.events.includes(event)) {
+                    existing.events.push(event);
+                }
+                continue;
+            }
+            ret[key] ??= [];
+            // prosrc includes the full function body between $$ delimiters (e.g. " begin RETURN NEW; end;")
+            // Strip the begin/end wrapper to get just the trigger body for round-trip comparison
+            let body = (row.function_body ?? '').trim();
+            const beginEndMatch = /^\s*begin\s+([\s\S]*?)\s*end;?\s*$/i.exec(body);
+            if (beginEndMatch) {
+                body = beginEndMatch[1].trim().replace(/;\s*$/, '');
+            }
+            const trigger = {
+                name: row.trigger_name,
+                timing: row.timing.toLowerCase(),
+                events: [row.event.toLowerCase()],
+                forEach: row.for_each.toLowerCase(),
+                body,
+                when: row.when_clause ?? undefined,
+            };
+            ret[key].push(trigger);
+            triggerMap.set(dedupeKey, trigger);
+        }
+        return ret;
+    }
+    getTriggersSQL(tablesBySchemas) {
+        const conditions = [];
+        for (const [schema, tables] of tablesBySchemas) {
+            const names = tables.map(t => this.platform.quoteValue(t.table_name)).join(', ');
+            const schemaName = this.platform.quoteValue(schema ?? this.platform.getDefaultSchemaName());
+            conditions.push(`(t.event_object_schema = ${schemaName} and t.event_object_table in (${names}))`);
+        }
+        // Function lookup uses the '{table}_{trigger}_fn' convention from createTrigger().
+        // External triggers with different function names will have NULL body;
+        // use the `expression` escape hatch for those.
+        return `select t.trigger_name, t.event_object_schema as schema_name, t.event_object_table as table_name,
+      t.event_manipulation as event, t.action_timing as timing,
+      t.action_orientation as for_each,
+      t.action_condition as when_clause,
+      pg_get_functiondef(p.oid) as function_def,
+      p.prosrc as function_body
+    from information_schema.triggers t
+    left join pg_namespace n on n.nspname = t.event_object_schema
+    left join pg_proc p on p.proname = t.event_object_table || '_' || t.trigger_name || '_fn' and p.pronamespace = n.oid
+    where (${conditions.join(' or ')})
+    order by t.trigger_name, t.event_manipulation`;
+    }
     async getAllForeignKeys(connection, tablesBySchemas, ctx) {
         const sql = `select nsp1.nspname schema_name, cls1.relname table_name, nsp2.nspname referenced_schema_name,
       cls2.relname referenced_table_name, a.attname column_name, af.attname referenced_column_name, conname constraint_name,
@@ -505,6 +719,9 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             return o;
         }, {});
     }
+    getCollateSQL(collation) {
+        return `collate ${this.platform.quoteCollation(collation)}`;
+    }
     createTableColumn(column, table) {
         const pk = table.getPrimaryKey();
         const compositePK = pk?.composite;
@@ -537,6 +754,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 columnType += ` generated always as ${column.generated}`;
             }
             col.push(columnType);
+            Utils.runIfNotEmpty(() => col.push(this.getCollateSQL(column.collation)), column.collation);
             Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
             Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable);
         }
@@ -548,6 +766,12 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         return col.join(' ');
     }
     getPreAlterTable(tableDiff, safe) {
+        if (tableDiff.changedPartitioning) {
+            const from = tableDiff.changedPartitioning.from?.definition;
+            const to = tableDiff.changedPartitioning.to?.definition;
+            const action = !from ? 'Adding' : !to ? 'Removing' : 'Changing';
+            throw new Error(`${action} partition definitions for existing PostgreSQL tables is not supported automatically (${tableDiff.name}: '${from ?? '<none>'}' -> '${to ?? '<none>'}'); create a manual migration instead`);
+        }
         const ret = [];
         const parts = tableDiff.name.split('.');
         const tableName = parts.pop();
@@ -680,7 +904,8 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         if (index.primary || (index.unique && index.constraint)) {
             return `alter table ${this.quote(table)} drop constraint ${this.quote(oldIndexName)}`;
         }
-        return `drop index ${this.quote(oldIndexName)}`;
+        const [schemaName] = this.splitTableName(table);
+        return `drop index ${this.quote(schemaName, oldIndexName)}`;
     }
     /**
      * Build the column list for a PostgreSQL index.

package/dialects/postgresql/index.d.ts

@@ -1,4 +1,6 @@
 export * from './PostgreSqlNativeQueryBuilder.js';
 export * from './BasePostgreSqlPlatform.js';
+export * from './BasePostgreSqlEntityManager.js';
 export * from './FullTextType.js';
 export * from './PostgreSqlSchemaHelper.js';
+export * from './typeOverrides.js';

package/dialects/postgresql/index.js

@@ -1,4 +1,6 @@
 export * from './PostgreSqlNativeQueryBuilder.js';
 export * from './BasePostgreSqlPlatform.js';
+export * from './BasePostgreSqlEntityManager.js';
 export * from './FullTextType.js';
 export * from './PostgreSqlSchemaHelper.js';
+export * from './typeOverrides.js';

package/dialects/postgresql/typeOverrides.d.ts

@@ -0,0 +1,14 @@
+/**
+ * MikroORM keeps PostgreSQL date/timestamp/interval values as raw strings
+ * (and array variants as `string[]`); both `pg` and `pglite` would otherwise
+ * eagerly parse them via `pg-types`. Centralizing the OID list here keeps the
+ * postgres and pglite drivers in lockstep, while leaving the actual array
+ * parsing implementation to the leaf driver (so `@mikro-orm/sql` stays free of
+ * postgres-array / postgres-date / postgres-interval dependencies).
+ *
+ * Use `select typname, oid, typarray from pg_type order by oid` to look up OIDs.
+ */
+type PostgreSqlArrayParser = (value: string) => string[];
+type PostgreSqlValueParser = (value: string) => unknown;
+export declare function createPostgreSqlTypeParsers(arrayParse: PostgreSqlArrayParser): Record<number, PostgreSqlValueParser>;
+export {};

package/dialects/postgresql/typeOverrides.js

@@ -0,0 +1,12 @@
+export function createPostgreSqlTypeParsers(arrayParse) {
+    const parsers = {};
+    for (const oid of [1082, 1114, 1184, 1186]) {
+        // date, timestamp, timestamptz, interval — kept as raw strings
+        parsers[oid] = str => str;
+    }
+    for (const oid of [1182, 1115, 1185, 1187]) {
+        // date[], timestamp[], timestamptz[], interval[]
+        parsers[oid] = arrayParse;
+    }
+    return parsers;
+}

package/dialects/sqlite/SqlitePlatform.d.ts

@@ -15,6 +15,7 @@ export declare class SqlitePlatform extends AbstractSqlPlatform {
     getDateTimeTypeDeclarationSQL(column: {
         length: number;
     }): string;
+    getDefaultVersionLength(): number;
     getBeginTransactionSQL(options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;

package/dialects/sqlite/SqlitePlatform.js

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

package/dialects/sqlite/SqliteSchemaHelper.d.ts

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