@mikro-orm/sql 7.1.0-dev.8 → 7.1.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()`;
@@ -68,6 +90,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
         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]) {
@@ -84,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',
@@ -113,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);
             }
@@ -150,40 +179,43 @@ 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.columns?.length) {
-            return index.columns
-                .map(col => {
-                const quotedName = this.quote(col.name);
-                // MySQL supports collation via expression: (column_name COLLATE collation_name)
-                // When collation is specified, wrap in parentheses as an expression
-                if (col.collation) {
-                    let expr = col.length ? `${quotedName}(${col.length})` : quotedName;
-                    expr = `(${expr} collate ${col.collation})`;
-                    // Sort order comes after the expression
-                    if (col.sort) {
-                        expr += ` ${col.sort}`;
-                    }
-                    return expr;
-                }
-                // Standard column definition without collation
-                let colDef = quotedName;
-                // MySQL supports prefix length
-                if (col.length) {
-                    colDef += `(${col.length})`;
-                }
-                // MySQL supports sort order
+        if (index.where) {
+            return this.emulatePartialIndexColumns(index);
+        }
+        return index.columnNames
+            .map(name => {
+            const col = index.columns?.find(c => c.name === name);
+            const quotedName = this.quote(name);
+            // MySQL supports collation via expression: (column_name COLLATE collation_name)
+            // When collation is specified, wrap in parentheses as an expression
+            if (col?.collation) {
+                let expr = col.length ? `${quotedName}(${col.length})` : quotedName;
+                expr = `(${expr} collate ${col.collation})`;
+                // Sort order comes after the expression
                 if (col.sort) {
-                    colDef += ` ${col.sort}`;
+                    expr += ` ${col.sort}`;
                 }
-                return colDef;
-            })
-                .join(', ');
-        }
-        return index.columnNames.map(c => this.quote(c)).join(', ');
+                return expr;
+            }
+            // Standard column definition without collation
+            let colDef = quotedName;
+            // MySQL supports prefix length
+            if (col?.length) {
+                colDef += `(${col.length})`;
+            }
+            // MySQL supports sort order
+            if (col?.sort) {
+                colDef += ` ${col.sort}`;
+            }
+            return colDef;
+        })
+            .join(', ');
     }
     /**
      * Append MySQL-specific index suffixes like INVISIBLE.
@@ -196,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;
@@ -242,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,
             });
@@ -289,6 +325,115 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }
         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,
@@ -402,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: {
@@ -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;
+    }
 }