@mikro-orm/sql 7.1.0-dev.9 → 7.1.1-dev.0

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: {
@@ -46,6 +47,7 @@ export declare class BasePostgreSqlPlatform extends AbstractSqlPlatform {
         precision?: number;
         scale?: number;
         autoincrement?: boolean;
+        columnTypes?: string[];
     }): string;
     getMappedType(type: string): Type<unknown>;
     getRegExpOperator(val?: unknown, flags?: string): string;
@@ -69,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;
@@ -92,11 +100,8 @@ export declare class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     getDefaultMappedType(type: string): Type<unknown>;
     supportsSchemas(): boolean;
     getDefaultSchemaName(): string | undefined;
-    /**
-     * Returns the default name of index for the given columns
-     * cannot go past 63 character length for identifiers in MySQL
-     */
-    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
+    /** Postgres identifier limit (NAMEDATALEN - 1). */
+    getMaxIdentifierLength(): number;
     getDefaultPrimaryName(tableName: string, columns: string[]): string;
     /**
      * @inheritDoc
@@ -110,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;
     }
@@ -90,18 +93,27 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     }
     normalizeColumnType(type, options) {
         const simpleType = this.extractSimpleType(type);
-        if (['int', 'int4', 'integer'].includes(simpleType)) {
+        if (['int', 'int4', 'integer', 'serial'].includes(simpleType)) {
             return this.getIntegerTypeDeclarationSQL({});
         }
-        if (['bigint', 'int8'].includes(simpleType)) {
+        if (['bigint', 'int8', 'bigserial'].includes(simpleType)) {
             return this.getBigIntTypeDeclarationSQL({});
         }
-        if (['smallint', 'int2'].includes(simpleType)) {
+        if (['smallint', 'int2', 'smallserial'].includes(simpleType)) {
             return this.getSmallIntTypeDeclarationSQL({});
         }
         if (['boolean', 'bool'].includes(simpleType)) {
             return this.getBooleanTypeDeclarationSQL();
         }
+        if (['double', 'double precision', 'float8'].includes(simpleType)) {
+            return this.getDoubleDeclarationSQL();
+        }
+        if (['real', 'float4'].includes(simpleType)) {
+            return this.getFloatDeclarationSQL();
+        }
+        if (['timestamptz', 'timestamp with time zone'].includes(simpleType)) {
+            return this.getDateTimeTypeDeclarationSQL(options);
+        }
         if (['varchar', 'character varying'].includes(simpleType)) {
             return this.getVarcharTypeDeclarationSQL(options);
         }
@@ -114,6 +126,12 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
         if (['interval'].includes(simpleType)) {
             return this.getIntervalTypeDeclarationSQL(options);
         }
+        // TimeType.getColumnType drops the timezone qualifier, so detect tz aliases from the original column type.
+        const originalType = options.columnTypes?.[0]?.toLowerCase() ?? type;
+        if (/^timetz\b/.test(originalType) || /^time\s+with\s+time\s+zone\b/.test(originalType)) {
+            const length = options.length ?? this.getDefaultDateTimeLength();
+            return `timetz(${length})`;
+        }
         return super.normalizeColumnType(type, options);
     }
     getMappedType(type) {
@@ -194,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';
@@ -228,9 +290,9 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
             lastOperator = '->';
         }
         if (path.length === 0) {
-            return cast(`${root}${lastOperator}'${last}'`);
+            return cast(`${root}${lastOperator}${this.quoteValue(last)}`);
         }
-        return cast(`${root}->${path.map(a => this.quoteValue(a)).join('->')}${lastOperator}'${last}'`);
+        return cast(`${root}->${path.map(a => this.quoteValue(a)).join('->')}${lastOperator}${this.quoteValue(last)}`);
     }
     getJsonIndexDefinition(index) {
         return index.columnNames.map(column => {
@@ -250,7 +312,8 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
         if (RawQueryFragment.isKnownFragment(id)) {
             return super.quoteIdentifier(id);
         }
-        return `${quote}${id.toString().replace('.', `${quote}.${quote}`)}${quote}`;
+        const escaped = id.toString().replaceAll(quote, quote + quote);
+        return `${quote}${escaped.replace('.', `${quote}.${quote}`)}${quote}`;
     }
     pad(number, digits) {
         return String(number).padStart(digits, '0');
@@ -320,17 +383,9 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     getDefaultSchemaName() {
         return 'public';
     }
-    /**
-     * Returns the default name of index for the given columns
-     * cannot go past 63 character length for identifiers in MySQL
-     */
-    getIndexName(tableName, columns, type) {
-        const indexName = super.getIndexName(tableName, columns, type);
-        if (indexName.length > 63) {
-            const suffix = type === 'primary' ? 'pkey' : type;
-            return `${indexName.substring(0, 55 - type.length)}_${Utils.hash(indexName, 5)}_${suffix}`;
-        }
-        return indexName;
+    /** Postgres identifier limit (NAMEDATALEN - 1). */
+    getMaxIdentifierLength() {
+        return 63;
     }
     getDefaultPrimaryName(tableName, columns) {
         const indexName = `${tableName}_pkey`;
@@ -362,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, SqlTriggerDef } 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.
@@ -53,7 +69,20 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     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>>>;
@@ -66,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;