@mikro-orm/sql 7.0.2-dev.8 → 7.0.2

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -1,250 +1,256 @@
-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,
@@ -263,89 +269,93 @@ 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,
-            };
-            if (nativeEnums?.[column.type]) {
-                column.mappedType = Type.getType(EnumType);
-                column.nativeEnumName = column.type;
-                column.enumItems = nativeEnums[column.type]?.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,
+      };
+      if (nativeEnums?.[column.type]) {
+        column.mappedType = Type.getType(EnumType);
+        column.nativeEnumName = column.type;
+        column.enumItems = nativeEnums[column.type]?.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
@@ -359,342 +369,360 @@ 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;
-                /* 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();
+        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 */
-        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,
+        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,
       array(
         select pg_get_indexdef(idx.indexrelid, k + 1, true)
         from generate_subscripts(idx.indkey, 1) as k
@@ -712,37 +740,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];
+  }
 }