pg-migration-engine 0.1.0

package/src/ddl-generator/drop-generator.js

@@ -0,0 +1,194 @@
+/**
+ * Generate DROP DDL for any object type.
+ */
+
+export function generateDropSql(change) {
+  const obj = change.before;
+  const objectKey = change.objectKey;
+  const objectType = change.objectType;
+  const changeType = change.changeType;
+
+  switch (objectType) {
+    case 'schema':
+      return `DROP SCHEMA IF EXISTS ${ident(obj?.name || objectKey)} CASCADE;`;
+
+    case 'table':
+      return `DROP TABLE IF EXISTS ${objectKey} CASCADE;`;
+
+    case 'view':
+      return `DROP VIEW IF EXISTS ${objectKey} CASCADE;`;
+
+    case 'materializedView':
+      return `DROP MATERIALIZED VIEW IF EXISTS ${objectKey} CASCADE;`;
+
+    case 'function':
+      const fnArgs = obj?.argumentTypes ? `(${obj.argumentTypes.join(', ')})` : '';
+      return `DROP FUNCTION IF EXISTS ${objectKey}${fnArgs} CASCADE;`;
+
+    case 'procedure':
+      const procArgs = obj?.argumentTypes ? `(${obj.argumentTypes.join(', ')})` : '';
+      return `DROP PROCEDURE IF EXISTS ${objectKey}${procArgs} CASCADE;`;
+
+    case 'trigger':
+      const trigTable = obj?.tableName || objectKey.split('.').slice(0, -1).join('.');
+      const trigName = obj?.name || objectKey.split('.').pop();
+      return `DROP TRIGGER IF EXISTS ${ident(trigName)} ON ${trigTable};`;
+
+    case 'index':
+      if (changeType === 'DROP_INDEX_CONCURRENTLY' || obj?.isConcurrent) {
+        return `DROP INDEX CONCURRENTLY IF EXISTS ${objectKey};`;
+      }
+      return `DROP INDEX IF EXISTS ${objectKey};`;
+
+    case 'constraint':
+      const conTable = obj?._tableKey || obj?.tableKey || objectKey.split('.').slice(0, -1).join('.');
+      const conName = obj?.name || objectKey.split('.').pop();
+      return `ALTER TABLE ${conTable} DROP CONSTRAINT IF EXISTS ${ident(conName)};`;
+
+    case 'policy':
+      const polTable = obj?.table || objectKey.split('.').slice(0, -1).join('.');
+      const polName = obj?.name || objectKey.split('.').pop();
+      return `DROP POLICY IF EXISTS ${ident(polName)} ON ${polTable};`;
+
+    case 'sequence':
+      return `DROP SEQUENCE IF EXISTS ${objectKey} CASCADE;`;
+
+    case 'extension':
+      return `DROP EXTENSION IF EXISTS ${ident(obj?.name || objectKey)} CASCADE;`;
+
+    case 'type':
+      return `DROP TYPE IF EXISTS ${objectKey} CASCADE;`;
+
+    case 'domain':
+      return `DROP DOMAIN IF EXISTS ${objectKey} CASCADE;`;
+
+    case 'rule':
+      const ruleTable = obj?.tableName || objectKey.split('.').slice(0, -1).join('.');
+      const ruleName = obj?.name || objectKey.split('.').pop();
+      return `DROP RULE IF EXISTS ${ident(ruleName)} ON ${ruleTable};`;
+
+    case 'aggregate':
+      const aggArgs = obj?.argumentTypes ? `(${obj.argumentTypes.join(', ')})` : '()';
+      return `DROP AGGREGATE IF EXISTS ${objectKey}${aggArgs} CASCADE;`;
+
+    case 'eventTrigger':
+      return `DROP EVENT TRIGGER IF EXISTS ${ident(obj?.name || objectKey)};`;
+
+    case 'foreignTable':
+      return `DROP FOREIGN TABLE IF EXISTS ${objectKey} CASCADE;`;
+
+    case 'foreignServer':
+      return `DROP SERVER IF EXISTS ${ident(obj?.name || objectKey)} CASCADE;`;
+
+    case 'foreignDataWrapper':
+      return `DROP FOREIGN DATA WRAPPER IF EXISTS ${ident(obj?.name || objectKey)} CASCADE;`;
+
+    case 'userMapping':
+      return `DROP USER MAPPING IF EXISTS FOR ${ident(obj?.user || 'PUBLIC')} SERVER ${ident(obj?.server || 'FOREIGN')};`;
+
+    case 'cast':
+      return `DROP CAST IF EXISTS (${obj?.sourceType || 'type'} AS ${obj?.targetType || 'type'});`;
+
+    case 'operator':
+      const opLeft = obj?.leftType || 'NONE';
+      const opRight = obj?.rightType || 'NONE';
+      return `DROP OPERATOR IF EXISTS ${objectKey} (${opLeft}, ${opRight}) CASCADE;`;
+
+    case 'operatorClass':
+      return `DROP OPERATOR CLASS IF EXISTS ${objectKey} USING ${obj?.accessMethod || 'btree'} CASCADE;`;
+
+    case 'operatorFamily':
+      return `DROP OPERATOR FAMILY IF EXISTS ${objectKey} USING ${obj?.accessMethod || 'btree'} CASCADE;`;
+
+    case 'textSearchConfig':
+      return `DROP TEXT SEARCH CONFIGURATION IF EXISTS ${objectKey} CASCADE;`;
+
+    case 'textSearchDict':
+      return `DROP TEXT SEARCH DICTIONARY IF EXISTS ${objectKey} CASCADE;`;
+
+    case 'textSearchParser':
+      return `DROP TEXT SEARCH PARSER IF EXISTS ${objectKey} CASCADE;`;
+
+    case 'textSearchTemplate':
+      return `DROP TEXT SEARCH TEMPLATE IF EXISTS ${objectKey} CASCADE;`;
+
+    case 'statistics':
+      return `DROP STATISTICS IF EXISTS ${objectKey};`;
+
+    case 'publication':
+      return `DROP PUBLICATION IF EXISTS ${ident(obj?.name || objectKey)};`;
+
+    case 'subscription':
+      return `DROP SUBSCRIPTION IF EXISTS ${ident(obj?.name || objectKey)};`;
+
+    case 'language':
+      return `DROP LANGUAGE IF EXISTS ${ident(obj?.name || objectKey)} CASCADE;`;
+
+    case 'collation':
+      return `DROP COLLATION IF EXISTS ${objectKey} CASCADE;`;
+
+    case 'conversion':
+      return `DROP CONVERSION IF EXISTS ${objectKey} CASCADE;`;
+
+    case 'column':
+      const colTable = objectKey.split('.').slice(0, -1).join('.');
+      const colName = objectKey.split('.').pop();
+      return `ALTER TABLE ${colTable} DROP COLUMN IF EXISTS ${ident(colName)};`;
+
+    case 'database':
+      return `-- DROP DATABASE must be run outside transaction: DROP DATABASE IF EXISTS ${ident(obj?.name || objectKey)};`;
+
+    case 'tablespace':
+      return `DROP TABLESPACE IF EXISTS ${ident(obj?.name || objectKey)};`;
+
+    case 'role':
+      return `DROP ROLE IF EXISTS ${ident(obj?.name || objectKey)};`;
+
+    case 'defaultPrivileges':
+      const dpSchema = obj?.schema;
+      const dpForRole = obj?.forRole;
+      return `ALTER DEFAULT PRIVILEGES${dpSchema ? ` IN SCHEMA ${ident(dpSchema)}` : ''}${dpForRole ? ` FOR ROLE ${ident(dpForRole)}` : ''} REVOKE ALL ON ALL FROM PUBLIC;`;
+
+    case 'conversion':
+      return `DROP CONVERSION IF EXISTS ${objectKey};`;
+
+    case 'accessMethod':
+      return `DROP ACCESS METHOD IF EXISTS ${ident(obj?.name || objectKey)};`;
+
+    default:
+      if (objectType.startsWith('RECREATE')) {
+        return generateRecreateSql(change);
+      }
+      return `-- Unsupported DROP for ${objectType}`;
+  }
+}
+
+function generateRecreateSql(change) {
+  const dropSql = generateDropSql({
+    ...change,
+    changeType: 'DROP',
+    before: change.before
+  });
+  
+  const createChange = {
+    ...change,
+    changeType: 'CREATE',
+    after: change.before,
+  };
+
+  switch (change.objectType) {
+    case 'materializedView':
+      return dropSql;
+    default:
+      return dropSql;
+  }
+}
+
+function ident(name) {
+  if (!name) return '';
+  if (typeof name !== 'string') name = String(name);
+  if (name.includes('"') || name.includes(' ')) {
+    return `"${name.replace(/"/g, '""')}"`;
+  }
+  return `"${name}"`;
+}

