@mikro-orm/sql 7.0.4 → 7.0.5-dev.0

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -1,256 +1,250 @@
-import { DeferMode, EnumType, Type, Utils } from '@mikro-orm/core';
+import { DeferMode, EnumType, Type, Utils, } from '@mikro-orm/core';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 /** PostGIS system views that should be automatically ignored */
 const POSTGIS_VIEWS = ['geography_columns', 'geometry_columns'];
 export class PostgreSqlSchemaHelper extends SchemaHelper {
-  static DEFAULT_VALUES = {
-    'now()': ['now()', 'current_timestamp'],
-    'current_timestamp(?)': ['current_timestamp(?)'],
-    "('now'::text)::timestamp(?) with time zone": ['current_timestamp(?)'],
-    "('now'::text)::timestamp(?) without time zone": ['current_timestamp(?)'],
-    'null::character varying': ['null'],
-    'null::timestamp with time zone': ['null'],
-    'null::timestamp without time zone': ['null'],
-  };
-  getSchemaBeginning(charset, disableForeignKeys) {
-    if (disableForeignKeys) {
-      return `set names '${charset}';\n${this.disableForeignKeysSQL()}\n\n`;
-    }
-    return `set names '${charset}';\n\n`;
-  }
-  getCreateDatabaseSQL(name) {
-    return `create database ${this.quote(name)}`;
-  }
-  getListTablesSQL() {
-    return (
-      `select table_name, table_schema as schema_name, ` +
-      `(select pg_catalog.obj_description(c.oid) from pg_catalog.pg_class c
+    static DEFAULT_VALUES = {
+        'now()': ['now()', 'current_timestamp'],
+        'current_timestamp(?)': ['current_timestamp(?)'],
+        "('now'::text)::timestamp(?) with time zone": ['current_timestamp(?)'],
+        "('now'::text)::timestamp(?) without time zone": ['current_timestamp(?)'],
+        'null::character varying': ['null'],
+        'null::timestamp with time zone': ['null'],
+        'null::timestamp without time zone': ['null'],
+    };
+    getSchemaBeginning(charset, disableForeignKeys) {
+        if (disableForeignKeys) {
+            return `set names '${charset}';\n${this.disableForeignKeysSQL()}\n\n`;
+        }
+        return `set names '${charset}';\n\n`;
+    }
+    getCreateDatabaseSQL(name) {
+        return `create database ${this.quote(name)}`;
+    }
+    getListTablesSQL() {
+        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 ` +
-      `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) ` +
-      `order by table_name`
-    );
-  }
-  getIgnoredViewsCondition() {
-    return POSTGIS_VIEWS.map(v => `table_name != '${v}'`).join(' and ');
-  }
-  getListViewsSQL() {
-    return (
-      `select table_name as view_name, table_schema as schema_name, view_definition ` +
-      `from information_schema.views ` +
-      `where ${this.getIgnoredNamespacesConditionSQL('table_schema')} ` +
-      `and ${this.getIgnoredViewsCondition()} ` +
-      `order by table_name`
-    );
-  }
-  async loadViews(schema, connection) {
-    const views = await connection.execute(this.getListViewsSQL());
-    for (const view of views) {
-      const definition = view.view_definition?.trim().replace(/;$/, '') ?? '';
-      if (definition) {
-        schema.addView(view.view_name, view.schema_name, definition);
-      }
-    }
-  }
-  getListMaterializedViewsSQL() {
-    return (
-      `select matviewname as view_name, schemaname as schema_name, definition as view_definition ` +
-      `from pg_matviews ` +
-      `where ${this.getIgnoredNamespacesConditionSQL('schemaname')} ` +
-      `order by matviewname`
-    );
-  }
-  async loadMaterializedViews(schema, connection, schemaName) {
-    const views = await connection.execute(this.getListMaterializedViewsSQL());
-    for (const view of views) {
-      const definition = view.view_definition?.trim().replace(/;$/, '') ?? '';
-      if (definition) {
-        schema.addView(view.view_name, view.schema_name, definition, true);
-      }
-    }
-  }
-  createMaterializedView(name, schema, definition, withData = true) {
-    const viewName = this.quote(this.getTableName(name, schema));
-    const dataClause = withData ? ' with data' : ' with no data';
-    return `create materialized view ${viewName} as ${definition}${dataClause}`;
-  }
-  dropMaterializedViewIfExists(name, schema) {
-    return `drop materialized view if exists ${this.quote(this.getTableName(name, schema))} cascade`;
-  }
-  refreshMaterializedView(name, schema, concurrently = false) {
-    const concurrent = concurrently ? ' concurrently' : '';
-    return `refresh materialized view${concurrent} ${this.quote(this.getTableName(name, schema))}`;
-  }
-  async getNamespaces(connection) {
-    const sql =
-      `select schema_name from information_schema.schemata ` +
-      `where ${this.getIgnoredNamespacesConditionSQL()} ` +
-      `order by schema_name`;
-    const res = await connection.execute(sql);
-    return res.map(row => row.schema_name);
-  }
-  getIgnoredNamespacesConditionSQL(column = 'schema_name') {
-    const ignored = [
-      'information_schema',
-      'tiger',
-      'topology',
-      /* v8 ignore next */
-      ...(this.platform.getConfig().get('schemaGenerator').ignoreSchema ?? []),
-    ]
-      .map(s => this.platform.quoteValue(s))
-      .join(', ');
-    const ignoredPrefixes = ['pg_', 'crdb_', '_timescaledb_'].map(p => `"${column}" not like '${p}%'`).join(' and ');
-    return `${ignoredPrefixes} and "${column}" not in (${ignored})`;
-  }
-  async loadInformationSchema(schema, connection, tables, schemas) {
-    schemas ??= tables.length === 0 ? [schema.name] : tables.map(t => t.schema_name);
-    const nativeEnums = await this.getNativeEnumDefinitions(connection, schemas);
-    schema.setNativeEnums(nativeEnums);
-    if (tables.length === 0) {
-      return;
-    }
-    const tablesBySchema = this.getTablesGroupedBySchemas(tables);
-    const columns = await this.getAllColumns(connection, tablesBySchema, nativeEnums);
-    const indexes = await this.getAllIndexes(connection, tables);
-    const checks = await this.getAllChecks(connection, tablesBySchema);
-    const fks = await this.getAllForeignKeys(connection, tablesBySchema);
-    for (const t of tables) {
-      const key = this.getTableKey(t);
-      const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
-      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);
-      }
-    }
-  }
-  async getAllIndexes(connection, tables) {
-    const sql = this.getIndexesSQL(tables);
-    const unquote = str => str.replace(/['"`]/g, '');
-    const allIndexes = await connection.execute(sql);
-    const ret = {};
-    for (const index of allIndexes) {
-      const key = this.getTableKey(index);
-      // Extract INCLUDE columns from expression first, to filter them from key columns
-      const includeMatch = index.expression?.match(/include\s*\(([^)]+)\)/i);
-      const includeColumns = includeMatch ? includeMatch[1].split(',').map(col => unquote(col.trim())) : [];
-      // Filter out INCLUDE columns from the column definitions to get only key columns
-      const keyColumnDefs = index.index_def.filter(col => !includeColumns.includes(unquote(col)));
-      // Parse sort order and NULLS ordering from the full expression
-      // pg_get_indexdef individual columns don't include sort modifiers, so we parse from full expression
-      const columns = this.parseIndexColumnsFromExpression(index.expression, keyColumnDefs, unquote);
-      const columnNames = columns.map(col => col.name);
-      const hasAdvancedColumnOptions = columns.some(col => col.sort || col.nulls || col.collation);
-      const indexDef = {
-        columnNames,
-        composite: columnNames.length > 1,
-        // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
-        constraint: index.contype === 'u',
-        keyName: index.constraint_name,
-        unique: index.unique,
-        primary: index.primary,
-      };
-      // Add columns array if there are advanced options
-      if (hasAdvancedColumnOptions) {
-        indexDef.columns = columns;
-      }
-      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)) {
-        indexDef.expression = index.expression;
-      }
-      if (index.deferrable) {
-        indexDef.deferMode = index.initially_deferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
-      }
-      // Extract fillFactor from reloptions
-      if (index.reloptions) {
-        const fillFactorMatch = index.reloptions.find(opt => opt.startsWith('fillfactor='));
-        if (fillFactorMatch) {
-          indexDef.fillFactor = parseInt(fillFactorMatch.split('=')[1], 10);
-        }
-      }
-      // Add INCLUDE columns (already extracted above)
-      if (includeColumns.length > 0) {
-        indexDef.include = includeColumns;
-      }
-      // Add index type if not btree (the default)
-      if (index.index_type && index.index_type !== 'btree') {
-        indexDef.type = index.index_type;
-      }
-      ret[key] ??= [];
-      ret[key].push(indexDef);
-    }
-    return ret;
-  }
-  /**
-   * Parses column definitions from the full CREATE INDEX expression.
-   * Since pg_get_indexdef(oid, col_num, true) doesn't include sort modifiers,
-   * we extract them from the full expression instead.
-   *
-   * We use columnDefs (from individual pg_get_indexdef calls) as the source
-   * of column names, and find their modifiers in the expression.
-   */
-  parseIndexColumnsFromExpression(expression, columnDefs, unquote) {
-    // Extract just the column list from the expression (between first parens after USING)
-    // Pattern: ... USING method (...columns...) [INCLUDE (...)] [WHERE ...]
-    // Note: pg_get_indexdef always returns a valid expression with USING clause
-    const usingMatch = /using\s+\w+\s*\(/i.exec(expression);
-    const startIdx = usingMatch.index + usingMatch[0].length - 1; // Position of opening (
-    const columnsStr = this.extractParenthesizedContent(expression, startIdx);
-    // Use the column names from columnDefs and find their modifiers in the expression
-    return columnDefs.map(colDef => {
-      const name = unquote(colDef);
-      const result = { name };
-      // Find this column in the expression and extract modifiers
-      // Create a pattern that matches the column name (quoted or unquoted) followed by modifiers
-      const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-      const colPattern = new RegExp(`"?${escapedName}"?\\s*([^,)]*?)(?:,|$)`, 'i');
-      const colMatch = columnsStr.match(colPattern);
-      if (colMatch) {
-        const modifiers = colMatch[1];
-        // Extract sort order (PostgreSQL omits ASC in output as it's the default)
-        if (/\bdesc\b/i.test(modifiers)) {
-          result.sort = 'DESC';
-        }
-        // Extract NULLS ordering
-        const nullsMatch = /nulls\s+(first|last)/i.exec(modifiers);
-        if (nullsMatch) {
-          result.nulls = nullsMatch[1].toUpperCase();
-        }
-        // Extract collation
-        const collateMatch = /collate\s+"?([^"\s,)]+)"?/i.exec(modifiers);
-        if (collateMatch) {
-          result.collation = collateMatch[1];
-        }
-      }
-      return result;
-    });
-  }
-  /**
-   * Extracts the content inside parentheses starting at the given position.
-   * Handles nested parentheses correctly.
-   */
-  extractParenthesizedContent(str, startIdx) {
-    let depth = 0;
-    const start = startIdx + 1;
-    for (let i = startIdx; i < str.length; i++) {
-      if (str[i] === '(') {
-        depth++;
-      } else if (str[i] === ')') {
-        depth--;
-        if (depth === 0) {
-          return str.slice(start, i);
-        }
-      }
-    }
-    /* v8 ignore next - pg_get_indexdef always returns balanced parentheses */
-    return '';
-  }
-  async getAllColumns(connection, tablesBySchemas, nativeEnums) {
-    const sql = `select table_schema as schema_name, table_name, column_name,
+            `from information_schema.tables ` +
+            `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) ` +
+            `order by table_name`);
+    }
+    getIgnoredViewsCondition() {
+        return POSTGIS_VIEWS.map(v => `table_name != '${v}'`).join(' and ');
+    }
+    getListViewsSQL() {
+        return (`select table_name as view_name, table_schema as schema_name, view_definition ` +
+            `from information_schema.views ` +
+            `where ${this.getIgnoredNamespacesConditionSQL('table_schema')} ` +
+            `and ${this.getIgnoredViewsCondition()} ` +
+            `order by table_name`);
+    }
+    async loadViews(schema, connection) {
+        const views = await connection.execute(this.getListViewsSQL());
+        for (const view of views) {
+            const definition = view.view_definition?.trim().replace(/;$/, '') ?? '';
+            if (definition) {
+                schema.addView(view.view_name, view.schema_name, definition);
+            }
+        }
+    }
+    getListMaterializedViewsSQL() {
+        return (`select matviewname as view_name, schemaname as schema_name, definition as view_definition ` +
+            `from pg_matviews ` +
+            `where ${this.getIgnoredNamespacesConditionSQL('schemaname')} ` +
+            `order by matviewname`);
+    }
+    async loadMaterializedViews(schema, connection, schemaName) {
+        const views = await connection.execute(this.getListMaterializedViewsSQL());
+        for (const view of views) {
+            const definition = view.view_definition?.trim().replace(/;$/, '') ?? '';
+            if (definition) {
+                schema.addView(view.view_name, view.schema_name, definition, true);
+            }
+        }
+    }
+    createMaterializedView(name, schema, definition, withData = true) {
+        const viewName = this.quote(this.getTableName(name, schema));
+        const dataClause = withData ? ' with data' : ' with no data';
+        return `create materialized view ${viewName} as ${definition}${dataClause}`;
+    }
+    dropMaterializedViewIfExists(name, schema) {
+        return `drop materialized view if exists ${this.quote(this.getTableName(name, schema))} cascade`;
+    }
+    refreshMaterializedView(name, schema, concurrently = false) {
+        const concurrent = concurrently ? ' concurrently' : '';
+        return `refresh materialized view${concurrent} ${this.quote(this.getTableName(name, schema))}`;
+    }
+    async getNamespaces(connection) {
+        const sql = `select schema_name from information_schema.schemata ` +
+            `where ${this.getIgnoredNamespacesConditionSQL()} ` +
+            `order by schema_name`;
+        const res = await connection.execute(sql);
+        return res.map(row => row.schema_name);
+    }
+    getIgnoredNamespacesConditionSQL(column = 'schema_name') {
+        const ignored = [
+            'information_schema',
+            'tiger',
+            'topology',
+            /* v8 ignore next */
+            ...(this.platform.getConfig().get('schemaGenerator').ignoreSchema ?? []),
+        ]
+            .map(s => this.platform.quoteValue(s))
+            .join(', ');
+        const ignoredPrefixes = ['pg_', 'crdb_', '_timescaledb_'].map(p => `"${column}" not like '${p}%'`).join(' and ');
+        return `${ignoredPrefixes} and "${column}" not in (${ignored})`;
+    }
+    async loadInformationSchema(schema, connection, tables, schemas) {
+        schemas ??= tables.length === 0 ? [schema.name] : tables.map(t => t.schema_name);
+        const nativeEnums = await this.getNativeEnumDefinitions(connection, schemas);
+        schema.setNativeEnums(nativeEnums);
+        if (tables.length === 0) {
+            return;
+        }
+        const tablesBySchema = this.getTablesGroupedBySchemas(tables);
+        const columns = await this.getAllColumns(connection, tablesBySchema, nativeEnums);
+        const indexes = await this.getAllIndexes(connection, tables);
+        const checks = await this.getAllChecks(connection, tablesBySchema);
+        const fks = await this.getAllForeignKeys(connection, tablesBySchema);
+        for (const t of tables) {
+            const key = this.getTableKey(t);
+            const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
+            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);
+            }
+        }
+    }
+    async getAllIndexes(connection, tables) {
+        const sql = this.getIndexesSQL(tables);
+        const unquote = (str) => str.replace(/['"`]/g, '');
+        const allIndexes = await connection.execute(sql);
+        const ret = {};
+        for (const index of allIndexes) {
+            const key = this.getTableKey(index);
+            // Extract INCLUDE columns from expression first, to filter them from key columns
+            const includeMatch = index.expression?.match(/include\s*\(([^)]+)\)/i);
+            const includeColumns = includeMatch ? includeMatch[1].split(',').map((col) => unquote(col.trim())) : [];
+            // Filter out INCLUDE columns from the column definitions to get only key columns
+            const keyColumnDefs = index.index_def.filter((col) => !includeColumns.includes(unquote(col)));
+            // Parse sort order and NULLS ordering from the full expression
+            // pg_get_indexdef individual columns don't include sort modifiers, so we parse from full expression
+            const columns = this.parseIndexColumnsFromExpression(index.expression, keyColumnDefs, unquote);
+            const columnNames = columns.map(col => col.name);
+            const hasAdvancedColumnOptions = columns.some(col => col.sort || col.nulls || col.collation);
+            const indexDef = {
+                columnNames,
+                composite: columnNames.length > 1,
+                // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
+                constraint: index.contype === 'u',
+                keyName: index.constraint_name,
+                unique: index.unique,
+                primary: index.primary,
+            };
+            // Add columns array if there are advanced options
+            if (hasAdvancedColumnOptions) {
+                indexDef.columns = columns;
+            }
+            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)) {
+                indexDef.expression = index.expression;
+            }
+            if (index.deferrable) {
+                indexDef.deferMode = index.initially_deferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
+            }
+            // Extract fillFactor from reloptions
+            if (index.reloptions) {
+                const fillFactorMatch = index.reloptions.find((opt) => opt.startsWith('fillfactor='));
+                if (fillFactorMatch) {
+                    indexDef.fillFactor = parseInt(fillFactorMatch.split('=')[1], 10);
+                }
+            }
+            // Add INCLUDE columns (already extracted above)
+            if (includeColumns.length > 0) {
+                indexDef.include = includeColumns;
+            }
+            // Add index type if not btree (the default)
+            if (index.index_type && index.index_type !== 'btree') {
+                indexDef.type = index.index_type;
+            }
+            ret[key] ??= [];
+            ret[key].push(indexDef);
+        }
+        return ret;
+    }
+    /**
+     * Parses column definitions from the full CREATE INDEX expression.
+     * Since pg_get_indexdef(oid, col_num, true) doesn't include sort modifiers,
+     * we extract them from the full expression instead.
+     *
+     * We use columnDefs (from individual pg_get_indexdef calls) as the source
+     * of column names, and find their modifiers in the expression.
+     */
+    parseIndexColumnsFromExpression(expression, columnDefs, unquote) {
+        // Extract just the column list from the expression (between first parens after USING)
+        // Pattern: ... USING method (...columns...) [INCLUDE (...)] [WHERE ...]
+        // Note: pg_get_indexdef always returns a valid expression with USING clause
+        const usingMatch = /using\s+\w+\s*\(/i.exec(expression);
+        const startIdx = usingMatch.index + usingMatch[0].length - 1; // Position of opening (
+        const columnsStr = this.extractParenthesizedContent(expression, startIdx);
+        // Use the column names from columnDefs and find their modifiers in the expression
+        return columnDefs.map(colDef => {
+            const name = unquote(colDef);
+            const result = { name };
+            // Find this column in the expression and extract modifiers
+            // Create a pattern that matches the column name (quoted or unquoted) followed by modifiers
+            const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const colPattern = new RegExp(`"?${escapedName}"?\\s*([^,)]*?)(?:,|$)`, 'i');
+            const colMatch = columnsStr.match(colPattern);
+            if (colMatch) {
+                const modifiers = colMatch[1];
+                // Extract sort order (PostgreSQL omits ASC in output as it's the default)
+                if (/\bdesc\b/i.test(modifiers)) {
+                    result.sort = 'DESC';
+                }
+                // Extract NULLS ordering
+                const nullsMatch = /nulls\s+(first|last)/i.exec(modifiers);
+                if (nullsMatch) {
+                    result.nulls = nullsMatch[1].toUpperCase();
+                }
+                // Extract collation
+                const collateMatch = /collate\s+"?([^"\s,)]+)"?/i.exec(modifiers);
+                if (collateMatch) {
+                    result.collation = collateMatch[1];
+                }
+            }
+            return result;
+        });
+    }
+    /**
+     * Extracts the content inside parentheses starting at the given position.
+     * Handles nested parentheses correctly.
+     */
+    extractParenthesizedContent(str, startIdx) {
+        let depth = 0;
+        const start = startIdx + 1;
+        for (let i = startIdx; i < str.length; i++) {
+            if (str[i] === '(') {
+                depth++;
+            }
+            else if (str[i] === ')') {
+                depth--;
+                if (depth === 0) {
+                    return str.slice(start, i);
+                }
+            }
+        }
+        /* v8 ignore next - pg_get_indexdef always returns balanced parentheses */
+        return '';
+    }
+    async getAllColumns(connection, tablesBySchemas, nativeEnums) {
+        const sql = `select table_schema as schema_name, table_name, column_name,
       column_default,
       is_nullable,
       udt_name,
@@ -269,115 +263,111 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       join pg_attribute pga on pgc.oid = pga.attrelid and cols.column_name = pga.attname
       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);
-    const str = val => (val != null ? '' + val : val);
-    const ret = {};
-    for (const col of allColumns) {
-      const mappedType = connection.getPlatform().getMappedType(col.data_type);
-      const increments =
-        (col.column_default?.includes('nextval') || col.is_identity === 'YES') &&
-        connection.getPlatform().isNumericColumn(mappedType);
-      const key = this.getTableKey(col);
-      ret[key] ??= [];
-      let type = col.data_type.toLowerCase() === 'array' ? col.udt_name.replace(/^_(.*)$/, '$1[]') : col.udt_name;
-      if (
-        col.data_type === 'USER-DEFINED' &&
-        col.udt_schema &&
-        col.udt_schema !== this.platform.getDefaultSchemaName()
-      ) {
-        type = `${col.udt_schema}.${type}`;
-      }
-      if (type === 'bpchar') {
-        type = 'char';
-      }
-      if (type === 'vector' && col.length == null && col.custom_length != null && col.custom_length !== -1) {
-        col.length = col.custom_length;
-      }
-      if (col.length != null && !type.endsWith(`(${col.length})`) && !['text', 'date'].includes(type)) {
-        type += `(${col.length})`;
-      }
-      if (type === 'numeric' && col.numeric_precision != null && col.numeric_scale != null) {
-        type += `(${col.numeric_precision},${col.numeric_scale})`;
-      }
-      const length = this.inferLengthFromColumnType(type) === -1 ? -1 : col.length;
-      const column = {
-        name: col.column_name,
-        type,
-        mappedType,
-        length,
-        precision: col.numeric_precision,
-        scale: col.numeric_scale,
-        nullable: col.is_nullable === 'YES',
-        default: str(this.normalizeDefaultValue(col.column_default, col.length)),
-        unsigned: increments,
-        autoincrement: increments,
-        generated:
-          col.is_identity === 'YES'
-            ? col.identity_generation === 'BY DEFAULT'
-              ? 'by default as identity'
-              : 'identity'
-            : col.generation_expression
-              ? col.generation_expression + ' stored'
-              : undefined,
-        comment: col.column_comment,
-      };
-      let enumKey = column.type;
-      let enumEntry = nativeEnums?.[enumKey];
-      // for array enum columns, strip the [] suffix and try the base type,
-      // try schema-qualified key first for non-default schemas to avoid
-      // ambiguity when multiple schemas have enums with the same name
-      if (!enumEntry && enumKey.endsWith('[]')) {
-        const baseType = enumKey.slice(0, -2);
-        if (col.udt_schema && col.udt_schema !== this.platform.getDefaultSchemaName()) {
-          const schemaKey = `${col.udt_schema}.${baseType}`;
-          enumEntry = nativeEnums?.[schemaKey];
-          if (enumEntry) {
-            enumKey = schemaKey;
-            column.type = `${schemaKey}[]`;
-          }
-        }
-        if (!enumEntry) {
-          enumEntry = nativeEnums?.[baseType];
-          if (enumEntry) {
-            enumKey = baseType;
-          }
-        }
-      }
-      if (enumEntry) {
-        column.mappedType = Type.getType(EnumType);
-        column.nativeEnumName = enumKey;
-        column.enumItems = enumEntry.items;
-      }
-      ret[key].push(column);
-    }
-    return ret;
-  }
-  async getAllChecks(connection, tablesBySchemas) {
-    const sql = this.getChecksSQL(tablesBySchemas);
-    const allChecks = await connection.execute(sql);
-    const ret = {};
-    const seen = new Set();
-    for (const check of allChecks) {
-      const key = this.getTableKey(check);
-      const dedupeKey = `${key}:${check.name}`;
-      if (seen.has(dedupeKey)) {
-        continue;
-      }
-      seen.add(dedupeKey);
-      ret[key] ??= [];
-      const m = /^check \(\((.*)\)\)$/is.exec(check.expression);
-      const def = m?.[1].replace(/\((.*?)\)::\w+/g, '$1');
-      ret[key].push({
-        name: check.name,
-        columnName: check.column_name,
-        definition: check.expression,
-        expression: def,
-      });
-    }
-    return ret;
-  }
-  async getAllForeignKeys(connection, tablesBySchemas) {
-    const sql = `select nsp1.nspname schema_name, cls1.relname table_name, nsp2.nspname referenced_schema_name,
+        const allColumns = await connection.execute(sql);
+        const str = (val) => (val != null ? '' + val : val);
+        const ret = {};
+        for (const col of allColumns) {
+            const mappedType = connection.getPlatform().getMappedType(col.data_type);
+            const increments = (col.column_default?.includes('nextval') || col.is_identity === 'YES') &&
+                connection.getPlatform().isNumericColumn(mappedType);
+            const key = this.getTableKey(col);
+            ret[key] ??= [];
+            let type = col.data_type.toLowerCase() === 'array' ? col.udt_name.replace(/^_(.*)$/, '$1[]') : col.udt_name;
+            if (col.data_type === 'USER-DEFINED' &&
+                col.udt_schema &&
+                col.udt_schema !== this.platform.getDefaultSchemaName()) {
+                type = `${col.udt_schema}.${type}`;
+            }
+            if (type === 'bpchar') {
+                type = 'char';
+            }
+            if (type === 'vector' && col.length == null && col.custom_length != null && col.custom_length !== -1) {
+                col.length = col.custom_length;
+            }
+            if (col.length != null && !type.endsWith(`(${col.length})`) && !['text', 'date'].includes(type)) {
+                type += `(${col.length})`;
+            }
+            if (type === 'numeric' && col.numeric_precision != null && col.numeric_scale != null) {
+                type += `(${col.numeric_precision},${col.numeric_scale})`;
+            }
+            const length = this.inferLengthFromColumnType(type) === -1 ? -1 : col.length;
+            const column = {
+                name: col.column_name,
+                type,
+                mappedType,
+                length,
+                precision: col.numeric_precision,
+                scale: col.numeric_scale,
+                nullable: col.is_nullable === 'YES',
+                default: str(this.normalizeDefaultValue(col.column_default, col.length)),
+                unsigned: increments,
+                autoincrement: increments,
+                generated: col.is_identity === 'YES'
+                    ? col.identity_generation === 'BY DEFAULT'
+                        ? 'by default as identity'
+                        : 'identity'
+                    : col.generation_expression
+                        ? col.generation_expression + ' stored'
+                        : undefined,
+                comment: col.column_comment,
+            };
+            let enumKey = column.type;
+            let enumEntry = nativeEnums?.[enumKey];
+            // for array enum columns, strip the [] suffix and try the base type,
+            // try schema-qualified key first for non-default schemas to avoid
+            // ambiguity when multiple schemas have enums with the same name
+            if (!enumEntry && enumKey.endsWith('[]')) {
+                const baseType = enumKey.slice(0, -2);
+                if (col.udt_schema && col.udt_schema !== this.platform.getDefaultSchemaName()) {
+                    const schemaKey = `${col.udt_schema}.${baseType}`;
+                    enumEntry = nativeEnums?.[schemaKey];
+                    if (enumEntry) {
+                        enumKey = schemaKey;
+                        column.type = `${schemaKey}[]`;
+                    }
+                }
+                if (!enumEntry) {
+                    enumEntry = nativeEnums?.[baseType];
+                    if (enumEntry) {
+                        enumKey = baseType;
+                    }
+                }
+            }
+            if (enumEntry) {
+                column.mappedType = Type.getType(EnumType);
+                column.nativeEnumName = enumKey;
+                column.enumItems = enumEntry.items;
+            }
+            ret[key].push(column);
+        }
+        return ret;
+    }
+    async getAllChecks(connection, tablesBySchemas) {
+        const sql = this.getChecksSQL(tablesBySchemas);
+        const allChecks = await connection.execute(sql);
+        const ret = {};
+        const seen = new Set();
+        for (const check of allChecks) {
+            const key = this.getTableKey(check);
+            const dedupeKey = `${key}:${check.name}`;
+            if (seen.has(dedupeKey)) {
+                continue;
+            }
+            seen.add(dedupeKey);
+            ret[key] ??= [];
+            const m = /^check \(\((.*)\)\)$/is.exec(check.expression);
+            const def = m?.[1].replace(/\((.*?)\)::\w+/g, '$1');
+            ret[key].push({
+                name: check.name,
+                columnName: check.column_name,
+                definition: check.expression,
+                expression: def,
+            });
+        }
+        return ret;
+    }
+    async getAllForeignKeys(connection, tablesBySchemas) {
+        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,
       confupdtype update_rule, confdeltype delete_rule, array_position(con.conkey,a.attnum) as ord, condeferrable, condeferred,
       pg_get_constraintdef(con.oid) as constraint_def
@@ -391,360 +381,342 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(cls1.relname in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}) and nsp1.nspname = ${this.platform.quoteValue(schema)})`).join(' or ')})
       and confrelid > 0
       order by nsp1.nspname, cls1.relname, constraint_name, ord`;
