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

package/dialects/mysql/MySqlSchemaHelper.js

@@ -7,12 +7,34 @@ 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`;
         }
         return `set names ${charset};\n\n`;
     }
+    getSetSchemaSQL(schema) {
+        return `use ${this.quote(schema)}`;
+    }
+    getResetSchemaSQL(defaultSchema) {
+        return `use ${this.quote(defaultSchema)}`;
+    }
+    supportsMigrationSchema() {
+        return true;
+    }
+    async tableExists(connection, tableName, schemaName, ctx) {
+        // MySQL "schema" = database — when none is requested, probe the connection's current DB
+        // via `schema()` rather than the base impl's `getDefaultSchemaName()` (which is undefined here).
+        const schemaClause = schemaName
+            ? `table_schema = ${this.platform.quoteValue(schemaName)}`
+            : `table_schema = schema()`;
+        const rows = await connection.execute(`select 1 from information_schema.tables where ${schemaClause} and table_name = ${this.platform.quoteValue(tableName)}`, [], 'all', ctx);
+        return rows.length > 0;
+    }
     disableForeignKeysSQL() {
         return 'set foreign_key_checks = 0;';
     }
@@ -31,7 +53,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
         return sql;
     }
     getListTablesSQL() {
-        return `select table_name as table_name, nullif(table_schema, schema()) as schema_name, table_comment as table_comment from information_schema.tables where table_type = 'BASE TABLE' and table_schema = schema()`;
+        return `select table_name as table_name, nullif(table_schema, schema()) as schema_name, table_comment as table_comment, table_collation as table_collation from information_schema.tables where table_type = 'BASE TABLE' and table_schema = schema()`;
     }
     getListViewsSQL() {
         return `select table_name as view_name, nullif(table_schema, schema()) as schema_name, view_definition from information_schema.views where table_schema = schema()`;
@@ -64,11 +86,16 @@ export class MySqlSchemaHelper extends SchemaHelper {
         const checks = await this.getAllChecks(connection, tables, ctx);
         const fks = await this.getAllForeignKeys(connection, tables, ctx);
         const enums = await this.getAllEnumDefinitions(connection, tables, ctx);
+        const triggers = await this.getAllTriggers(connection, tables);
         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 = t.table_collation ?? undefined;
             const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
             table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums[key]);
+            if (triggers[key]) {
+                table.setTriggers(triggers[key]);
+            }
         }
     }
     async getAllIndexes(connection, tables, ctx) {
@@ -80,8 +107,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',
@@ -109,7 +139,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);
             }
@@ -146,10 +179,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);
+        }
         return index.columnNames
             .map(name => {
             const col = index.columns?.find(c => c.name === name);
@@ -190,22 +228,25 @@ export class MySqlSchemaHelper extends SchemaHelper {
         return sql;
     }
     async getAllColumns(connection, tables, ctx) {
-        const sql = `select table_name as table_name,
-      nullif(table_schema, schema()) as schema_name,
-      column_name as column_name,
-      column_default as column_default,
-      nullif(column_comment, '') as column_comment,
-      is_nullable as is_nullable,
-      data_type as data_type,
-      column_type as column_type,
-      column_key as column_key,
-      extra as extra,
-      generation_expression as generation_expression,
-      numeric_precision as numeric_precision,
-      numeric_scale as numeric_scale,
-      ifnull(datetime_precision, character_maximum_length) length
-      from information_schema.columns where table_schema = database() and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name))})
-      order by ordinal_position`;
+        const sql = `select c.table_name as table_name,
+      nullif(c.table_schema, schema()) as schema_name,
+      c.column_name as column_name,
+      c.column_default as column_default,
+      nullif(c.column_comment, '') as column_comment,
+      c.is_nullable as is_nullable,
+      c.data_type as data_type,
+      c.column_type as column_type,
+      c.column_key as column_key,
+      c.extra as extra,
+      c.generation_expression as generation_expression,
+      c.numeric_precision as numeric_precision,
+      c.numeric_scale as numeric_scale,
+      ifnull(c.datetime_precision, c.character_maximum_length) length,
+      nullif(c.collation_name, t.table_collation) as collation_name
+      from information_schema.columns c
+      join information_schema.tables t on t.table_schema = c.table_schema and t.table_name = c.table_name
+      where c.table_schema = database() and c.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name))})
+      order by c.ordinal_position`;
         const allColumns = await connection.execute(sql, [], 'all', ctx);
         const str = (val) => (val != null ? '' + val : val);
         const extra = (val) => val.replace(/auto_increment|default_generated|(stored|virtual) generated/i, '').trim() || undefined;
@@ -236,6 +277,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
                 precision: col.numeric_precision,
                 scale: col.numeric_scale,
                 comment: col.column_comment,
+                collation: col.collation_name ?? undefined,
                 extra: extra(col.extra),
                 generated,
             });
@@ -262,6 +304,194 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
+    /** Generates SQL to create MySQL triggers. MySQL requires one trigger per event. */
+    createTrigger(table, trigger) {
+        if (trigger.expression) {
+            return trigger.expression;
+        }
+        /* v8 ignore next 3 */
+        if (trigger.timing === 'instead of') {
+            throw new Error(`MySQL does not support INSTEAD OF triggers. Use BEFORE or AFTER for trigger "${trigger.name}".`);
+        }
+        /* v8 ignore next 5 */
+        if (trigger.forEach === 'statement') {
+            throw new Error(`MySQL does not support FOR EACH STATEMENT triggers. Use FOR EACH ROW for trigger "${trigger.name}".`);
+        }
+        const timing = trigger.timing.toUpperCase();
+        const ret = [];
+        for (const event of trigger.events) {
+            const name = trigger.events.length > 1 ? `${trigger.name}_${event}` : trigger.name;
+            ret.push(`create trigger ${this.quote(name)} ${timing} ${event.toUpperCase()} on ${table.getQuotedName()} for each ROW begin ${trigger.body}; end`);
+        }
+        return ret.join(';\n');
+    }
+    createRoutine(routine) {
+        if (routine.expression) {
+            return routine.expression;
+        }
+        const name = this.platform.quoteIdentifier(routine.name);
+        // MySQL functions reject direction prefixes (function params are always IN); procedures use them.
+        const params = routine.params
+            .map(p => {
+            const dir = routine.type === 'procedure' ? `${p.direction.toUpperCase()} ` : '';
+            return `${dir}${this.platform.quoteIdentifier(p.name)} ${p.type}`;
+        })
+            .join(', ');
+        const determinism = routine.deterministic === true ? ' deterministic' : routine.deterministic === false ? ' not deterministic' : '';
+        const dataAccess = this.formatDataAccess(routine.dataAccess);
+        const security = routine.security === 'definer'
+            ? ' sql security definer'
+            : routine.security === 'invoker'
+                ? ' sql security invoker'
+                : '';
+        const comment = routine.comment ? ` comment ${this.platform.quoteValue(routine.comment)}` : '';
+        const body = this.wrapRoutineBody(routine.body ?? '');
+        if (routine.type === 'procedure') {
+            return `create procedure ${name}(${params})${determinism}${dataAccess}${security}${comment} ${body}`;
+        }
+        const returnType = routine.returns?.type ?? 'text';
+        return `create function ${name}(${params}) returns ${returnType}${determinism}${dataAccess}${security}${comment} ${body}`;
+    }
+    dropRoutine(routine) {
+        const kind = routine.type === 'procedure' ? 'procedure' : 'function';
+        return `drop ${kind} if exists ${this.platform.quoteIdentifier(routine.name)}`;
+    }
+    async getAllRoutines(connection) {
+        const sql = `
+      select
+        r.routine_name as name,
+        r.routine_schema as schema_name,
+        lower(r.routine_type) as type,
+        r.routine_definition as body,
+        r.dtd_identifier as return_type,
+        r.is_deterministic as is_deterministic,
+        r.sql_data_access as sql_data_access,
+        r.security_type as security_type,
+        r.routine_comment as comment
+      from information_schema.routines r
+      where r.routine_schema = database()
+        and r.routine_type in ('PROCEDURE', 'FUNCTION')
+    `;
+        const [rows, params] = await Promise.all([
+            connection.execute(sql),
+            this.getAllRoutineParams(connection),
+        ]);
+        return rows.map(row => ({
+            name: row.name,
+            type: row.type,
+            // MySQL has no schema namespace for routines — undefined matches the metadata side.
+            schema: undefined,
+            body: this.stripRoutineBody(row.body ?? ''),
+            deterministic: row.is_deterministic === 'YES',
+            dataAccess: this.parseDataAccess(row.sql_data_access),
+            security: row.security_type === 'DEFINER' ? 'definer' : 'invoker',
+            comment: row.comment || undefined,
+            params: params.get(row.name) ?? [],
+            returns: row.type === 'function' && row.return_type ? { type: row.return_type } : undefined,
+        }));
+    }
+    async getAllRoutineParams(connection) {
+        const sql = `
+      select
+        specific_name as routine_name,
+        parameter_name as name,
+        parameter_mode as direction,
+        dtd_identifier as type,
+        ordinal_position as position
+      from information_schema.parameters
+      where specific_schema = database()
+        and parameter_name is not null
+      order by specific_name, ordinal_position
+    `;
+        const rows = await connection.execute(sql);
+        const out = new Map();
+        for (const row of rows) {
+            if (!out.has(row.routine_name)) {
+                out.set(row.routine_name, []);
+            }
+            out.get(row.routine_name).push({
+                name: row.name,
+                type: row.type,
+                direction: row.direction.toLowerCase(),
+            });
+        }
+        return out;
+    }
+    formatDataAccess(access) {
+        switch (access) {
+            case 'no-sql':
+                return ' no sql';
+            case 'reads-sql-data':
+                return ' reads sql data';
+            case 'modifies-sql-data':
+                return ' modifies sql data';
+            case 'contains-sql':
+                return ' contains sql';
+            default:
+                return '';
+        }
+    }
+    parseDataAccess(access) {
+        return access.toLowerCase().replace(/\s+/g, '-');
+    }
+    async getAllTriggers(connection, tables) {
+        const names = tables.map(t => this.platform.quoteValue(t.table_name)).join(', ');
+        const sql = `select trigger_name as trigger_name, event_object_table as table_name, nullif(event_object_schema, schema()) as schema_name,
+      event_manipulation as event, action_timing as timing,
+      action_orientation as for_each, action_statement as body
+    from information_schema.triggers
+    where event_object_schema = database()
+      and event_object_table in (${names})
+    order by trigger_name, event_manipulation`;
+        const allTriggers = await connection.execute(sql);
+        const ret = {};
+        // First pass: collect all raw trigger names per table to detect multi-event groups.
+        // A base name is only used for grouping if multiple triggers share it (e.g. trg_multi_insert + trg_multi_update).
+        const namesByTable = new Map();
+        for (const row of allTriggers) {
+            const key = this.getTableKey(row);
+            namesByTable.set(key, [...(namesByTable.get(key) ?? []), row.trigger_name]);
+        }
+        const triggerMap = new Map();
+        for (const row of allTriggers) {
+            const key = this.getTableKey(row);
+            const eventLower = row.event.toLowerCase();
+            const tableNames = namesByTable.get(key) ?? [];
+            // Only strip event suffix when another trigger with the same base exists for this table
+            const candidateBase = row.trigger_name.endsWith(`_${eventLower}`)
+                ? row.trigger_name.slice(0, -eventLower.length - 1)
+                : null;
+            const baseName = candidateBase && tableNames.some(n => n !== row.trigger_name && n.startsWith(`${candidateBase}_`))
+                ? candidateBase
+                : row.trigger_name;
+            const dedupeKey = `${key}:${baseName}`;
+            if (triggerMap.has(dedupeKey)) {
+                const existing = triggerMap.get(dedupeKey);
+                const event = eventLower;
+                if (!existing.events.includes(event)) {
+                    existing.events.push(event);
+                }
+                continue;
+            }
+            ret[key] ??= [];
+            // Strip BEGIN/END wrapper from MySQL action_statement
+            let body = row.body ?? '';
+            const beginEndMatch = /^\s*begin\s+([\s\S]*)\s*end\s*$/i.exec(body);
+            if (beginEndMatch) {
+                body = beginEndMatch[1].trim().replace(/;\s*$/, '');
+            }
+            const trigger = {
+                name: baseName,
+                timing: row.timing.toLowerCase(),
+                events: [eventLower],
+                forEach: (row.for_each ?? 'row').toLowerCase(),
+                body,
+            };
+            ret[key].push(trigger);
+            triggerMap.set(dedupeKey, trigger);
+        }
+        return ret;
+    }
     async getAllForeignKeys(connection, tables, ctx) {
         const sql = `select k.constraint_name as constraint_name, nullif(k.table_schema, schema()) as schema_name, k.table_name as table_name, k.column_name as column_name, k.referenced_table_name as referenced_table_name, k.referenced_column_name as referenced_column_name, c.update_rule as update_rule, c.delete_rule as delete_rule
         from information_schema.key_column_usage k