package/src/ddl-generator/generator.js

@@ -0,0 +1,78 @@
+import { generateCreateSql } from './create-generator.js';
+import { generateAlterSql } from './alter-generator.js';
+import { generateDropSql } from './drop-generator.js';
+import { generateRenameSql } from './rename-generator.js';
+import { generateCommentSql } from './comment-generator.js';
+import { generateGrantSql } from './grant-generator.js';
+import { generateSafePatterns } from './safe-patterns.js';
+
+export class DdlGenerator {
+  /**
+   * @param {import('../types/changes.js').SchemaChange[]} changes
+   * @param {import('../types/execution.js').DdlOptions} [options]
+   * @returns {string}
+   */
+  generate(changes, options = {}) {
+    const { safeMode = false } = options;
+    const statements = [];
+
+    for (const change of changes) {
+      if (safeMode) {
+        const safeSteps = generateSafePatterns(change);
+        if (safeSteps) {
+          for (const step of safeSteps) {
+            statements.push(`-- ${step.description}`);
+            statements.push(step.sql);
+          }
+          continue;
+        }
+      }
+
+      let sql = '';
+      const changeType = change.changeType;
+      const objectType = change.objectType;
+
+      if (change.sql) {
+        sql = change.sql;
+      } else if (change.requiresRecreation || changeType === 'PARTITION_STRUCTURE_CHANGE') {
+        const beforeObj = change.before || change.currentValue;
+        const afterObj = change.after || change.desiredValue;
+        
+        const dropSql = generateDropSql({
+          changeType: 'DROP',
+          objectType: change.objectType,
+          objectKey: change.objectKey,
+          before: beforeObj
+        });
+        
+        const createSql = generateCreateSql({
+          changeType: 'CREATE',
+          objectType: change.objectType,
+          objectKey: change.objectKey,
+          after: afterObj
+        });
+        
+        sql = `${dropSql}\n${createSql}`;
+      } else if (changeType === 'CREATE' || changeType.startsWith('ADD')) {
+        sql = generateCreateSql(change);
+      } else if (changeType === 'ALTER' || changeType.includes('CHANGE') || changeType.includes('CAST')) {
+        sql = generateAlterSql(change);
+      } else if (changeType === 'DROP' || changeType.startsWith('REMOVE') || changeType.includes('RECREATE')) {
+        sql = generateDropSql(change);
+      } else if (changeType === 'RENAME') {
+        sql = generateRenameSql(change);
+      } else if (changeType === 'COMMENT') {
+        sql = generateCommentSql(change);
+      } else if (changeType === 'GRANT' || changeType === 'REVOKE') {
+        sql = generateGrantSql(change);
+      }
+
+      if (sql && !sql.startsWith('--')) {
+        statements.push(`-- ${changeType} ${objectType} ${change.objectKey}`);
+        statements.push(sql);
+      }
+    }
+
+    return statements.join('\n');
+  }
+}

