aigroup-workflow 1.0.1 → 1.1.1

package/skills/jarvis/engineering-team/engineering/database-designer/migration_generator.py

@@ -1,1199 +0,0 @@
-#!/usr/bin/env python3
-"""
-Database Migration Generator
-
-Generates safe migration scripts between schema versions:
-- Compares current and target schemas
-- Generates ALTER TABLE statements for schema changes
-- Implements zero-downtime migration strategies (expand-contract pattern)
-- Creates rollback scripts for all changes
-- Generates validation queries to verify migrations
-- Handles complex changes like table splits/merges
-
-Input: Current schema JSON + Target schema JSON
-Output: Migration SQL + Rollback SQL + Validation queries + Execution plan
-
-Usage:
-    python migration_generator.py --current current_schema.json --target target_schema.json --output migration.sql
-    python migration_generator.py --current current.json --target target.json --format json
-    python migration_generator.py --current current.json --target target.json --zero-downtime
-    python migration_generator.py --current current.json --target target.json --validate-only
-"""
-
-import argparse
-import json
-import re
-import sys
-from collections import defaultdict, OrderedDict
-from typing import Dict, List, Set, Tuple, Optional, Any, Union
-from dataclasses import dataclass, asdict
-from datetime import datetime
-import hashlib
-
-
-@dataclass
-class Column:
-    name: str
-    data_type: str
-    nullable: bool = True
-    primary_key: bool = False
-    unique: bool = False
-    foreign_key: Optional[str] = None
-    default_value: Optional[str] = None
-    check_constraint: Optional[str] = None
-    
-
-@dataclass
-class Table:
-    name: str
-    columns: Dict[str, Column]
-    primary_key: List[str]
-    foreign_keys: Dict[str, str]  # column -> referenced_table.column
-    unique_constraints: List[List[str]]
-    check_constraints: Dict[str, str]
-    indexes: List[Dict[str, Any]]
-
-
-@dataclass
-class MigrationStep:
-    step_id: str
-    step_type: str
-    table: str
-    description: str
-    sql_forward: str
-    sql_rollback: str
-    validation_sql: Optional[str] = None
-    dependencies: List[str] = None
-    risk_level: str = "LOW"  # LOW, MEDIUM, HIGH
-    estimated_time: Optional[str] = None
-    zero_downtime_phase: Optional[str] = None  # EXPAND, CONTRACT, or None
-
-
-@dataclass
-class MigrationPlan:
-    migration_id: str
-    created_at: str
-    source_schema_hash: str
-    target_schema_hash: str
-    steps: List[MigrationStep]
-    summary: Dict[str, Any]
-    execution_order: List[str]
-    rollback_order: List[str]
-
-
-@dataclass
-class ValidationCheck:
-    check_id: str
-    check_type: str
-    table: str
-    description: str
-    sql_query: str
-    expected_result: Any
-    critical: bool = True
-
-
-class SchemaComparator:
-    """Compares two schema versions and identifies differences."""
-    
-    def __init__(self):
-        self.current_schema: Dict[str, Table] = {}
-        self.target_schema: Dict[str, Table] = {}
-        self.changes: Dict[str, List[Dict[str, Any]]] = {
-            'tables_added': [],
-            'tables_dropped': [],
-            'tables_renamed': [],
-            'columns_added': [],
-            'columns_dropped': [],
-            'columns_modified': [],
-            'columns_renamed': [],
-            'constraints_added': [],
-            'constraints_dropped': [],
-            'indexes_added': [],
-            'indexes_dropped': []
-        }
-    
-    def load_schemas(self, current_data: Dict[str, Any], target_data: Dict[str, Any]):
-        """Load current and target schemas."""
-        self.current_schema = self._parse_schema(current_data)
-        self.target_schema = self._parse_schema(target_data)
-    
-    def _parse_schema(self, schema_data: Dict[str, Any]) -> Dict[str, Table]:
-        """Parse schema JSON into Table objects."""
-        tables = {}
-        
-        if 'tables' not in schema_data:
-            return tables
-        
-        for table_name, table_def in schema_data['tables'].items():
-            columns = {}
-            primary_key = table_def.get('primary_key', [])
-            foreign_keys = {}
-            
-            # Parse columns
-            for col_name, col_def in table_def.get('columns', {}).items():
-                column = Column(
-                    name=col_name,
-                    data_type=col_def.get('type', 'VARCHAR(255)'),
-                    nullable=col_def.get('nullable', True),
-                    primary_key=col_name in primary_key,
-                    unique=col_def.get('unique', False),
-                    foreign_key=col_def.get('foreign_key'),
-                    default_value=col_def.get('default'),
-                    check_constraint=col_def.get('check_constraint')
-                )
-                columns[col_name] = column
-                
-                if column.foreign_key:
-                    foreign_keys[col_name] = column.foreign_key
-            
-            table = Table(
-                name=table_name,
-                columns=columns,
-                primary_key=primary_key,
-                foreign_keys=foreign_keys,
-                unique_constraints=table_def.get('unique_constraints', []),
-                check_constraints=table_def.get('check_constraints', {}),
-                indexes=table_def.get('indexes', [])
-            )
-            tables[table_name] = table
-        
-        return tables
-    
-    def compare_schemas(self) -> Dict[str, List[Dict[str, Any]]]:
-        """Compare schemas and identify all changes."""
-        self._compare_tables()
-        self._compare_columns()
-        self._compare_constraints()
-        self._compare_indexes()
-        return self.changes
-    
-    def _compare_tables(self):
-        """Compare table-level changes."""
-        current_tables = set(self.current_schema.keys())
-        target_tables = set(self.target_schema.keys())
-        
-        # Tables added
-        for table_name in target_tables - current_tables:
-            self.changes['tables_added'].append({
-                'table': table_name,
-                'definition': self.target_schema[table_name]
-            })
-        
-        # Tables dropped
-        for table_name in current_tables - target_tables:
-            self.changes['tables_dropped'].append({
-                'table': table_name,
-                'definition': self.current_schema[table_name]
-            })
-        
-        # Tables renamed (heuristic based on column similarity)
-        self._detect_renamed_tables(current_tables - target_tables, target_tables - current_tables)
-    
-    def _detect_renamed_tables(self, dropped_tables: Set[str], added_tables: Set[str]):
-        """Detect renamed tables based on column similarity."""
-        if not dropped_tables or not added_tables:
-            return
-        
-        # Calculate similarity scores
-        similarity_scores = []
-        for dropped_table in dropped_tables:
-            for added_table in added_tables:
-                score = self._calculate_table_similarity(dropped_table, added_table)
-                if score > 0.7:  # High similarity threshold
-                    similarity_scores.append((score, dropped_table, added_table))
-        
-        # Sort by similarity and identify renames
-        similarity_scores.sort(reverse=True)
-        used_tables = set()
-        
-        for score, old_name, new_name in similarity_scores:
-            if old_name not in used_tables and new_name not in used_tables:
-                self.changes['tables_renamed'].append({
-                    'old_name': old_name,
-                    'new_name': new_name,
-                    'similarity_score': score
-                })
-                used_tables.add(old_name)
-                used_tables.add(new_name)
-                
-                # Remove from added/dropped lists
-                self.changes['tables_added'] = [t for t in self.changes['tables_added'] if t['table'] != new_name]
-                self.changes['tables_dropped'] = [t for t in self.changes['tables_dropped'] if t['table'] != old_name]
-    
-    def _calculate_table_similarity(self, table1_name: str, table2_name: str) -> float:
-        """Calculate similarity between two tables based on columns."""
-        table1 = self.current_schema[table1_name]
-        table2 = self.target_schema[table2_name]
-        
-        cols1 = set(table1.columns.keys())
-        cols2 = set(table2.columns.keys())
-        
-        if not cols1 and not cols2:
-            return 1.0
-        elif not cols1 or not cols2:
-            return 0.0
-        
-        intersection = len(cols1.intersection(cols2))
-        union = len(cols1.union(cols2))
-        
-        return intersection / union
-    
-    def _compare_columns(self):
-        """Compare column-level changes."""
-        common_tables = set(self.current_schema.keys()).intersection(set(self.target_schema.keys()))
-        
-        for table_name in common_tables:
-            current_table = self.current_schema[table_name]
-            target_table = self.target_schema[table_name]
-            
-            current_columns = set(current_table.columns.keys())
-            target_columns = set(target_table.columns.keys())
-            
-            # Columns added
-            for col_name in target_columns - current_columns:
-                self.changes['columns_added'].append({
-                    'table': table_name,
-                    'column': col_name,
-                    'definition': target_table.columns[col_name]
-                })
-            
-            # Columns dropped
-            for col_name in current_columns - target_columns:
-                self.changes['columns_dropped'].append({
-                    'table': table_name,
-                    'column': col_name,
-                    'definition': current_table.columns[col_name]
-                })
-            
-            # Columns modified
-            for col_name in current_columns.intersection(target_columns):
-                current_col = current_table.columns[col_name]
-                target_col = target_table.columns[col_name]
-                
-                if self._columns_different(current_col, target_col):
-                    self.changes['columns_modified'].append({
-                        'table': table_name,
-                        'column': col_name,
-                        'current_definition': current_col,
-                        'target_definition': target_col,
-                        'changes': self._describe_column_changes(current_col, target_col)
-                    })
-    
-    def _columns_different(self, col1: Column, col2: Column) -> bool:
-        """Check if two columns have different definitions."""
-        return (col1.data_type != col2.data_type or
-                col1.nullable != col2.nullable or
-                col1.default_value != col2.default_value or
-                col1.unique != col2.unique or
-                col1.foreign_key != col2.foreign_key or
-                col1.check_constraint != col2.check_constraint)
-    
-    def _describe_column_changes(self, current_col: Column, target_col: Column) -> List[str]:
-        """Describe specific changes between column definitions."""
-        changes = []
-        
-        if current_col.data_type != target_col.data_type:
-            changes.append(f"type: {current_col.data_type} -> {target_col.data_type}")
-        
-        if current_col.nullable != target_col.nullable:
-            changes.append(f"nullable: {current_col.nullable} -> {target_col.nullable}")
-        
-        if current_col.default_value != target_col.default_value:
-            changes.append(f"default: {current_col.default_value} -> {target_col.default_value}")
-        
-        if current_col.unique != target_col.unique:
-            changes.append(f"unique: {current_col.unique} -> {target_col.unique}")
-        
-        if current_col.foreign_key != target_col.foreign_key:
-            changes.append(f"foreign_key: {current_col.foreign_key} -> {target_col.foreign_key}")
-        
-        return changes
-    
-    def _compare_constraints(self):
-        """Compare constraint changes."""
-        common_tables = set(self.current_schema.keys()).intersection(set(self.target_schema.keys()))
-        
-        for table_name in common_tables:
-            current_table = self.current_schema[table_name]
-            target_table = self.target_schema[table_name]
-            
-            # Compare primary keys
-            if current_table.primary_key != target_table.primary_key:
-                if current_table.primary_key:
-                    self.changes['constraints_dropped'].append({
-                        'table': table_name,
-                        'constraint_type': 'PRIMARY_KEY',
-                        'columns': current_table.primary_key
-                    })
-                
-                if target_table.primary_key:
-                    self.changes['constraints_added'].append({
-                        'table': table_name,
-                        'constraint_type': 'PRIMARY_KEY',
-                        'columns': target_table.primary_key
-                    })
-            
-            # Compare unique constraints
-            current_unique = set(tuple(uc) for uc in current_table.unique_constraints)
-            target_unique = set(tuple(uc) for uc in target_table.unique_constraints)
-            
-            for constraint in target_unique - current_unique:
-                self.changes['constraints_added'].append({
-                    'table': table_name,
-                    'constraint_type': 'UNIQUE',
-                    'columns': list(constraint)
-                })
-            
-            for constraint in current_unique - target_unique:
-                self.changes['constraints_dropped'].append({
-                    'table': table_name,
-                    'constraint_type': 'UNIQUE',
-                    'columns': list(constraint)
-                })
-            
-            # Compare check constraints
-            current_checks = set(current_table.check_constraints.items())
-            target_checks = set(target_table.check_constraints.items())
-            
-            for name, condition in target_checks - current_checks:
-                self.changes['constraints_added'].append({
-                    'table': table_name,
-                    'constraint_type': 'CHECK',
-                    'constraint_name': name,
-                    'condition': condition
-                })
-            
-            for name, condition in current_checks - target_checks:
-                self.changes['constraints_dropped'].append({
-                    'table': table_name,
-                    'constraint_type': 'CHECK',
-                    'constraint_name': name,
-                    'condition': condition
-                })
-    
-    def _compare_indexes(self):
-        """Compare index changes."""
-        common_tables = set(self.current_schema.keys()).intersection(set(self.target_schema.keys()))
-        
-        for table_name in common_tables:
-            current_indexes = {idx['name']: idx for idx in self.current_schema[table_name].indexes}
-            target_indexes = {idx['name']: idx for idx in self.target_schema[table_name].indexes}
-            
-            current_names = set(current_indexes.keys())
-            target_names = set(target_indexes.keys())
-            
-            # Indexes added
-            for idx_name in target_names - current_names:
-                self.changes['indexes_added'].append({
-                    'table': table_name,
-                    'index': target_indexes[idx_name]
-                })
-            
-            # Indexes dropped
-            for idx_name in current_names - target_names:
-                self.changes['indexes_dropped'].append({
-                    'table': table_name,
-                    'index': current_indexes[idx_name]
-                })
-
-
-class MigrationGenerator:
-    """Generates migration steps from schema differences."""
-    
-    def __init__(self, zero_downtime: bool = False):
-        self.zero_downtime = zero_downtime
-        self.migration_steps: List[MigrationStep] = []
-        self.step_counter = 0
-        
-        # Data type conversion safety
-        self.safe_type_conversions = {
-            ('VARCHAR(50)', 'VARCHAR(100)'): True,  # Expanding varchar
-            ('INT', 'BIGINT'): True,  # Expanding integer
-            ('DECIMAL(10,2)', 'DECIMAL(12,2)'): True,  # Expanding decimal precision
-        }
-        
-        self.risky_type_conversions = {
-            ('VARCHAR(100)', 'VARCHAR(50)'): 'Data truncation possible',
-            ('BIGINT', 'INT'): 'Data loss possible for large values',
-            ('TEXT', 'VARCHAR(255)'): 'Data truncation possible'
-        }
-    
-    def generate_migration(self, changes: Dict[str, List[Dict[str, Any]]]) -> MigrationPlan:
-        """Generate complete migration plan from schema changes."""
-        self.migration_steps = []
-        self.step_counter = 0
-        
-        # Generate steps in dependency order
-        self._generate_table_creation_steps(changes['tables_added'])
-        self._generate_column_addition_steps(changes['columns_added'])
-        self._generate_constraint_addition_steps(changes['constraints_added'])
-        self._generate_index_addition_steps(changes['indexes_added'])
-        self._generate_column_modification_steps(changes['columns_modified'])
-        self._generate_table_rename_steps(changes['tables_renamed'])
-        self._generate_index_removal_steps(changes['indexes_dropped'])
-        self._generate_constraint_removal_steps(changes['constraints_dropped'])
-        self._generate_column_removal_steps(changes['columns_dropped'])
-        self._generate_table_removal_steps(changes['tables_dropped'])
-        
-        # Create migration plan
-        migration_id = self._generate_migration_id(changes)
-        execution_order = [step.step_id for step in self.migration_steps]
-        rollback_order = list(reversed(execution_order))
-        
-        return MigrationPlan(
-            migration_id=migration_id,
-            created_at=datetime.now().isoformat(),
-            source_schema_hash=self._calculate_changes_hash(changes),
-            target_schema_hash="",  # Would be calculated from target schema
-            steps=self.migration_steps,
-            summary=self._generate_summary(changes),
-            execution_order=execution_order,
-            rollback_order=rollback_order
-        )
-    
-    def _generate_step_id(self) -> str:
-        """Generate unique step ID."""
-        self.step_counter += 1
-        return f"step_{self.step_counter:03d}"
-    
-    def _generate_table_creation_steps(self, tables_added: List[Dict[str, Any]]):
-        """Generate steps for creating new tables."""
-        for table_info in tables_added:
-            table = table_info['definition']
-            step = self._create_table_step(table)
-            self.migration_steps.append(step)
-    
-    def _create_table_step(self, table: Table) -> MigrationStep:
-        """Create migration step for table creation."""
-        columns_sql = []
-        
-        for col_name, column in table.columns.items():
-            col_sql = f"{col_name} {column.data_type}"
-            
-            if not column.nullable:
-                col_sql += " NOT NULL"
-            
-            if column.default_value:
-                col_sql += f" DEFAULT {column.default_value}"
-            
-            if column.unique:
-                col_sql += " UNIQUE"
-            
-            columns_sql.append(col_sql)
-        
-        # Add primary key
-        if table.primary_key:
-            pk_sql = f"PRIMARY KEY ({', '.join(table.primary_key)})"
-            columns_sql.append(pk_sql)
-        
-        # Add foreign keys
-        for col_name, ref in table.foreign_keys.items():
-            fk_sql = f"FOREIGN KEY ({col_name}) REFERENCES {ref}"
-            columns_sql.append(fk_sql)
-        
-        create_sql = f"CREATE TABLE {table.name} (\n    " + ",\n    ".join(columns_sql) + "\n);"
-        drop_sql = f"DROP TABLE IF EXISTS {table.name};"
-        
-        return MigrationStep(
-            step_id=self._generate_step_id(),
-            step_type="CREATE_TABLE",
-            table=table.name,
-            description=f"Create table {table.name} with {len(table.columns)} columns",
-            sql_forward=create_sql,
-            sql_rollback=drop_sql,
-            validation_sql=f"SELECT COUNT(*) FROM information_schema.tables WHERE table_name = '{table.name}';",
-            risk_level="LOW"
-        )
-    
-    def _generate_column_addition_steps(self, columns_added: List[Dict[str, Any]]):
-        """Generate steps for adding columns."""
-        for col_info in columns_added:
-            if self.zero_downtime:
-                # For zero-downtime, add columns as nullable first
-                step = self._add_column_zero_downtime_step(col_info)
-            else:
-                step = self._add_column_step(col_info)
-            self.migration_steps.append(step)
-    
-    def _add_column_step(self, col_info: Dict[str, Any]) -> MigrationStep:
-        """Create step for adding a column."""
-        table = col_info['table']
-        column = col_info['definition']
-        
-        col_sql = f"{column.name} {column.data_type}"
-        
-        if not column.nullable:
-            if column.default_value:
-                col_sql += f" DEFAULT {column.default_value} NOT NULL"
-            else:
-                # This is risky - adding NOT NULL without default
-                col_sql += " NOT NULL"
-        elif column.default_value:
-            col_sql += f" DEFAULT {column.default_value}"
-        
-        add_sql = f"ALTER TABLE {table} ADD COLUMN {col_sql};"
-        drop_sql = f"ALTER TABLE {table} DROP COLUMN {column.name};"
-        
-        risk_level = "HIGH" if not column.nullable and not column.default_value else "LOW"
-        
-        return MigrationStep(
-            step_id=self._generate_step_id(),
-            step_type="ADD_COLUMN",
-            table=table,
-            description=f"Add column {column.name} to {table}",
-            sql_forward=add_sql,
-            sql_rollback=drop_sql,
-            validation_sql=f"SELECT COUNT(*) FROM information_schema.columns WHERE table_name = '{table}' AND column_name = '{column.name}';",
-            risk_level=risk_level
-        )
-    
-    def _add_column_zero_downtime_step(self, col_info: Dict[str, Any]) -> MigrationStep:
-        """Create zero-downtime step for adding column."""
-        table = col_info['table']
-        column = col_info['definition']
-        
-        # Phase 1: Add as nullable with default if needed
-        col_sql = f"{column.name} {column.data_type}"
-        if column.default_value:
-            col_sql += f" DEFAULT {column.default_value}"
-        
-        add_sql = f"ALTER TABLE {table} ADD COLUMN {col_sql};"
-        
-        # If column should be NOT NULL, handle in separate phase
-        if not column.nullable:
-            # Add comment about needing follow-up step
-            add_sql += f"\n-- Follow-up needed: Add NOT NULL constraint after data population"
-        
-        drop_sql = f"ALTER TABLE {table} DROP COLUMN {column.name};"
-        
-        return MigrationStep(
-            step_id=self._generate_step_id(),
-            step_type="ADD_COLUMN_ZD",
-            table=table,
-            description=f"Add column {column.name} to {table} (zero-downtime phase 1)",
-            sql_forward=add_sql,
-            sql_rollback=drop_sql,
-            validation_sql=f"SELECT COUNT(*) FROM information_schema.columns WHERE table_name = '{table}' AND column_name = '{column.name}';",
-            risk_level="LOW",
-            zero_downtime_phase="EXPAND"
-        )
-    
-    def _generate_column_modification_steps(self, columns_modified: List[Dict[str, Any]]):
-        """Generate steps for modifying columns."""
-        for col_info in columns_modified:
-            if self.zero_downtime:
-                steps = self._modify_column_zero_downtime_steps(col_info)
-                self.migration_steps.extend(steps)
-            else:
-                step = self._modify_column_step(col_info)
-                self.migration_steps.append(step)
-    
-    def _modify_column_step(self, col_info: Dict[str, Any]) -> MigrationStep:
-        """Create step for modifying a column."""
-        table = col_info['table']
-        column = col_info['column']
-        current_def = col_info['current_definition']
-        target_def = col_info['target_definition']
-        changes = col_info['changes']
-        
-        alter_statements = []
-        rollback_statements = []
-        
-        # Handle different types of changes
-        if current_def.data_type != target_def.data_type:
-            alter_statements.append(f"ALTER COLUMN {column} TYPE {target_def.data_type}")
-            rollback_statements.append(f"ALTER COLUMN {column} TYPE {current_def.data_type}")
-        
-        if current_def.nullable != target_def.nullable:
-            if target_def.nullable:
-                alter_statements.append(f"ALTER COLUMN {column} DROP NOT NULL")
-                rollback_statements.append(f"ALTER COLUMN {column} SET NOT NULL")
-            else:
-                alter_statements.append(f"ALTER COLUMN {column} SET NOT NULL")
-                rollback_statements.append(f"ALTER COLUMN {column} DROP NOT NULL")
-        
-        if current_def.default_value != target_def.default_value:
-            if target_def.default_value:
-                alter_statements.append(f"ALTER COLUMN {column} SET DEFAULT {target_def.default_value}")
-            else:
-                alter_statements.append(f"ALTER COLUMN {column} DROP DEFAULT")
-            
-            if current_def.default_value:
-                rollback_statements.append(f"ALTER COLUMN {column} SET DEFAULT {current_def.default_value}")
-            else:
-                rollback_statements.append(f"ALTER COLUMN {column} DROP DEFAULT")
-        
-        # Build SQL
-        alter_sql = f"ALTER TABLE {table}\n    " + ",\n    ".join(alter_statements) + ";"
-        rollback_sql = f"ALTER TABLE {table}\n    " + ",\n    ".join(rollback_statements) + ";"
-        
-        # Assess risk
-        risk_level = self._assess_column_modification_risk(current_def, target_def)
-        
-        return MigrationStep(
-            step_id=self._generate_step_id(),
-            step_type="MODIFY_COLUMN",
-            table=table,
-            description=f"Modify column {column}: {', '.join(changes)}",
-            sql_forward=alter_sql,
-            sql_rollback=rollback_sql,
-            validation_sql=f"SELECT data_type, is_nullable FROM information_schema.columns WHERE table_name = '{table}' AND column_name = '{column}';",
-            risk_level=risk_level
-        )
-    
-    def _modify_column_zero_downtime_steps(self, col_info: Dict[str, Any]) -> List[MigrationStep]:
-        """Create zero-downtime steps for column modification."""
-        table = col_info['table']
-        column = col_info['column']
-        current_def = col_info['current_definition']
-        target_def = col_info['target_definition']
-        
-        steps = []
-        
-        # For zero-downtime, use expand-contract pattern
-        temp_column = f"{column}_new"
-        
-        # Step 1: Add new column
-        step1 = MigrationStep(
-            step_id=self._generate_step_id(),
-            step_type="ADD_TEMP_COLUMN",
-            table=table,
-            description=f"Add temporary column {temp_column} for zero-downtime migration",
-            sql_forward=f"ALTER TABLE {table} ADD COLUMN {temp_column} {target_def.data_type};",
-            sql_rollback=f"ALTER TABLE {table} DROP COLUMN {temp_column};",
-            zero_downtime_phase="EXPAND"
-        )
-        steps.append(step1)
-        
-        # Step 2: Copy data
-        step2 = MigrationStep(
-            step_id=self._generate_step_id(),
-            step_type="COPY_COLUMN_DATA",
-            table=table,
-            description=f"Copy data from {column} to {temp_column}",
-            sql_forward=f"UPDATE {table} SET {temp_column} = {column};",
-            sql_rollback=f"UPDATE {table} SET {temp_column} = NULL;",
-            zero_downtime_phase="EXPAND"
-        )
-        steps.append(step2)
-        
-        # Step 3: Drop old column
-        step3 = MigrationStep(
-            step_id=self._generate_step_id(),
-            step_type="DROP_OLD_COLUMN",
-            table=table,
-            description=f"Drop original column {column}",
-            sql_forward=f"ALTER TABLE {table} DROP COLUMN {column};",
-            sql_rollback=f"ALTER TABLE {table} ADD COLUMN {column} {current_def.data_type};",
-            zero_downtime_phase="CONTRACT"
-        )
-        steps.append(step3)
-        
-        # Step 4: Rename new column
-        step4 = MigrationStep(
-            step_id=self._generate_step_id(),
-            step_type="RENAME_COLUMN",
-            table=table,
-            description=f"Rename {temp_column} to {column}",
-            sql_forward=f"ALTER TABLE {table} RENAME COLUMN {temp_column} TO {column};",
-            sql_rollback=f"ALTER TABLE {table} RENAME COLUMN {column} TO {temp_column};",
-            zero_downtime_phase="CONTRACT"
-        )
-        steps.append(step4)
-        
-        return steps
-    
-    def _assess_column_modification_risk(self, current: Column, target: Column) -> str:
-        """Assess risk level of column modification."""
-        if current.data_type != target.data_type:
-            conversion_key = (current.data_type, target.data_type)
-            if conversion_key in self.risky_type_conversions:
-                return "HIGH"
-            elif conversion_key not in self.safe_type_conversions:
-                return "MEDIUM"
-        
-        if current.nullable and not target.nullable:
-            return "HIGH"  # Adding NOT NULL constraint
-        
-        return "LOW"
-    
-    def _generate_constraint_addition_steps(self, constraints_added: List[Dict[str, Any]]):
-        """Generate steps for adding constraints."""
-        for constraint_info in constraints_added:
-            step = self._add_constraint_step(constraint_info)
-            self.migration_steps.append(step)
-    
-    def _add_constraint_step(self, constraint_info: Dict[str, Any]) -> MigrationStep:
-        """Create step for adding constraint."""
-        table = constraint_info['table']
-        constraint_type = constraint_info['constraint_type']
-        
-        if constraint_type == 'PRIMARY_KEY':
-            columns = constraint_info['columns']
-            constraint_name = f"pk_{table}"
-            add_sql = f"ALTER TABLE {table} ADD CONSTRAINT {constraint_name} PRIMARY KEY ({', '.join(columns)});"
-            drop_sql = f"ALTER TABLE {table} DROP CONSTRAINT {constraint_name};"
-            description = f"Add primary key on {', '.join(columns)}"
-            
-        elif constraint_type == 'UNIQUE':
-            columns = constraint_info['columns']
-            constraint_name = f"uq_{table}_{'_'.join(columns)}"
-            add_sql = f"ALTER TABLE {table} ADD CONSTRAINT {constraint_name} UNIQUE ({', '.join(columns)});"
-            drop_sql = f"ALTER TABLE {table} DROP CONSTRAINT {constraint_name};"
-            description = f"Add unique constraint on {', '.join(columns)}"
-            
-        elif constraint_type == 'CHECK':
-            constraint_name = constraint_info['constraint_name']
-            condition = constraint_info['condition']
-            add_sql = f"ALTER TABLE {table} ADD CONSTRAINT {constraint_name} CHECK ({condition});"
-            drop_sql = f"ALTER TABLE {table} DROP CONSTRAINT {constraint_name};"
-            description = f"Add check constraint: {condition}"
-            
-        else:
-            return None
-        
-        return MigrationStep(
-            step_id=self._generate_step_id(),
-            step_type="ADD_CONSTRAINT",
-            table=table,
-            description=description,
-            sql_forward=add_sql,
-            sql_rollback=drop_sql,
-            risk_level="MEDIUM"  # Constraints can fail if data doesn't comply
-        )
-    
-    def _generate_index_addition_steps(self, indexes_added: List[Dict[str, Any]]):
-        """Generate steps for adding indexes."""
-        for index_info in indexes_added:
-            step = self._add_index_step(index_info)
-            self.migration_steps.append(step)
-    
-    def _add_index_step(self, index_info: Dict[str, Any]) -> MigrationStep:
-        """Create step for adding index."""
-        table = index_info['table']
-        index = index_info['index']
-        
-        unique_keyword = "UNIQUE " if index.get('unique', False) else ""
-        columns_sql = ', '.join(index['columns'])
-        
-        create_sql = f"CREATE {unique_keyword}INDEX {index['name']} ON {table} ({columns_sql});"
-        drop_sql = f"DROP INDEX {index['name']};"
-        
-        return MigrationStep(
-            step_id=self._generate_step_id(),
-            step_type="ADD_INDEX",
-            table=table,
-            description=f"Create index {index['name']} on ({columns_sql})",
-            sql_forward=create_sql,
-            sql_rollback=drop_sql,
-            estimated_time="1-5 minutes depending on table size",
-            risk_level="LOW"
-        )
-    
-    def _generate_table_rename_steps(self, tables_renamed: List[Dict[str, Any]]):
-        """Generate steps for renaming tables."""
-        for rename_info in tables_renamed:
-            step = self._rename_table_step(rename_info)
-            self.migration_steps.append(step)
-    
-    def _rename_table_step(self, rename_info: Dict[str, Any]) -> MigrationStep:
-        """Create step for renaming table."""
-        old_name = rename_info['old_name']
-        new_name = rename_info['new_name']
-        
-        rename_sql = f"ALTER TABLE {old_name} RENAME TO {new_name};"
-        rollback_sql = f"ALTER TABLE {new_name} RENAME TO {old_name};"
-        
-        return MigrationStep(
-            step_id=self._generate_step_id(),
-            step_type="RENAME_TABLE",
-            table=old_name,
-            description=f"Rename table {old_name} to {new_name}",
-            sql_forward=rename_sql,
-            sql_rollback=rollback_sql,
-            validation_sql=f"SELECT COUNT(*) FROM information_schema.tables WHERE table_name = '{new_name}';",
-            risk_level="LOW"
-        )
-    
-    def _generate_column_removal_steps(self, columns_dropped: List[Dict[str, Any]]):
-        """Generate steps for removing columns."""
-        for col_info in columns_dropped:
-            step = self._drop_column_step(col_info)
-            self.migration_steps.append(step)
-    
-    def _drop_column_step(self, col_info: Dict[str, Any]) -> MigrationStep:
-        """Create step for dropping column."""
-        table = col_info['table']
-        column = col_info['definition']
-        
-        drop_sql = f"ALTER TABLE {table} DROP COLUMN {column.name};"
-        
-        # Recreate column for rollback
-        col_sql = f"{column.name} {column.data_type}"
-        if not column.nullable:
-            col_sql += " NOT NULL"
-        if column.default_value:
-            col_sql += f" DEFAULT {column.default_value}"
-        
-        add_sql = f"ALTER TABLE {table} ADD COLUMN {col_sql};"
-        
-        return MigrationStep(
-            step_id=self._generate_step_id(),
-            step_type="DROP_COLUMN",
-            table=table,
-            description=f"Drop column {column.name} from {table}",
-            sql_forward=drop_sql,
-            sql_rollback=add_sql,
-            risk_level="HIGH"  # Data loss risk
-        )
-    
-    def _generate_constraint_removal_steps(self, constraints_dropped: List[Dict[str, Any]]):
-        """Generate steps for removing constraints."""
-        for constraint_info in constraints_dropped:
-            step = self._drop_constraint_step(constraint_info)
-            if step:
-                self.migration_steps.append(step)
-    
-    def _drop_constraint_step(self, constraint_info: Dict[str, Any]) -> Optional[MigrationStep]:
-        """Create step for dropping constraint."""
-        table = constraint_info['table']
-        constraint_type = constraint_info['constraint_type']
-        
-        if constraint_type == 'PRIMARY_KEY':
-            constraint_name = f"pk_{table}"
-            drop_sql = f"ALTER TABLE {table} DROP CONSTRAINT {constraint_name};"
-            columns = constraint_info['columns']
-            add_sql = f"ALTER TABLE {table} ADD CONSTRAINT {constraint_name} PRIMARY KEY ({', '.join(columns)});"
-            description = f"Drop primary key constraint"
-            
-        elif constraint_type == 'UNIQUE':
-            columns = constraint_info['columns']
-            constraint_name = f"uq_{table}_{'_'.join(columns)}"
-            drop_sql = f"ALTER TABLE {table} DROP CONSTRAINT {constraint_name};"
-            add_sql = f"ALTER TABLE {table} ADD CONSTRAINT {constraint_name} UNIQUE ({', '.join(columns)});"
-            description = f"Drop unique constraint on {', '.join(columns)}"
-            
-        elif constraint_type == 'CHECK':
-            constraint_name = constraint_info['constraint_name']
-            condition = constraint_info.get('condition', '')
-            drop_sql = f"ALTER TABLE {table} DROP CONSTRAINT {constraint_name};"
-            add_sql = f"ALTER TABLE {table} ADD CONSTRAINT {constraint_name} CHECK ({condition});"
-            description = f"Drop check constraint {constraint_name}"
-            
-        else:
-            return None
-        
-        return MigrationStep(
-            step_id=self._generate_step_id(),
-            step_type="DROP_CONSTRAINT",
-            table=table,
-            description=description,
-            sql_forward=drop_sql,
-            sql_rollback=add_sql,
-            risk_level="MEDIUM"
-        )
-    
-    def _generate_index_removal_steps(self, indexes_dropped: List[Dict[str, Any]]):
-        """Generate steps for removing indexes."""
-        for index_info in indexes_dropped:
-            step = self._drop_index_step(index_info)
-            self.migration_steps.append(step)
-    
-    def _drop_index_step(self, index_info: Dict[str, Any]) -> MigrationStep:
-        """Create step for dropping index."""
-        table = index_info['table']
-        index = index_info['index']
-        
-        drop_sql = f"DROP INDEX {index['name']};"
-        
-        # Recreate for rollback
-        unique_keyword = "UNIQUE " if index.get('unique', False) else ""
-        columns_sql = ', '.join(index['columns'])
-        create_sql = f"CREATE {unique_keyword}INDEX {index['name']} ON {table} ({columns_sql});"
-        
-        return MigrationStep(
-            step_id=self._generate_step_id(),
-            step_type="DROP_INDEX",
-            table=table,
-            description=f"Drop index {index['name']}",
-            sql_forward=drop_sql,
-            sql_rollback=create_sql,
-            risk_level="LOW"
-        )
-    
-    def _generate_table_removal_steps(self, tables_dropped: List[Dict[str, Any]]):
-        """Generate steps for removing tables."""
-        for table_info in tables_dropped:
-            step = self._drop_table_step(table_info)
-            self.migration_steps.append(step)
-    
-    def _drop_table_step(self, table_info: Dict[str, Any]) -> MigrationStep:
-        """Create step for dropping table."""
-        table = table_info['definition']
-        
-        drop_sql = f"DROP TABLE {table.name};"
-        
-        # Would need to recreate entire table for rollback
-        # This is simplified - full implementation would generate CREATE TABLE statement
-        create_sql = f"-- Recreate table {table.name} (implementation needed)"
-        
-        return MigrationStep(
-            step_id=self._generate_step_id(),
-            step_type="DROP_TABLE",
-            table=table.name,
-            description=f"Drop table {table.name}",
-            sql_forward=drop_sql,
-            sql_rollback=create_sql,
-            risk_level="HIGH"  # Data loss risk
-        )
-    
-    def _generate_migration_id(self, changes: Dict[str, List[Dict[str, Any]]]) -> str:
-        """Generate unique migration ID."""
-        content = json.dumps(changes, sort_keys=True)
-        return hashlib.md5(content.encode()).hexdigest()[:8]
-    
-    def _calculate_changes_hash(self, changes: Dict[str, List[Dict[str, Any]]]) -> str:
-        """Calculate hash of changes for versioning."""
-        content = json.dumps(changes, sort_keys=True)
-        return hashlib.md5(content.encode()).hexdigest()
-    
-    def _generate_summary(self, changes: Dict[str, List[Dict[str, Any]]]) -> Dict[str, Any]:
-        """Generate migration summary."""
-        summary = {
-            "total_steps": len(self.migration_steps),
-            "changes_summary": {
-                "tables_added": len(changes['tables_added']),
-                "tables_dropped": len(changes['tables_dropped']),
-                "tables_renamed": len(changes['tables_renamed']),
-                "columns_added": len(changes['columns_added']),
-                "columns_dropped": len(changes['columns_dropped']),
-                "columns_modified": len(changes['columns_modified']),
-                "constraints_added": len(changes['constraints_added']),
-                "constraints_dropped": len(changes['constraints_dropped']),
-                "indexes_added": len(changes['indexes_added']),
-                "indexes_dropped": len(changes['indexes_dropped'])
-            },
-            "risk_assessment": {
-                "high_risk_steps": len([s for s in self.migration_steps if s.risk_level == "HIGH"]),
-                "medium_risk_steps": len([s for s in self.migration_steps if s.risk_level == "MEDIUM"]),
-                "low_risk_steps": len([s for s in self.migration_steps if s.risk_level == "LOW"])
-            },
-            "zero_downtime": self.zero_downtime
-        }
-        
-        return summary
-
-
-class ValidationGenerator:
-    """Generates validation queries for migration verification."""
-    
-    def generate_validations(self, migration_plan: MigrationPlan) -> List[ValidationCheck]:
-        """Generate validation checks for migration plan."""
-        validations = []
-        
-        for step in migration_plan.steps:
-            if step.step_type == "CREATE_TABLE":
-                validations.append(self._create_table_validation(step))
-            elif step.step_type == "ADD_COLUMN":
-                validations.append(self._add_column_validation(step))
-            elif step.step_type == "MODIFY_COLUMN":
-                validations.append(self._modify_column_validation(step))
-            elif step.step_type == "ADD_INDEX":
-                validations.append(self._add_index_validation(step))
-        
-        return validations
-    
-    def _create_table_validation(self, step: MigrationStep) -> ValidationCheck:
-        """Create validation for table creation."""
-        return ValidationCheck(
-            check_id=f"validate_{step.step_id}",
-            check_type="TABLE_EXISTS",
-            table=step.table,
-            description=f"Verify table {step.table} exists",
-            sql_query=f"SELECT COUNT(*) FROM information_schema.tables WHERE table_name = '{step.table}';",
-            expected_result=1
-        )
-    
-    def _add_column_validation(self, step: MigrationStep) -> ValidationCheck:
-        """Create validation for column addition."""
-        # Extract column name from SQL
-        column_match = re.search(r'ADD COLUMN (\w+)', step.sql_forward)
-        column_name = column_match.group(1) if column_match else "unknown"
-        
-        return ValidationCheck(
-            check_id=f"validate_{step.step_id}",
-            check_type="COLUMN_EXISTS",
-            table=step.table,
-            description=f"Verify column {column_name} exists in {step.table}",
-            sql_query=f"SELECT COUNT(*) FROM information_schema.columns WHERE table_name = '{step.table}' AND column_name = '{column_name}';",
-            expected_result=1
-        )
-    
-    def _modify_column_validation(self, step: MigrationStep) -> ValidationCheck:
-        """Create validation for column modification."""
-        return ValidationCheck(
-            check_id=f"validate_{step.step_id}",
-            check_type="COLUMN_MODIFIED",
-            table=step.table,
-            description=f"Verify column modification in {step.table}",
-            sql_query=step.validation_sql or f"SELECT 1;",  # Use provided validation or default
-            expected_result=1
-        )
-    
-    def _add_index_validation(self, step: MigrationStep) -> ValidationCheck:
-        """Create validation for index addition."""
-        # Extract index name from SQL
-        index_match = re.search(r'INDEX (\w+)', step.sql_forward)
-        index_name = index_match.group(1) if index_match else "unknown"
-        
-        return ValidationCheck(
-            check_id=f"validate_{step.step_id}",
-            check_type="INDEX_EXISTS",
-            table=step.table,
-            description=f"Verify index {index_name} exists",
-            sql_query=f"SELECT COUNT(*) FROM information_schema.statistics WHERE index_name = '{index_name}';",
-            expected_result=1
-        )
-
-
-def format_migration_plan_text(plan: MigrationPlan, validations: List[ValidationCheck] = None) -> str:
-    """Format migration plan as human-readable text."""
-    lines = []
-    lines.append("DATABASE MIGRATION PLAN")
-    lines.append("=" * 50)
-    lines.append(f"Migration ID: {plan.migration_id}")
-    lines.append(f"Created: {plan.created_at}")
-    lines.append(f"Zero Downtime: {plan.summary['zero_downtime']}")
-    lines.append("")
-    
-    # Summary
-    summary = plan.summary
-    lines.append("MIGRATION SUMMARY")
-    lines.append("-" * 17)
-    lines.append(f"Total Steps: {summary['total_steps']}")
-    
-    changes = summary['changes_summary']
-    for change_type, count in changes.items():
-        if count > 0:
-            lines.append(f"{change_type.replace('_', ' ').title()}: {count}")
-    lines.append("")
-    
-    # Risk Assessment
-    risk = summary['risk_assessment']
-    lines.append("RISK ASSESSMENT")
-    lines.append("-" * 15)
-    lines.append(f"High Risk Steps: {risk['high_risk_steps']}")
-    lines.append(f"Medium Risk Steps: {risk['medium_risk_steps']}")
-    lines.append(f"Low Risk Steps: {risk['low_risk_steps']}")
-    lines.append("")
-    
-    # Migration Steps
-    lines.append("MIGRATION STEPS")
-    lines.append("-" * 15)
-    for i, step in enumerate(plan.steps, 1):
-        lines.append(f"{i}. {step.description} ({step.risk_level} risk)")
-        lines.append(f"   Type: {step.step_type}")
-        if step.zero_downtime_phase:
-            lines.append(f"   Phase: {step.zero_downtime_phase}")
-        lines.append(f"   Forward SQL: {step.sql_forward}")
-        lines.append(f"   Rollback SQL: {step.sql_rollback}")
-        if step.estimated_time:
-            lines.append(f"   Estimated Time: {step.estimated_time}")
-        lines.append("")
-    
-    # Validation Checks
-    if validations:
-        lines.append("VALIDATION CHECKS")
-        lines.append("-" * 17)
-        for validation in validations:
-            lines.append(f"• {validation.description}")
-            lines.append(f"  SQL: {validation.sql_query}")
-            lines.append(f"  Expected: {validation.expected_result}")
-            lines.append("")
-    
-    return "\n".join(lines)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Generate database migration scripts")
-    parser.add_argument("--current", "-c", required=True, help="Current schema JSON file")
-    parser.add_argument("--target", "-t", required=True, help="Target schema JSON file")
-    parser.add_argument("--output", "-o", help="Output file (default: stdout)")
-    parser.add_argument("--format", "-f", choices=["json", "text", "sql"], default="text",
-                       help="Output format")
-    parser.add_argument("--zero-downtime", "-z", action="store_true",
-                       help="Generate zero-downtime migration strategy")
-    parser.add_argument("--validate-only", "-v", action="store_true",
-                       help="Only generate validation queries")
-    parser.add_argument("--include-validations", action="store_true",
-                       help="Include validation queries in output")
-    
-    args = parser.parse_args()
-    
-    try:
-        # Load schemas
-        with open(args.current, 'r') as f:
-            current_schema = json.load(f)
-        
-        with open(args.target, 'r') as f:
-            target_schema = json.load(f)
-        
-        # Compare schemas
-        comparator = SchemaComparator()
-        comparator.load_schemas(current_schema, target_schema)
-        changes = comparator.compare_schemas()
-        
-        if not any(changes.values()):
-            print("No schema changes detected.")
-            return 0
-        
-        # Generate migration
-        generator = MigrationGenerator(zero_downtime=args.zero_downtime)
-        migration_plan = generator.generate_migration(changes)
-        
-        # Generate validations if requested
-        validations = None
-        if args.include_validations or args.validate_only:
-            validator = ValidationGenerator()
-            validations = validator.generate_validations(migration_plan)
-        
-        # Format output
-        if args.validate_only:
-            output = json.dumps([asdict(v) for v in validations], indent=2)
-        elif args.format == "json":
-            result = {"migration_plan": asdict(migration_plan)}
-            if validations:
-                result["validations"] = [asdict(v) for v in validations]
-            output = json.dumps(result, indent=2)
-        elif args.format == "sql":
-            sql_lines = []
-            sql_lines.append("-- Database Migration Script")
-            sql_lines.append(f"-- Migration ID: {migration_plan.migration_id}")
-            sql_lines.append(f"-- Created: {migration_plan.created_at}")
-            sql_lines.append("")
-            
-            for step in migration_plan.steps:
-                sql_lines.append(f"-- Step: {step.description}")
-                sql_lines.append(step.sql_forward)
-                sql_lines.append("")
-            
-            output = "\n".join(sql_lines)
-        else:  # text format
-            output = format_migration_plan_text(migration_plan, validations)
-        
-        # Write output
-        if args.output:
-            with open(args.output, 'w') as f:
-                f.write(output)
-        else:
-            print(output)
-        
-        return 0
-        
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())