@@ -317,10 +547,13 @@ export class MySqlSchemaHelper extends SchemaHelper {
         const col = this.createTableColumn(column, table, changedProperties);
         return [`alter table ${table.getQuotedName()} modify ${col}`];
     }
+    // MySQL MODIFY/CHANGE resets omitted column attributes to the table default, so collation must
+    // be re-emitted on rename and comment-only paths to preserve a non-default column collation.
     getColumnDeclarationSQL(col) {
         let ret = col.type;
         ret += col.unsigned ? ' unsigned' : '';
         ret += col.autoincrement ? ' auto_increment' : '';
+        ret += col.collation ? ` ${this.getCollateSQL(col.collation)}` : '';
         ret += ' ';
         ret += col.nullable ? 'null' : 'not null';
         ret += col.default ? ' default ' + col.default : '';

package/dialects/oracledb/OracleDialect.d.ts

@@ -46,7 +46,7 @@ declare class OracleConnection implements DatabaseConnection {
         sql: string;
         bindParams: unknown[];
     };
-    streamQuery<R>(compiledQuery: CompiledQuery, _chunkSize?: number): AsyncIterableIterator<QueryResult<R>>;
+    streamQuery<R>(compiledQuery: CompiledQuery, chunkSize?: number): AsyncIterableIterator<QueryResult<R>>;
     get connection(): OraclePoolConnection;
 }
 declare class OracleDriver implements Driver {

package/dialects/oracledb/OracleDialect.js

@@ -66,13 +66,14 @@ class OracleConnection {
             bindParams: query.parameters,
         };
     }