package/src/ddl-generator/grant-generator.js

@@ -0,0 +1,31 @@
+function ident(name) {
+  if (!name) return '';
+  if (name.includes('"') || name.includes(' ')) {
+    return `"${name.replace(/"/g, '""')}"`;
+  }
+  return `"${name}"`;
+}
+
+/**
+ * @param {import('../types/changes.js').SchemaChange} change
+ * @returns {string}
+ */
+export function generateGrantSql(change) {
+  const type = change.changeType || change.type;
+  if (type === 'GRANT') {
+    const g = change.after || {};
+    const grantee = g.grantee || 'PUBLIC';
+    const granteeRef = grantee.toUpperCase() === 'PUBLIC' ? 'PUBLIC' : ident(grantee);
+    let sql = `GRANT ${g.privilege || 'ALL'} ON ${g.objectType || 'TABLE'} ${ident(g.schema)}.${ident(g.object)} TO ${granteeRef}`;
+    if (g.isGrantable || g.withGrantOption) sql += ' WITH GRANT OPTION';
+    return sql + ';';
+  }
+  if (type === 'REVOKE') {
+    const g = change.before || {};
+    const grantee = g.grantee || 'PUBLIC';
+    const granteeRef = grantee.toUpperCase() === 'PUBLIC' ? 'PUBLIC' : ident(grantee);
+    let sql = `REVOKE ${g.privilege || 'ALL'} ON ${g.objectType || 'TABLE'} ${ident(g.schema)}.${ident(g.object)} FROM ${granteeRef}`;
+    return sql + ';';
+  }
+  return '';
+}