-    const allFks = await connection.execute(sql);
-    const ret = {};
-    function mapReferentialIntegrity(value, def) {
-      const match = ['n', 'd'].includes(value) && /ON DELETE (SET (NULL|DEFAULT) \(.*?\))/.exec(def);
-      if (match) {
-        return match[1];
-      }
-      /* v8 ignore next */
-      switch (value) {
-        case 'r':
-          return 'RESTRICT';
-        case 'c':
-          return 'CASCADE';
-        case 'n':
-          return 'SET NULL';
-        case 'd':
-          return 'SET DEFAULT';
-        case 'a':
-        default:
-          return 'NO ACTION';
-      }
-    }
-    for (const fk of allFks) {
-      fk.update_rule = mapReferentialIntegrity(fk.update_rule, fk.constraint_def);
-      fk.delete_rule = mapReferentialIntegrity(fk.delete_rule, fk.constraint_def);
-      if (fk.condeferrable) {
-        fk.defer_mode = fk.condeferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
-      }
-      const key = this.getTableKey(fk);
-      ret[key] ??= [];
-      ret[key].push(fk);
-    }
-    Object.keys(ret).forEach(key => {
-      const [schemaName, tableName] = key.split('.');
-      ret[key] = this.mapForeignKeys(ret[key], tableName, schemaName);
-    });
-    return ret;
-  }
-  async getNativeEnumDefinitions(connection, schemas) {
-    const uniqueSchemas = Utils.unique(schemas);
-    const res = await connection.execute(
-      `select t.typname as enum_name, n.nspname as schema_name, array_agg(e.enumlabel order by e.enumsortorder) as enum_value
+        const allFks = await connection.execute(sql);
+        const ret = {};
+        function mapReferentialIntegrity(value, def) {
+            const match = ['n', 'd'].includes(value) && /ON DELETE (SET (NULL|DEFAULT) \(.*?\))/.exec(def);
+            if (match) {
+                return match[1];
+            }
+            /* v8 ignore next */
+            switch (value) {
+                case 'r':
+                    return 'RESTRICT';
+                case 'c':
+                    return 'CASCADE';
+                case 'n':
+                    return 'SET NULL';
+                case 'd':
+                    return 'SET DEFAULT';
+                case 'a':
+                default:
+                    return 'NO ACTION';
+            }
+        }
+        for (const fk of allFks) {
+            fk.update_rule = mapReferentialIntegrity(fk.update_rule, fk.constraint_def);
+            fk.delete_rule = mapReferentialIntegrity(fk.delete_rule, fk.constraint_def);
+            if (fk.condeferrable) {
+                fk.defer_mode = fk.condeferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
+            }
+            const key = this.getTableKey(fk);
+            ret[key] ??= [];
+            ret[key].push(fk);
+        }
+        Object.keys(ret).forEach(key => {
+            const [schemaName, tableName] = key.split('.');
+            ret[key] = this.mapForeignKeys(ret[key], tableName, schemaName);
+        });
+        return ret;
+    }
+    async getNativeEnumDefinitions(connection, schemas) {
+        const uniqueSchemas = Utils.unique(schemas);
+        const res = await connection.execute(`select t.typname as enum_name, n.nspname as schema_name, array_agg(e.enumlabel order by e.enumsortorder) as enum_value
         from pg_type t
         join pg_enum e on t.oid = e.enumtypid
         join pg_catalog.pg_namespace n on n.oid = t.typnamespace
         where n.nspname in (${Array(uniqueSchemas.length).fill('?').join(', ')})
-        group by t.typname, n.nspname`,
-      uniqueSchemas,
-    );
-    return res.reduce((o, row) => {
-      let name = row.enum_name;
-      if (row.schema_name && row.schema_name !== this.platform.getDefaultSchemaName()) {
-        name = row.schema_name + '.' + name;
-      }
-      let items = row.enum_value;
-      if (!Array.isArray(items)) {
-        items = this.platform.unmarshallArray(row.enum_value);
-      }
-      o[name] = {
-        name: row.enum_name,
-        schema: row.schema_name,
-        items,
-      };
-      return o;
-    }, {});
-  }
-  getCreateNativeEnumSQL(name, values, schema) {
-    if (schema && schema !== this.platform.getDefaultSchemaName()) {
-      name = schema + '.' + name;
-    }
-    return `create type ${this.quote(name)} as enum (${values.map(value => this.platform.quoteValue(value)).join(', ')})`;
-  }
-  getDropNativeEnumSQL(name, schema) {
-    if (schema && schema !== this.platform.getDefaultSchemaName()) {
-      name = schema + '.' + name;
-    }
-    return `drop type ${this.quote(name)}`;
-  }
-  getAlterNativeEnumSQL(name, schema, value, items, oldItems) {
-    if (schema && schema !== this.platform.getDefaultSchemaName()) {
-      name = schema + '.' + name;
-    }
-    let suffix = '';
-    if (items && value && oldItems) {
-      const position = items.indexOf(value);
-      if (position > 0) {
-        suffix = ` after ${this.platform.quoteValue(items[position - 1])}`;
-      } else if (items.length > 1 && oldItems.length > 0) {
-        suffix = ` before ${this.platform.quoteValue(oldItems[0])}`;
-      }
-    }
-    return `alter type ${this.quote(name)} add value if not exists ${this.platform.quoteValue(value)}${suffix}`;
-  }
-  getEnumDefinitions(checks) {
-    return checks.reduce((o, item) => {
-      // check constraints are defined as one of:
-      // `CHECK ((type = ANY (ARRAY['local'::text, 'global'::text])))`
-      // `CHECK (("columnName" = ANY (ARRAY['local'::text, 'global'::text])))`
-      // `CHECK (((enum_test)::text = ANY ((ARRAY['a'::character varying, 'b'::character varying, 'c'::character varying])::text[])))`
-      // `CHECK ((("enumTest")::text = ANY ((ARRAY['a'::character varying, 'b'::character varying, 'c'::character varying])::text[])))`
-      // `CHECK ((type = 'a'::text))`
-      const m1 =
-        item.definition?.match(/check \(\(\("?(\w+)"?\)::/i) || item.definition?.match(/check \(\("?(\w+)"? = /i);
-      const m2 = item.definition?.match(/\(array\[(.*)]\)/i) || item.definition?.match(/ = (.*)\)/i);
-      if (item.columnName && m1 && m2) {
-        const m3 = m2[1].match(/('[^']*'::text)/g);
-        let items;
+        group by t.typname, n.nspname`, uniqueSchemas);
+        return res.reduce((o, row) => {
+            let name = row.enum_name;
+            if (row.schema_name && row.schema_name !== this.platform.getDefaultSchemaName()) {
+                name = row.schema_name + '.' + name;
+            }
+            let items = row.enum_value;
+            if (!Array.isArray(items)) {
+                items = this.platform.unmarshallArray(row.enum_value);
+            }
+            o[name] = {
+                name: row.enum_name,
+                schema: row.schema_name,
+                items,
+            };
+            return o;
+        }, {});
+    }
+    getCreateNativeEnumSQL(name, values, schema) {
+        if (schema && schema !== this.platform.getDefaultSchemaName()) {
+            name = schema + '.' + name;
+        }
+        return `create type ${this.quote(name)} as enum (${values.map(value => this.platform.quoteValue(value)).join(', ')})`;
+    }
+    getDropNativeEnumSQL(name, schema) {
+        if (schema && schema !== this.platform.getDefaultSchemaName()) {
+            name = schema + '.' + name;
+        }
+        return `drop type ${this.quote(name)}`;
+    }
+    getAlterNativeEnumSQL(name, schema, value, items, oldItems) {
+        if (schema && schema !== this.platform.getDefaultSchemaName()) {
+            name = schema + '.' + name;
+        }
+        let suffix = '';
+        if (items && value && oldItems) {
+            const position = items.indexOf(value);
+            if (position > 0) {
+                suffix = ` after ${this.platform.quoteValue(items[position - 1])}`;
+            }
+            else if (items.length > 1 && oldItems.length > 0) {
+                suffix = ` before ${this.platform.quoteValue(oldItems[0])}`;
+            }
+        }
+        return `alter type ${this.quote(name)} add value if not exists ${this.platform.quoteValue(value)}${suffix}`;
+    }
+    getEnumDefinitions(checks) {
+        return checks.reduce((o, item) => {
+            // check constraints are defined as one of:
+            // `CHECK ((type = ANY (ARRAY['local'::text, 'global'::text])))`
+            // `CHECK (("columnName" = ANY (ARRAY['local'::text, 'global'::text])))`
+            // `CHECK (((enum_test)::text = ANY ((ARRAY['a'::character varying, 'b'::character varying, 'c'::character varying])::text[])))`
+            // `CHECK ((("enumTest")::text = ANY ((ARRAY['a'::character varying, 'b'::character varying, 'c'::character varying])::text[])))`
+            // `CHECK ((type = 'a'::text))`
+            const m1 = item.definition?.match(/check \(\(\("?(\w+)"?\)::/i) || item.definition?.match(/check \(\("?(\w+)"? = /i);
+            const m2 = item.definition?.match(/\(array\[(.*)]\)/i) || item.definition?.match(/ = (.*)\)/i);
+            if (item.columnName && m1 && m2) {
+                const m3 = m2[1].match(/('[^']*'::text)/g);
+                let items;
+                /* v8 ignore next */
+                if (m3) {
+                    items = m3.map((item) => /^\(?'(.*)'/.exec(item.trim())?.[1]);
+                }
+                else {
+                    items = m2[1].split(',').map((item) => /^\(?'(.*)'/.exec(item.trim())?.[1]);
+                }
+                items = items.filter(item => item !== undefined);
+                if (items.length > 0) {
+                    o[item.columnName] = items;
+                    item.expression = `${this.quote(item.columnName)} in ('${items.join("', '")}')`;
+                    item.definition = `check (${item.expression})`;
+                }
+            }
+            return o;
+        }, {});
+    }
+    createTableColumn(column, table) {
+        const pk = table.getPrimaryKey();
+        const compositePK = pk?.composite;
+        const primaryKey = !this.hasNonDefaultPrimaryKeyName(table);
+        const col = [this.quote(column.name)];
+        if (column.autoincrement && !column.generated && !compositePK) {
+            col.push(column.mappedType.getColumnType({ autoincrement: true }, this.platform));
+        }
+        else {
+            let columnType = column.type;
+            if (column.nativeEnumName) {
+                const parts = column.type.split('.');
+                if (parts.length === 2 && parts[0] === '*') {
+                    columnType = `${table.schema}.${parts[1]}`;
+                }
+                if (columnType.endsWith('[]')) {
+                    columnType = this.quote(columnType.substring(0, columnType.length - 2)) + '[]';
+                }
+                else {
+                    columnType = this.quote(columnType);
+                }
+            }
+            if (column.generated === 'by default as identity') {
+                columnType += ` generated ${column.generated}`;
+            }
+            else if (column.generated) {
+                columnType += ` generated always as ${column.generated}`;
+            }
+            col.push(columnType);
+            Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
+            Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable);
+        }
+        if (column.autoincrement && !compositePK) {
+            Utils.runIfNotEmpty(() => col.push('primary key'), primaryKey && column.primary);
+        }
+        const useDefault = column.default != null && column.default !== 'null' && !column.autoincrement;
+        Utils.runIfNotEmpty(() => col.push(`default ${column.default}`), useDefault);
+        return col.join(' ');
+    }
+    getPreAlterTable(tableDiff, safe) {
+        const ret = [];
+        const parts = tableDiff.name.split('.');
+        const tableName = parts.pop();
+        const schemaName = parts.pop();
         /* v8 ignore next */
-        if (m3) {
-          items = m3.map(item => /^\(?'(.*)'/.exec(item.trim())?.[1]);
-        } else {
-          items = m2[1].split(',').map(item => /^\(?'(.*)'/.exec(item.trim())?.[1]);
-        }
-        items = items.filter(item => item !== undefined);
-        if (items.length > 0) {
-          o[item.columnName] = items;
-          item.expression = `${this.quote(item.columnName)} in ('${items.join("', '")}')`;
-          item.definition = `check (${item.expression})`;
-        }
-      }
-      return o;
-    }, {});
-  }
-  createTableColumn(column, table) {
-    const pk = table.getPrimaryKey();
-    const compositePK = pk?.composite;
-    const primaryKey = !this.hasNonDefaultPrimaryKeyName(table);
-    const col = [this.quote(column.name)];
-    if (column.autoincrement && !column.generated && !compositePK) {
-      col.push(column.mappedType.getColumnType({ autoincrement: true }, this.platform));
-    } else {
-      let columnType = column.type;
-      if (column.nativeEnumName) {
-        const parts = column.type.split('.');
-        if (parts.length === 2 && parts[0] === '*') {
-          columnType = `${table.schema}.${parts[1]}`;
-        }
-        if (columnType.endsWith('[]')) {
-          columnType = this.quote(columnType.substring(0, columnType.length - 2)) + '[]';
-        } else {
-          columnType = this.quote(columnType);
-        }
-      }
-      if (column.generated === 'by default as identity') {
-        columnType += ` generated ${column.generated}`;
-      } else if (column.generated) {
-        columnType += ` generated always as ${column.generated}`;
-      }
-      col.push(columnType);
-      Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
-      Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable);
-    }
-    if (column.autoincrement && !compositePK) {
-      Utils.runIfNotEmpty(() => col.push('primary key'), primaryKey && column.primary);
-    }
-    const useDefault = column.default != null && column.default !== 'null' && !column.autoincrement;
-    Utils.runIfNotEmpty(() => col.push(`default ${column.default}`), useDefault);
-    return col.join(' ');
-  }
-  getPreAlterTable(tableDiff, safe) {
-    const ret = [];
-    const parts = tableDiff.name.split('.');
-    const tableName = parts.pop();
-    const schemaName = parts.pop();
-    /* v8 ignore next */
-    const name =
-      (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
-    const quotedName = this.quote(name);
-    // detect that the column was an enum before and remove the check constraint in such case here
-    const changedEnums = Object.values(tableDiff.changedColumns).filter(
-      col => col.fromColumn.mappedType instanceof EnumType,
-    );
-    for (const col of changedEnums) {
-      if (!col.fromColumn.nativeEnumName && col.column.nativeEnumName && col.fromColumn.default) {
-        ret.push(`alter table ${quotedName} alter column "${col.column.name}" drop default`);
-      }
-      if (col.fromColumn.nativeEnumName && !col.column.nativeEnumName && col.fromColumn.default) {
-        ret.push(`alter table ${quotedName} alter column "${col.column.name}" drop default`);
-      }
-    }
-    // changing uuid column type requires to cast it to text first
-    const uuids = Object.values(tableDiff.changedColumns).filter(
-      col => col.changedProperties.has('type') && col.fromColumn.type === 'uuid',
-    );
-    for (const col of uuids) {
-      ret.push(
-        `alter table ${quotedName} alter column "${col.column.name}" type text using ("${col.column.name}"::text)`,
-      );
-    }
-    for (const { column } of Object.values(tableDiff.changedColumns).filter(diff =>
-      diff.changedProperties.has('autoincrement'),
-    )) {
-      if (!column.autoincrement && column.default == null) {
-        ret.push(`alter table ${quotedName} alter column ${this.quote(column.name)} drop default`);
-      }
-    }
-    return ret;
-  }
-  castColumn(name, type) {
-    if (type === 'uuid') {
-      type = 'text::uuid';
-    }
-    return ` using (${this.quote(name)}::${type})`;
-  }
-  dropForeignKey(tableName, constraintName) {
-    return `alter table ${this.quote(tableName)} drop constraint ${this.quote(constraintName)}`;
-  }
-  getPostAlterTable(tableDiff, safe) {
-    const ret = [];
-    const parts = tableDiff.name.split('.');
-    const tableName = parts.pop();
-    const schemaName = parts.pop();
-    /* v8 ignore next */
-    const name =
-      (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
-    const quotedName = this.quote(name);
-    // detect that the column was an enum before and remove the check constraint in such a case here
-    const changedEnums = Object.values(tableDiff.changedColumns).filter(
-      col => col.fromColumn.mappedType instanceof EnumType,
-    );
-    for (const col of changedEnums) {
-      if (!col.fromColumn.nativeEnumName && col.column.nativeEnumName && col.column.default) {
-        ret.push(`alter table ${quotedName} alter column "${col.column.name}" set default ${col.column.default}`);
-      }
-      if (col.fromColumn.nativeEnumName && !col.column.nativeEnumName && col.column.default) {
-        ret.push(`alter table ${quotedName} alter column "${col.column.name}" set default ${col.column.default}`);
-      }
-    }
-    for (const { column } of Object.values(tableDiff.changedColumns).filter(diff =>
-      diff.changedProperties.has('autoincrement'),
-    )) {
-      ret.push(...this.getAlterColumnAutoincrement(tableName, column, schemaName));
-    }
-    return ret;
-  }
-  getAlterColumnAutoincrement(tableName, column, schemaName) {
-    const ret = [];
-    /* v8 ignore next */
-    const name =
-      (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
-    if (column.autoincrement) {
-      const seqName = this.platform.getIndexName(tableName, [column.name], 'sequence');
-      ret.push(`create sequence if not exists ${this.quote(seqName)}`);
-      ret.push(`select setval('${seqName}', (select max(${this.quote(column.name)}) from ${this.quote(name)}))`);
-      ret.push(
-        `alter table ${this.quote(name)} alter column ${this.quote(column.name)} set default nextval('${seqName}')`,
-      );
-    }
-    return ret;
-  }
-  getChangeColumnCommentSQL(tableName, to, schemaName) {
-    const name = this.quote(
-      (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName,
-    );
-    const value = to.comment ? this.platform.quoteValue(to.comment) : 'null';
-    return `comment on column ${name}.${this.quote(to.name)} is ${value}`;
-  }
-  alterTableComment(table, comment) {
-    return `comment on table ${table.getQuotedName()} is ${this.platform.quoteValue(comment ?? '')}`;
-  }
-  normalizeDefaultValue(defaultValue, length) {
-    if (!defaultValue || typeof defaultValue !== 'string') {
-      return super.normalizeDefaultValue(defaultValue, length, PostgreSqlSchemaHelper.DEFAULT_VALUES);
-    }
-    const match = /^'(.*)'::(.*)$/.exec(defaultValue);
-    if (match) {
-      if (match[2] === 'integer') {
-        return +match[1];
-      }
-      return `'${match[1]}'`;
-    }
-    return super.normalizeDefaultValue(defaultValue, length, PostgreSqlSchemaHelper.DEFAULT_VALUES);
-  }
-  appendComments(table) {
-    const sql = [];
-    if (table.comment) {
-      const comment = this.platform.quoteValue(this.processComment(table.comment));
-      sql.push(`comment on table ${table.getQuotedName()} is ${comment}`);
-    }
-    for (const column of table.getColumns()) {
-      if (column.comment) {
-        const comment = this.platform.quoteValue(this.processComment(column.comment));
-        sql.push(`comment on column ${table.getQuotedName()}.${this.quote(column.name)} is ${comment}`);
-      }
-    }
-    return sql;
-  }
-  getDatabaseExistsSQL(name) {
-    return `select 1 from pg_database where datname = '${name}'`;
-  }
-  getDatabaseNotExistsError(dbName) {
-    return `database ${this.quote(dbName)} does not exist`;
-  }
-  getManagementDbName() {
-    return this.platform.getConfig().get('schemaGenerator', {}).managementDbName ?? 'postgres';
-  }
-  disableForeignKeysSQL() {
-    return `set session_replication_role = 'replica';`;
-  }
-  enableForeignKeysSQL() {
-    return `set session_replication_role = 'origin';`;
-  }
-  getRenameIndexSQL(tableName, index, oldIndexName) {
-    oldIndexName = this.quote(oldIndexName);
-    const keyName = this.quote(index.keyName);
-    return [`alter index ${oldIndexName} rename to ${keyName}`];
-  }
-  dropIndex(table, index, oldIndexName = index.keyName) {
-    if (index.primary || (index.unique && index.constraint)) {
-      return `alter table ${this.quote(table)} drop constraint ${this.quote(oldIndexName)}`;
-    }
-    return `drop index ${this.quote(oldIndexName)}`;
-  }
-  /**
-   * Build the column list for a PostgreSQL index.
-   */
-  getIndexColumns(index) {
-    if (index.columns?.length) {
-      return index.columns
-        .map(col => {
-          let colDef = this.quote(col.name);
-          // PostgreSQL supports collation with double quotes
-          if (col.collation) {
-            colDef += ` collate ${this.quote(col.collation)}`;
-          }
-          // PostgreSQL supports sort order
-          if (col.sort) {
-            colDef += ` ${col.sort}`;
-          }
-          // PostgreSQL supports NULLS FIRST/LAST
-          if (col.nulls) {
-            colDef += ` nulls ${col.nulls}`;
-          }
-          return colDef;
-        })
-        .join(', ');
-    }
-    return index.columnNames.map(c => this.quote(c)).join(', ');
-  }
-  /**
-   * PostgreSQL-specific index options like fill factor.
-   */
-  getCreateIndexSuffix(index) {
-    const withOptions = [];
-    if (index.fillFactor != null) {
-      withOptions.push(`fillfactor = ${index.fillFactor}`);
-    }
-    if (withOptions.length > 0) {
-      return ` with (${withOptions.join(', ')})`;
-    }
-    return super.getCreateIndexSuffix(index);
-  }
-  getIndexesSQL(tables) {
-    return `select indrelid::regclass as table_name, ns.nspname as schema_name, relname as constraint_name, idx.indisunique as unique, idx.indisprimary as primary, contype, condeferrable, condeferred,
+        const name = (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
+        const quotedName = this.quote(name);
+        // detect that the column was an enum before and remove the check constraint in such case here
+        const changedEnums = Object.values(tableDiff.changedColumns).filter(col => col.fromColumn.mappedType instanceof EnumType);
+        for (const col of changedEnums) {
+            if (!col.fromColumn.nativeEnumName && col.column.nativeEnumName && col.fromColumn.default) {
+                ret.push(`alter table ${quotedName} alter column "${col.column.name}" drop default`);
+            }
+            if (col.fromColumn.nativeEnumName && !col.column.nativeEnumName && col.fromColumn.default) {
+                ret.push(`alter table ${quotedName} alter column "${col.column.name}" drop default`);
+            }
+        }
+        // changing uuid column type requires to cast it to text first
+        const uuids = Object.values(tableDiff.changedColumns).filter(col => col.changedProperties.has('type') && col.fromColumn.type === 'uuid');
+        for (const col of uuids) {
+            ret.push(`alter table ${quotedName} alter column "${col.column.name}" type text using ("${col.column.name}"::text)`);
+        }
+        for (const { column } of Object.values(tableDiff.changedColumns).filter(diff => diff.changedProperties.has('autoincrement'))) {
+            if (!column.autoincrement && column.default == null) {
+                ret.push(`alter table ${quotedName} alter column ${this.quote(column.name)} drop default`);
+            }
+        }
+        return ret;
+    }
+    castColumn(name, type) {
+        if (type === 'uuid') {
+            type = 'text::uuid';
+        }
+        return ` using (${this.quote(name)}::${type})`;
+    }
+    dropForeignKey(tableName, constraintName) {
+        return `alter table ${this.quote(tableName)} drop constraint ${this.quote(constraintName)}`;
+    }
+    getPostAlterTable(tableDiff, safe) {
+        const ret = [];
+        const parts = tableDiff.name.split('.');
+        const tableName = parts.pop();
+        const schemaName = parts.pop();
+        /* v8 ignore next */
+        const name = (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
+        const quotedName = this.quote(name);
+        // detect that the column was an enum before and remove the check constraint in such a case here
+        const changedEnums = Object.values(tableDiff.changedColumns).filter(col => col.fromColumn.mappedType instanceof EnumType);
+        for (const col of changedEnums) {
+            if (!col.fromColumn.nativeEnumName && col.column.nativeEnumName && col.column.default) {
+                ret.push(`alter table ${quotedName} alter column "${col.column.name}" set default ${col.column.default}`);
+            }
+            if (col.fromColumn.nativeEnumName && !col.column.nativeEnumName && col.column.default) {
+                ret.push(`alter table ${quotedName} alter column "${col.column.name}" set default ${col.column.default}`);
+            }
+        }
+        for (const { column } of Object.values(tableDiff.changedColumns).filter(diff => diff.changedProperties.has('autoincrement'))) {
+            ret.push(...this.getAlterColumnAutoincrement(tableName, column, schemaName));
+        }
+        return ret;
+    }
+    getAlterColumnAutoincrement(tableName, column, schemaName) {
+        const ret = [];
+        /* v8 ignore next */
+        const name = (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
+        if (column.autoincrement) {
+            const seqName = this.platform.getIndexName(tableName, [column.name], 'sequence');
+            ret.push(`create sequence if not exists ${this.quote(seqName)}`);
+            ret.push(`select setval('${seqName}', (select max(${this.quote(column.name)}) from ${this.quote(name)}))`);
+            ret.push(`alter table ${this.quote(name)} alter column ${this.quote(column.name)} set default nextval('${seqName}')`);
+        }
+        return ret;
+    }
+    getChangeColumnCommentSQL(tableName, to, schemaName) {
+        const name = this.quote((schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName);
+        const value = to.comment ? this.platform.quoteValue(to.comment) : 'null';
+        return `comment on column ${name}.${this.quote(to.name)} is ${value}`;
+    }
+    alterTableComment(table, comment) {
+        return `comment on table ${table.getQuotedName()} is ${this.platform.quoteValue(comment ?? '')}`;
+    }
+    normalizeDefaultValue(defaultValue, length) {
+        if (!defaultValue || typeof defaultValue !== 'string') {
+            return super.normalizeDefaultValue(defaultValue, length, PostgreSqlSchemaHelper.DEFAULT_VALUES);
+        }
+        const match = /^'(.*)'::(.*)$/.exec(defaultValue);
+        if (match) {
+            if (match[2] === 'integer') {
+                return +match[1];
+            }
+            return `'${match[1]}'`;
+        }
+        return super.normalizeDefaultValue(defaultValue, length, PostgreSqlSchemaHelper.DEFAULT_VALUES);
+    }
+    appendComments(table) {
+        const sql = [];
+        if (table.comment) {
+            const comment = this.platform.quoteValue(this.processComment(table.comment));
+            sql.push(`comment on table ${table.getQuotedName()} is ${comment}`);
+        }
+        for (const column of table.getColumns()) {
+            if (column.comment) {
+                const comment = this.platform.quoteValue(this.processComment(column.comment));
+                sql.push(`comment on column ${table.getQuotedName()}.${this.quote(column.name)} is ${comment}`);
+            }
+        }
+        return sql;
+    }
+    getDatabaseExistsSQL(name) {
+        return `select 1 from pg_database where datname = '${name}'`;
+    }
+    getDatabaseNotExistsError(dbName) {
+        return `database ${this.quote(dbName)} does not exist`;
+    }
+    getManagementDbName() {
+        return this.platform.getConfig().get('schemaGenerator', {}).managementDbName ?? 'postgres';
+    }
+    disableForeignKeysSQL() {
+        return `set session_replication_role = 'replica';`;
+    }
+    enableForeignKeysSQL() {
+        return `set session_replication_role = 'origin';`;
+    }
+    getRenameIndexSQL(tableName, index, oldIndexName) {
+        oldIndexName = this.quote(oldIndexName);
+        const keyName = this.quote(index.keyName);
+        return [`alter index ${oldIndexName} rename to ${keyName}`];
+    }
+    dropIndex(table, index, oldIndexName = index.keyName) {
+        if (index.primary || (index.unique && index.constraint)) {
+            return `alter table ${this.quote(table)} drop constraint ${this.quote(oldIndexName)}`;
+        }
+        return `drop index ${this.quote(oldIndexName)}`;
+    }
+    /**
+     * Build the column list for a PostgreSQL index.
+     */
+    getIndexColumns(index) {
+        if (index.columns?.length) {
+            return index.columns
+                .map(col => {
+                let colDef = this.quote(col.name);
+                // PostgreSQL supports collation with double quotes
+                if (col.collation) {
+                    colDef += ` collate ${this.quote(col.collation)}`;
+                }
+                // PostgreSQL supports sort order
+                if (col.sort) {
+                    colDef += ` ${col.sort}`;
+                }
+                // PostgreSQL supports NULLS FIRST/LAST
+                if (col.nulls) {
+                    colDef += ` nulls ${col.nulls}`;
+                }
+                return colDef;
+            })
+                .join(', ');
+        }
+        return index.columnNames.map(c => this.quote(c)).join(', ');
+    }
+    /**
+     * PostgreSQL-specific index options like fill factor.
+     */
+    getCreateIndexSuffix(index) {
+        const withOptions = [];
+        if (index.fillFactor != null) {
+            withOptions.push(`fillfactor = ${index.fillFactor}`);
+        }
+        if (withOptions.length > 0) {
+            return ` with (${withOptions.join(', ')})`;
+        }
+        return super.getCreateIndexSuffix(index);
+    }
+    getIndexesSQL(tables) {
+        return `select indrelid::regclass as table_name, ns.nspname as schema_name, relname as constraint_name, idx.indisunique as unique, idx.indisprimary as primary, contype, condeferrable, condeferred,
       array(
         select pg_get_indexdef(idx.indexrelid, k + 1, true)
         from generate_subscripts(idx.indkey, 1) as k
@@ -762,37 +734,37 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       left join pg_constraint as c on c.conname = i.relname
       where indrelid in (${tables.map(t => `${this.platform.quoteValue(`${this.quote(t.schema_name)}.${this.quote(t.table_name)}`)}::regclass`).join(', ')})
       order by relname`;
-  }
-  getChecksSQL(tablesBySchemas) {
-    return `select ccu.table_name as table_name, ccu.table_schema as schema_name, pgc.conname as name, conrelid::regclass as table_from, ccu.column_name as column_name, pg_get_constraintdef(pgc.oid) as expression
+    }
+    getChecksSQL(tablesBySchemas) {
+        return `select ccu.table_name as table_name, ccu.table_schema as schema_name, pgc.conname as name, conrelid::regclass as table_from, ccu.column_name as column_name, pg_get_constraintdef(pgc.oid) as expression
       from pg_constraint pgc
       join pg_namespace nsp on nsp.oid = pgc.connamespace
       join pg_class cls on pgc.conrelid = cls.oid
       join information_schema.constraint_column_usage ccu on pgc.conname = ccu.constraint_name and nsp.nspname = ccu.constraint_schema and cls.relname = ccu.table_name
       where contype = 'c' and (${[...tablesBySchemas.entries()].map(([schema, tables]) => `ccu.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}) and ccu.table_schema = ${this.platform.quoteValue(schema)}`).join(' or ')})
       order by pgc.conname`;
-  }
-  inferLengthFromColumnType(type) {
-    const match = /^(\w+(?:\s+\w+)*)\s*(?:\(\s*(\d+)\s*\)|$)/.exec(type);
-    if (!match) {
-      return;
-    }
-    if (!match[2]) {
-      switch (match[1]) {
-        case 'character varying':
-        case 'varchar':
-        case 'bpchar':
-        case 'char':
-        case 'character':
-          return -1;
-        case 'interval':
-        case 'time':
-        case 'timestamp':
-        case 'timestamptz':
-          return this.platform.getDefaultDateTimeLength();
-      }
-      return;
-    }
-    return +match[2];
-  }
+    }
+    inferLengthFromColumnType(type) {
+        const match = /^(\w+(?:\s+\w+)*)\s*(?:\(\s*(\d+)\s*\)|$)/.exec(type);
+        if (!match) {
+            return;
+        }
+        if (!match[2]) {
+            switch (match[1]) {
+                case 'character varying':
+                case 'varchar':
+                case 'bpchar':
+                case 'char':
+                case 'character':
+                    return -1;
+                case 'interval':
+                case 'time':
+                case 'timestamp':
+                case 'timestamptz':
+                    return this.platform.getDefaultDateTimeLength();
+            }
+            return;
+        }
+        return +match[2];
+    }
 }