-    async *streamQuery(compiledQuery, _chunkSize) {
+    async *streamQuery(compiledQuery, chunkSize) {
         const { sql, bindParams } = this.formatQuery(compiledQuery);
         const result = await this.#connection.execute(sql, bindParams, {
             resultSet: true,
             autoCommit: compiledQuery.autoCommit,
             outFormat: OUT_FORMAT_OBJECT,
             ...this.#executeOptions,
+            ...(chunkSize != null ? { fetchArraySize: chunkSize } : {}),
         });
         const rs = result.resultSet;
         try {

package/dialects/postgresql/BasePostgreSqlEntityManager.d.ts

@@ -0,0 +1,19 @@
+import { type EntityName } from '@mikro-orm/core';
+import { SqlEntityManager } from '../../SqlEntityManager.js';
+import type { AbstractSqlDriver } from '../../AbstractSqlDriver.js';
+/**
+ * Shared base class for PostgreSQL-flavoured entity managers (`pg`, `pglite`).
+ * Adds Postgres-only helpers on top of `SqlEntityManager`.
+ */
+export declare class BasePostgreSqlEntityManager<Driver extends AbstractSqlDriver = AbstractSqlDriver> extends SqlEntityManager<Driver> {
+    /**
+     * Refreshes a materialized view.
+     *
+     * @param entityName - The entity name or class of the materialized view
+     * @param options - Optional settings
+     * @param options.concurrently - If true, refreshes the view concurrently (requires a unique index on the view)
+     */
+    refreshMaterializedView<Entity extends object>(entityName: EntityName<Entity>, options?: {
+        concurrently?: boolean;
+    }): Promise<void>;
+}

package/dialects/postgresql/BasePostgreSqlEntityManager.js

@@ -0,0 +1,24 @@
+import { SqlEntityManager } from '../../SqlEntityManager.js';
+/**
+ * Shared base class for PostgreSQL-flavoured entity managers (`pg`, `pglite`).
+ * Adds Postgres-only helpers on top of `SqlEntityManager`.
+ */
+export class BasePostgreSqlEntityManager extends SqlEntityManager {
+    /**
+     * Refreshes a materialized view.
+     *
+     * @param entityName - The entity name or class of the materialized view
+     * @param options - Optional settings
+     * @param options.concurrently - If true, refreshes the view concurrently (requires a unique index on the view)
+     */
+    async refreshMaterializedView(entityName, options) {
+        const meta = this.getMetadata(entityName);
+        if (!meta.view || !meta.materialized) {
+            throw new Error(`Entity ${meta.className} is not a materialized view`);
+        }
+        const helper = this.getDriver().getPlatform().getSchemaHelper();
+        const schema = meta.schema ?? this.config.get('schema');
+        const sql = helper.refreshMaterializedView(meta.tableName, schema, options?.concurrently);
+        await this.execute(sql);
+    }
+}

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: {
@@ -70,6 +71,12 @@ export declare class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     }): string[];
     marshallArray(values: string[]): string;
     unmarshallArray(value: string): string[];