package/src/ddl-generator/index.js

@@ -0,0 +1,3 @@
+export { DdlGenerator } from './generator.js';
+export { generateSafePatterns } from './safe-patterns.js';
+export { supportsPg18Features, supportsPg15Features } from './pg-version.js';

package/src/ddl-generator/pg-version.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number} [pgVersion]
+ * @returns {boolean}
+ */
+export function supportsPg18Features(pgVersion) {
+  return (pgVersion || 15) >= 180000;
+}
+
+/**
+ * @param {number} [pgVersion]
+ * @returns {boolean}
+ */
+export function supportsPg15Features(pgVersion) {
+  return (pgVersion || 15) >= 150000;
+}

package/src/ddl-generator/rename-generator.js

@@ -0,0 +1,88 @@
+/**
+ * @param {import('../types/changes.js').SchemaChange} change
+ * @returns {string}
+ */
+export function generateRenameSql(change) {
+  if (!change.isRename) return '';
+
+  const objType = (change.objectType || '').toLowerCase();
+  const schemaPrefix = change.schema ? `${ident(change.schema)}.` : '';
+
+  const getTableRef = () => {
+    const t = change.after?.table || change.before?.table || change.after?.tableName || change.before?.tableName;
+    if (!t) return '';
+    return t.includes('.') ? t.split('.').map(ident).join('.') : (change.schema ? `${ident(change.schema)}.${ident(t)}` : ident(t));
+  };
+
+  switch (objType) {
+    case 'table':
+      return `ALTER TABLE ${schemaPrefix}${ident(change.renameFrom)} RENAME TO ${ident(change.renameTo)};`;
+      
+    case 'column': {
+      const table = change.objectKey.split('.').slice(0, -1).join('.');
+      const formattedTable = table.split('.').map(ident).join('.');
+      return `ALTER TABLE ${formattedTable} RENAME COLUMN ${ident(change.renameFrom)} TO ${ident(change.renameTo)};`;
+    }
+    
+    case 'index':
+      return `ALTER INDEX ${schemaPrefix}${ident(change.renameFrom)} RENAME TO ${ident(change.renameTo)};`;
+      
+    case 'constraint': {
+      const constrTable = change.before?.table || change.after?.table || change.before?.tableName || change.after?.tableName;
+      const formattedConstrTable = constrTable.includes('.') ? constrTable.split('.').map(ident).join('.') : (change.schema ? `${ident(change.schema)}.${ident(constrTable)}` : ident(constrTable));
+      return `ALTER TABLE ${formattedConstrTable} RENAME CONSTRAINT ${ident(change.renameFrom)} TO ${ident(change.renameTo)};`;
+    }
+    
+    case 'type':
+      return `ALTER TYPE ${schemaPrefix}${ident(change.renameFrom)} RENAME TO ${ident(change.renameTo)};`;
+      
+    case 'function':
+    case 'procedure':
+      return `ALTER FUNCTION ${schemaPrefix}${ident(change.renameFrom)} RENAME TO ${ident(change.renameTo)};`;
+
+    case 'trigger':
+      return `ALTER TRIGGER ${ident(change.renameFrom)} ON ${getTableRef()} RENAME TO ${ident(change.renameTo)};`;
+
+    case 'schema':
+      return `ALTER SCHEMA ${ident(change.renameFrom)} RENAME TO ${ident(change.renameTo)};`;
+
+    case 'foreigntable':
+      return `ALTER FOREIGN TABLE ${schemaPrefix}${ident(change.renameFrom)} RENAME TO ${ident(change.renameTo)};`;
+
+    case 'foreignserver':
+      return `ALTER SERVER ${ident(change.renameFrom)} RENAME TO ${ident(change.renameTo)};`;
+
+    case 'conversion':
+      return `ALTER CONVERSION ${schemaPrefix}${ident(change.renameFrom)} RENAME TO ${ident(change.renameTo)};`;
+
+    case 'collation':
+      return `ALTER COLLATION ${schemaPrefix}${ident(change.renameFrom)} RENAME TO ${ident(change.renameTo)};`;
+
+    case 'textsearchconfig':
+      return `ALTER TEXT SEARCH CONFIGURATION ${schemaPrefix}${ident(change.renameFrom)} RENAME TO ${ident(change.renameTo)};`;
+
+    case 'textsearchdict':
+      return `ALTER TEXT SEARCH DICTIONARY ${schemaPrefix}${ident(change.renameFrom)} RENAME TO ${ident(change.renameTo)};`;
+
+    case 'language':
+      return `ALTER LANGUAGE ${ident(change.renameFrom)} RENAME TO ${ident(change.renameTo)};`;
+
+    case 'policy':
+      return `ALTER POLICY ${ident(change.renameFrom)} ON ${getTableRef()} RENAME TO ${ident(change.renameTo)};`;
+
+    case 'eventtrigger':
+      return `ALTER EVENT TRIGGER ${ident(change.renameFrom)} RENAME TO ${ident(change.renameTo)};`;
+
+    default:
+      return `-- Unsupported RENAME for ${change.objectType}`;
+  }
+}
+
+function ident(name) {
+  if (!name) return '';
+  if (typeof name !== 'string') name = String(name);
+  if (name.includes('"') || name.includes(' ')) {
+    return `"${name.replace(/"/g, '""')}"`;
+  }
+  return `"${name}"`;
+}

package/src/ddl-generator/safe-patterns.js

@@ -0,0 +1,241 @@
+/**
+ * Generate safe patterns for potentially destructive changes.
+ */
+
+const qi = name => name === '*' ? name : '"' + name.replace(/"/g, '""') + '"';
+
+export function generateSafePatterns(change) {
+  const steps = [];
+  const changeType = change.changeType;
+  const objectType = change.objectType;
+  const property = change.property;
+
+  // NOT NULL 3-step pattern
+  if (objectType === 'column' && property === 'isNullable' && change.currentValue === true && change.desiredValue === false) {
+    const parts = change.objectKey.split('.');
+    const col = parts.pop();
+    const table = parts.join('.');
+    const checkName = `${table.replace(/\./g, '_')}_${col}_not_null_chk`;
+    steps.push({
+      id: `step_${Date.now()}_1`,
+      type: 'constraint',
+      phase: 10,
+      description: `Add CHECK NOT NULL (NOT VALID) for ${table}.${col}`,
+      sql: `ALTER TABLE ${table} ADD CONSTRAINT ${checkName} CHECK (${col} IS NOT NULL) NOT VALID;`,
+      isTransactional: true,
+      riskLevel: 'low',
+      dependencies: [],
+    });
+    steps.push({
+      id: `step_${Date.now()}_2`,
+      type: 'constraint',
+      phase: 13,
+      description: `Validate CHECK constraint ${checkName}`,
+      sql: `ALTER TABLE ${table} VALIDATE CONSTRAINT ${checkName};`,
+      isTransactional: true,
+      riskLevel: 'low',
+      dependencies: [steps[0].id],
+    });
+    steps.push({
+      id: `step_${Date.now()}_3`,
+      type: 'structural',
+      phase: 11,
+      description: `Convert CHECK to NOT NULL for ${table}.${col}`,
+      sql: `ALTER TABLE ${table} ALTER COLUMN ${col} SET NOT NULL; ALTER TABLE ${table} DROP CONSTRAINT ${checkName};`,
+      isTransactional: true,
+      riskLevel: 'low',
+      dependencies: [steps[1].id],
+    });
+    return steps;
+  }
+
+  // FK NOT VALID pattern
+  if (objectType === 'constraint' && (change.after?.constraintType === 'FOREIGN_KEY' || change.after?.type === 'FOREIGN_KEY')) {
+    const con = change.after;
+    steps.push({
+      id: `step_${Date.now()}_1`,
+      type: 'constraint',
+      phase: 12,
+      description: `Add FK ${con.name} NOT VALID`,
+      sql: `ALTER TABLE ${con._tableKey || con.table} ADD CONSTRAINT ${con.name} FOREIGN KEY (${(con.columns || []).map(qi).join(', ')}) REFERENCES ${con.referencedTable}(${(con.referencedColumns || []).map(qi).join(', ')}) NOT VALID;`,
+      isTransactional: true,
+      riskLevel: 'low',
+      dependencies: [],
+    });
+    steps.push({
+      id: `step_${Date.now()}_2`,
+      type: 'constraint',
+      phase: 13,
+      description: `Validate FK ${con.name}`,
+      sql: `ALTER TABLE ${con._tableKey || con.table} VALIDATE CONSTRAINT ${con.name};`,
+      isTransactional: true,
+      riskLevel: 'low',
+      dependencies: [steps[0].id],
+    });
+    return steps;
+  }
+
+  // CREATE INDEX CONCURRENTLY pattern
+  if (objectType === 'index' && changeType === 'CREATE' && !change.after?.isConcurrent) {
+    const idx = change.after;
+    steps.push({
+      id: `step_${Date.now()}_1`,
+      type: 'index',
+      phase: 23,
+      description: `Create index ${idx.name} CONCURRENTLY`,
+      sql: `CREATE INDEX CONCURRENTLY ${idx.name} ON ${idx.schema}.${idx.table}${idx.accessMethod && idx.accessMethod !== 'btree' ? ` USING ${idx.accessMethod}` : ''} (${(idx.columns || []).map(c => c.expression || qi(c.name)).join(', ')});`,
+      isTransactional: false,
+      riskLevel: 'low',
+      dependencies: [],
+    });
+    return steps;
+  }
+
+  // Type change with USING clause
+  if (objectType === 'column' && property === 'dataType') {
+    const currentType = change.currentValue;
+    const desiredType = change.desiredValue;
+    if (currentType && desiredType && currentType !== desiredType) {
+      const parts = change.objectKey.split('.');
+      const col = parts.pop();
+      const table = parts.join('.');
+      steps.push({
+        id: `step_${Date.now()}_1`,
+        type: 'structural',
+        phase: 11,
+        description: `Alter type of ${table}.${col} from ${currentType} to ${desiredType}`,
+        sql: `ALTER TABLE ${table} ALTER COLUMN ${col} TYPE ${desiredType} USING ${col}::${desiredType};`,
+        isTransactional: true,
+        riskLevel: 'medium',
+        dependencies: [],
+      });
+      return steps;
+    }
+  }
+
+  // UNIQUE constraint with NOT VALID pattern (for large tables)
+  if (objectType === 'constraint' && change.after?.constraintType === 'UNIQUE' && change.objectKey) {
+    const con = change.after;
+    const table = con._tableKey || con.table;
+    const tempIdxName = `${con.name}_unique_build`;
+    steps.push({
+      id: `step_${Date.now()}_1`,
+      type: 'index',
+      phase: 23,
+      description: `Create unique index CONCURRENTLY for ${con.name}`,
+      sql: `CREATE UNIQUE INDEX CONCURRENTLY ${tempIdxName} ON ${table} (${(con.columns || []).map(qi).join(', ')});`,
+      isTransactional: false,
+      riskLevel: 'low',
+      dependencies: [],
+    });
+    steps.push({
+      id: `step_${Date.now()}_2`,
+      type: 'constraint',
+      phase: 24,
+      description: `Add unique constraint using existing index`,
+      sql: `ALTER TABLE ${table} ADD CONSTRAINT ${con.name} UNIQUE USING INDEX ${tempIdxName};`,
+      isTransactional: true,
+      riskLevel: 'low',
+      dependencies: [steps[0].id],
+    });
+    return steps;
+  }
+
+  // CHECK constraint with NOT VALID pattern (for validation safety)
+  if (objectType === 'constraint' && change.after?.constraintType === 'CHECK' && change.objectKey) {
+    const con = change.after;
+    const table = con._tableKey || con.table;
+    steps.push({
+      id: `step_${Date.now()}_1`,
+      type: 'constraint',
+      phase: 10,
+      description: `Add CHECK constraint ${con.name} NOT VALID`,
+      sql: `ALTER TABLE ${table} ADD CONSTRAINT ${con.name} CHECK (${con.definition || con.check}) NOT VALID;`,
+      isTransactional: true,
+      riskLevel: 'low',
+      dependencies: [],
+    });
+    steps.push({
+      id: `step_${Date.now()}_2`,
+      type: 'constraint',
+      phase: 13,
+      description: `Validate CHECK constraint ${con.name}`,
+      sql: `ALTER TABLE ${table} VALIDATE CONSTRAINT ${con.name};`,
+      isTransactional: true,
+      riskLevel: 'low',
+      dependencies: [steps[0].id],
+    });
+    return steps;
+  }
+
+  // Materialized view refresh after recreation
+  if (objectType === 'materializedView' && (changeType === 'CREATE' || changeType?.includes('RECREATE'))) {
+    const mv = change.after;
+    if (mv.isWithData !== false) {
+      steps.push({
+        id: `step_${Date.now()}_1`,
+        type: 'structural',
+        phase: 15,
+        description: `Refresh materialized view ${change.objectKey}`,
+        sql: `REFRESH MATERIALIZED VIEW ${change.objectKey};`,
+        isTransactional: true,
+        riskLevel: 'low',
+        dependencies: [],
+      });
+      return steps;
+    }
+  }
+
+  // Multi-step impossible type change (add column → copy → drop old → rename)
+  if (objectType === 'column' && property === 'dataType' && change.changeType === 'IMPOSSIBLE_CAST') {
+    const parts = change.objectKey.split('.');
+    const col = parts.pop();
+    const table = parts.join('.');
+    const newColName = `${col}_new`;
+    const oldColName = `${col}_old`;
+
+    steps.push({
+      id: `step_${Date.now()}_1`,
+      type: 'structural',
+      phase: 7,
+      description: `Add temporary column ${newColName}`,
+      sql: `ALTER TABLE ${table} ADD COLUMN ${newColName} ${change.desiredValue};`,
+      isTransactional: true,
+      riskLevel: 'medium',
+      dependencies: [],
+    });
+    steps.push({
+      id: `step_${Date.now()}_2`,
+      type: 'structural',
+      phase: 11,
+      description: `Copy data with transformation`,
+      sql: `UPDATE ${table} SET ${newColName} = ${change.usingExpression || `CAST(${col} AS ${change.desiredValue})`};`,
+      isTransactional: true,
+      riskLevel: 'medium',
+      dependencies: [steps[0].id],
+    });
+    steps.push({
+      id: `step_${Date.now()}_3`,
+      type: 'structural',
+      phase: 11,
+      description: `Drop old column`,
+      sql: `ALTER TABLE ${table} DROP COLUMN ${col};`,
+      isTransactional: true,
+      riskLevel: 'high',
+      dependencies: [steps[1].id],
+    });
+    steps.push({
+      id: `step_${Date.now()}_4`,
+      type: 'structural',
+      phase: 11,
+      description: `Rename new column to original name`,
+      sql: `ALTER TABLE ${table} RENAME COLUMN ${newColName} TO ${col};`,
+      isTransactional: true,
+      riskLevel: 'low',
+      dependencies: [steps[2].id],
+    });
+    return steps;
+  }
+
+  return null;
+}