+    escape(value: any): string;
+    /**
+     * Ported from PostgreSQL 9.2.4 source code (`src/interfaces/libpq/fe-exec.c`),
+     * matching `pg.Client.prototype.escapeLiteral` so we don't need a `pg` dep here.
+     */
+    private escapeLiteral;
     getVarcharTypeDeclarationSQL(column: {
         length?: number;
     }): string;
@@ -108,4 +115,5 @@ export declare class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     }[]): string;
     getJsonArrayElementPropertySQL(alias: string, property: string, type: string): string;
     getDefaultClientUrl(): string;
+    caseInsensitiveCollationNames(): boolean;
 }

package/dialects/postgresql/BasePostgreSqlPlatform.js

@@ -30,6 +30,9 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     supportsMaterializedViews() {
         return true;
     }
+    supportsPartitionedTables() {
+        return true;
+    }
     supportsCustomPrimaryKeyNames() {
         return true;
     }
@@ -209,6 +212,50 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
             return v;
         });
     }
+    escape(value) {
+        if (typeof value === 'bigint') {
+            value = value.toString();
+        }
+        if (typeof value === 'string') {
+            return this.escapeLiteral(value);
+        }
+        if (value instanceof Date) {
+            return `'${this.formatDate(value)}'`;
+        }
+        if (ArrayBuffer.isView(value)) {
+            return `E'\\\\x${value.toString('hex')}'`;
+        }
+        if (Array.isArray(value)) {
+            return value.map(v => this.escape(v)).join(', ');
+        }
+        return value;
+    }
+    /**
+     * Ported from PostgreSQL 9.2.4 source code (`src/interfaces/libpq/fe-exec.c`),
+     * matching `pg.Client.prototype.escapeLiteral` so we don't need a `pg` dep here.
+     */
+    escapeLiteral(str) {
+        let hasBackslash = false;
+        let escaped = `'`;
+        for (let i = 0; i < str.length; i++) {
+            const c = str[i];
+            if (c === `'`) {
+                escaped += c + c;
+            }
+            else if (c === '\\') {
+                escaped += c + c;
+                hasBackslash = true;
+            }
+            else {
+                escaped += c;
+            }
+        }
+        escaped += `'`;
+        if (hasBackslash) {
+            escaped = ` E${escaped}`;
+        }
+        return escaped;
+    }
     getVarcharTypeDeclarationSQL(column) {
         if (column.length === -1) {
             return 'varchar';
@@ -370,4 +417,7 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     getDefaultClientUrl() {
         return 'postgresql://postgres@127.0.0.1:5432';
     }
+    caseInsensitiveCollationNames() {
+        return false;
+    }
 }

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 } from '../../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, TablePartitioning, SqlTriggerDef, SqlRoutineDef } from '../../typings.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
 import type { DatabaseTable } from '../../schema/DatabaseTable.js';
 export declare class PostgreSqlSchemaHelper extends SchemaHelper {
@@ -14,7 +14,12 @@ 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;
+    getSetSchemaSQL(schema: string): string;
+    getResetSchemaSQL(_defaultSchema: string): string;
+    supportsMigrationSchema(): boolean;
     getCreateDatabaseSQL(name: string): string;
     getListTablesSQL(): string;
     private getIgnoredViewsCondition;
@@ -23,11 +28,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.
@@ -49,6 +65,26 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
         items: string[];
     }>, ctx?: Transaction): Promise<Dictionary<Column[]>>;
     getAllChecks(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<CheckDef[]>>;
+    /** Generates SQL to create a PostgreSQL trigger and its associated function. */
+    createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    /** Generates SQL to drop a PostgreSQL trigger and its associated function. */
+    dropTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    createRoutine(routine: SqlRoutineDef): string;
+    dropRoutine(routine: SqlRoutineDef): string;
+    getAllRoutines(connection: AbstractSqlConnection, schemas?: string[]): Promise<SqlRoutineDef[]>;
+    private formatRoutineParams;
+    private parseRoutineParams;
+    /** PG canonicalises `$$` quoting to a tagged form like `$function$ ... $function$`; match the tag-aware form. */
+    private extractRoutineBody;
+    private getSchemaQualifiedTriggerFnName;
+    /**
+     * 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.
+     */
+    getDatabaseCollation(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string | undefined>;
+    getAllTriggers(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<SqlTriggerDef[]>>;
+    private getTriggersSQL;
     getAllForeignKeys(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<Dictionary<ForeignKey>>>;
     getNativeEnumDefinitions(connection: AbstractSqlConnection, schemas: string[], ctx?: Transaction): Promise<Dictionary<{
         name: string;
@@ -59,6 +95,7 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     getDropNativeEnumSQL(name: string, schema?: string): string;
     getAlterNativeEnumSQL(name: string, schema?: string, value?: string, items?: string[], oldItems?: string[]): string;
     private getEnumDefinitions;
+    protected getCollateSQL(collation: string): string;
     createTableColumn(column: Column, table: DatabaseTable): string | undefined;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     castColumn(name: string, type: string): string;