sql-diff-explainer 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

sql_diff_explainer/analysis.py

@@ -0,0 +1,804 @@
+"""Static analysis helpers for query contracts, lineage, checks, and migrations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from decimal import Decimal, InvalidOperation
+from typing import TYPE_CHECKING, Any
+
+from .core import SqlglotParser, SQLParseError, UnsupportedSQL
+
+if TYPE_CHECKING:
+    from .core import SQLChange
+
+
+@dataclass(frozen=True)
+class SchemaColumn:
+    """One statically identifiable output column."""
+
+    name: str
+    position: int
+    expression: str
+    data_type: str | None
+    source: str | None
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "name": self.name,
+            "position": self.position,
+            "expression": self.expression,
+            "type": self.data_type,
+            "source": self.source,
+        }
+
+
+@dataclass(frozen=True)
+class SchemaChange:
+    """A change to a query's output-column contract."""
+
+    kind: str
+    before: SchemaColumn | None
+    after: SchemaColumn | None
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "kind": self.kind,
+            "before": self.before.to_dict() if self.before else None,
+            "after": self.after.to_dict() if self.after else None,
+        }
+
+
+@dataclass
+class SchemaContractDiff:
+    """Static comparison of the output columns from two simple SELECT queries."""
+
+    supported: bool = True
+    changes: list[SchemaChange] = field(default_factory=list)
+    unsupported_reason: str | None = None
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "supported": self.supported,
+            "unsupported_reason": self.unsupported_reason,
+            "changes": [change.to_dict() for change in self.changes],
+        }
+
+
+@dataclass(frozen=True)
+class OutputLineage:
+    """Source columns and expression contributing to one query output."""
+
+    name: str
+    expression: str
+    sources: tuple[str, ...]
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "name": self.name,
+            "expression": self.expression,
+            "sources": list(self.sources),
+        }
+
+
+@dataclass(frozen=True)
+class LineageChange:
+    """A changed output lineage between two query versions."""
+
+    kind: str
+    before: OutputLineage | None
+    after: OutputLineage | None
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "kind": self.kind,
+            "before": self.before.to_dict() if self.before else None,
+            "after": self.after.to_dict() if self.after else None,
+        }
+
+
+@dataclass
+class CTELineageDiff:
+    """Changed source-to-output lineage for a pair of supported SELECT queries."""
+
+    supported: bool = True
+    changes: list[LineageChange] = field(default_factory=list)
+    before: list[OutputLineage] = field(default_factory=list)
+    after: list[OutputLineage] = field(default_factory=list)
+    unsupported_reason: str | None = None
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "supported": self.supported,
+            "unsupported_reason": self.unsupported_reason,
+            "before": [item.to_dict() for item in self.before],
+            "after": [item.to_dict() for item in self.after],
+            "changes": [change.to_dict() for change in self.changes],
+        }
+
+
+@dataclass(frozen=True)
+class ValidationSuggestion:
+    """An advisory validation check; SQL is returned but never executed."""
+
+    kind: str
+    description: str
+    sql: str | None
+    checklist: tuple[str, ...]
+    unsupported_reason: str | None = None
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "kind": self.kind,
+            "description": self.description,
+            "advisory": True,
+            "executed": False,
+            "sql": self.sql,
+            "checklist": list(self.checklist),
+            "unsupported_reason": self.unsupported_reason,
+        }
+
+
+@dataclass(frozen=True)
+class MigrationOperation:
+    """One recognized operation in an ALTER TABLE migration."""
+
+    kind: str
+    table: str
+    column: str
+    before: str | None
+    after: str | None
+    statement: str
+    risk: str
+
+    def to_dict(self) -> dict[str, str | None]:
+        return {
+            "kind": self.kind,
+            "table": self.table,
+            "column": self.column,
+            "before": self.before,
+            "after": self.after,
+            "statement": self.statement,
+            "risk": self.risk,
+        }
+
+
+@dataclass(frozen=True)
+class UnsupportedMigrationStatement:
+    """A migration statement or operation outside the supported ALTER subset."""
+
+    statement: str
+    reason: str
+
+    def to_dict(self) -> dict[str, str]:
+        return {"statement": self.statement, "reason": self.reason}
+
+
+@dataclass
+class MigrationAnalysisResult:
+    """Recognized ALTER TABLE operations and explicit unsupported statements."""
+
+    operations: list[MigrationOperation] = field(default_factory=list)
+    unsupported: list[UnsupportedMigrationStatement] = field(default_factory=list)
+
+    @property
+    def supported(self) -> bool:
+        return not self.unsupported
+
+    @property
+    def risk(self) -> str:
+        if self.unsupported:
+            return "high"
+        severity = {"low": 0, "medium": 1, "high": 2}
+        return max(
+            (operation.risk for operation in self.operations),
+            key=severity.__getitem__,
+            default="low",
+        )
+
+    @property
+    def summary(self) -> str:
+        if not self.operations and not self.unsupported:
+            return "No ALTER TABLE operations detected."
+        return (
+            f"{len(self.operations)} migration operation(s), "
+            f"{len(self.unsupported)} unsupported statement/operation(s); "
+            f"overall risk is {self.risk}."
+        )
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "summary": self.summary,
+            "risk": self.risk,
+            "supported": self.supported,
+            "operations": [operation.to_dict() for operation in self.operations],
+            "unsupported": [item.to_dict() for item in self.unsupported],
+        }
+
+
+def _query_select(tree: Any, purpose: str) -> Any:
+    from sqlglot import exp
+
+    if not isinstance(tree, exp.Select):
+        raise UnsupportedSQL(f"{purpose} supports a single SELECT query, not set operations")
+    return tree
+
+
+def _projection_expression(projection: Any) -> Any:
+    from sqlglot import exp
+
+    return projection.this if isinstance(projection, exp.Alias) else projection
+
+
+def _projection_name(projection: Any) -> str:
+    from sqlglot import exp
+
+    name = projection.alias_or_name
+    if name:
+        return str(name)
+    expression = _projection_expression(projection)
+    if isinstance(expression, exp.Column):
+        return expression.name
+    raise UnsupportedSQL("Output expressions require explicit aliases for analysis")
+
+
+def _projection_type(expression: Any, dialect: str | None) -> str | None:
+    from sqlglot import exp
+
+    if isinstance(expression, (exp.Cast, exp.TryCast)):
+        return expression.args["to"].sql(dialect=dialect or None)
+    if isinstance(expression, exp.Literal):
+        if expression.is_string:
+            return "TEXT"
+        literal = str(expression.this)
+        try:
+            Decimal(literal)
+        except InvalidOperation:
+            return None
+        return "DOUBLE" if any(marker in literal.lower() for marker in (".", "e")) else "INT"
+    if isinstance(expression, (exp.Boolean, exp.Null)):
+        return "BOOLEAN" if isinstance(expression, exp.Boolean) else "NULL"
+    return None
+
+
+def _projection_source(expression: Any, dialect: str | None) -> str | None:
+    from sqlglot import exp
+
+    if isinstance(expression, exp.Column):
+        return expression.sql(dialect=dialect or None)
+    if isinstance(expression, (exp.Cast, exp.TryCast)) and isinstance(
+        expression.this, exp.Column
+    ):
+        return expression.this.sql(dialect=dialect or None)
+    return None
+
+
+def _schema_columns(tree: Any, dialect: str | None) -> list[SchemaColumn]:
+    from sqlglot import exp
+
+    select = _query_select(tree, "Output-schema contracts")
+    if any(isinstance(item, exp.Star) for item in select.expressions) or any(
+        isinstance(item, exp.Column) and isinstance(item.this, exp.Star)
+        for item in select.expressions
+    ):
+        raise UnsupportedSQL("Output-schema contracts require explicit projections, not *")
+    columns = []
+    seen: set[str] = set()
+    for index, projection in enumerate(select.expressions):
+        name = _projection_name(projection)
+        if name.casefold() in seen:
+            raise UnsupportedSQL(f"Output-schema contracts require unique output names: {name}")
+        seen.add(name.casefold())
+        expression = _projection_expression(projection)
+        columns.append(
+            SchemaColumn(
+                name=name,
+                position=index,
+                expression=expression.sql(dialect=dialect or None),
+                data_type=_projection_type(expression, dialect),
+                source=_projection_source(expression, dialect),
+            )
+        )
+    return columns
+
+
+def _unsupported_contract(exc: UnsupportedSQL) -> SchemaContractDiff:
+    return SchemaContractDiff(supported=False, unsupported_reason=str(exc))
+
+
+def compare_output_schema(
+    before: str,
+    after: str,
+    *,
+    dialect: str | None = None,
+) -> SchemaContractDiff:
+    """Compare output names and statically-known types from simple SELECT queries.
+
+    Types are reported only when SQL contains a direct cast or literal whose
+    type can be identified without a database catalog.
+    """
+    parser = SqlglotParser()
+    before_tree = parser.parse(before, dialect)
+    after_tree = parser.parse(after, dialect)
+    try:
+        before_columns = _schema_columns(before_tree, dialect)
+        after_columns = _schema_columns(after_tree, dialect)
+    except UnsupportedSQL as exc:
+        return _unsupported_contract(exc)
+
+    before_remaining = list(before_columns)
+    after_remaining = list(after_columns)
+    pairs: list[tuple[SchemaColumn, SchemaColumn]] = []
+    changes: list[SchemaChange] = []
+
+    for old in before_columns:
+        match = next(
+            (new for new in after_remaining if new.name.casefold() == old.name.casefold()),
+            None,
+        )
+        if match is not None:
+            pairs.append((old, match))
+            before_remaining.remove(old)
+            after_remaining.remove(match)
+
+    for old in list(before_remaining):
+        identity = old.source or old.expression
+        matching = [
+            new
+            for new in after_remaining
+            if (new.source or new.expression) == identity
+        ]
+        if len(matching) == 1:
+            new = matching[0]
+            pairs.append((old, new))
+            before_remaining.remove(old)
+            after_remaining.remove(new)
+
+    for old, new in pairs:
+        renamed = old.name.casefold() != new.name.casefold()
+        if renamed:
+            changes.append(SchemaChange("renamed", old, new))
+        if old.position != new.position:
+            changes.append(SchemaChange("reordered", old, new))
+        type_changed = (
+            old.data_type is not None
+            and new.data_type is not None
+            and old.data_type.casefold() != new.data_type.casefold()
+        )
+        expression_changed = old.expression != new.expression and not (
+            renamed and old.source is not None and old.source == new.source
+        )
+        if type_changed:
+            changes.append(SchemaChange("type_changed", old, new))
+        elif expression_changed and not renamed:
+            changes.append(SchemaChange("changed", old, new))
+
+    changes.extend(SchemaChange("removed", old, None) for old in before_remaining)
+    changes.extend(SchemaChange("added", None, new) for new in after_remaining)
+    return SchemaContractDiff(changes=changes)
+
+
+def _lineage_select(
+    select: Any,
+    ctes: dict[str, dict[str, OutputLineage]],
+    dialect: str | None,
+) -> list[OutputLineage]:
+    from sqlglot import exp
+
+    if not isinstance(select, exp.Select):
+        raise UnsupportedSQL("CTE lineage supports SELECT CTE bodies and a SELECT output")
+    if select.find(exp.Subquery):
+        raise UnsupportedSQL("Subqueries are not supported for CTE lineage")
+
+    sources: dict[str, tuple[str, dict[str, OutputLineage] | None]] = {}
+    source_nodes = []
+    from_clause = select.args.get("from_")
+    if from_clause is not None:
+        source_nodes.append(from_clause.this)
+        source_nodes.extend(from_clause.expressions or [])
+    source_nodes.extend(join.this for join in select.args.get("joins", []))
+    for source in source_nodes:
+        if not isinstance(source, exp.Table):
+            raise UnsupportedSQL("CTE lineage supports direct table and CTE sources only")
+        name = source.name
+        alias = source.alias_or_name
+        cte_outputs = ctes.get(name.casefold())
+        if cte_outputs is not None:
+            rendered = name
+        else:
+            source_table = source.copy()
+            source_table.set("alias", None)
+            rendered = source_table.sql(dialect=dialect or None)
+        if alias.casefold() in sources:
+            raise UnsupportedSQL(f"CTE lineage cannot resolve duplicate source alias: {alias}")
+        sources[alias.casefold()] = (rendered, cte_outputs)
+
+    outputs: list[OutputLineage] = []
+    seen: set[str] = set()
+    for projection in select.expressions:
+        expression = _projection_expression(projection)
+        if isinstance(expression, exp.Star) or (
+            isinstance(expression, exp.Column) and isinstance(expression.this, exp.Star)
+        ):
+            raise UnsupportedSQL("CTE lineage requires explicit projections, not *")
+        name = _projection_name(projection)
+        if name.casefold() in seen:
+            raise UnsupportedSQL(f"CTE lineage requires unique output names: {name}")
+        seen.add(name.casefold())
+        inherited: set[str] = set()
+        for column in expression.find_all(exp.Column):
+            qualifier = column.table.casefold()
+            if qualifier:
+                source = sources.get(qualifier)
+                if source is None:
+                    raise UnsupportedSQL(
+                        f"CTE lineage cannot resolve source qualifier: {column.table}"
+                    )
+            elif len(sources) == 1:
+                source = next(iter(sources.values()))
+            elif not sources:
+                continue
+            else:
+                raise UnsupportedSQL(
+                    f"CTE lineage cannot resolve unqualified column: {column.name}"
+                )
+            table_name, cte_outputs = source
+            if cte_outputs is not None:
+                upstream = cte_outputs.get(column.name.casefold())
+                if upstream is None:
+                    raise UnsupportedSQL(
+                        f"CTE lineage cannot resolve {table_name}.{column.name}"
+                    )
+                inherited.update(upstream.sources)
+            else:
+                inherited.add(f"{table_name}.{column.name}")
+        outputs.append(
+            OutputLineage(
+                name=name,
+                expression=expression.sql(dialect=dialect or None),
+                sources=tuple(sorted(inherited)),
+            )
+        )
+    return outputs
+
+
+def _query_lineage(sql: str, dialect: str | None) -> list[OutputLineage]:
+    from sqlglot import exp
+
+    tree = SqlglotParser().parse(sql, dialect)
+    if not isinstance(tree, exp.Select):
+        raise UnsupportedSQL("CTE lineage supports a single SELECT query")
+    with_clause = tree.args.get("with_")
+    ctes: dict[str, dict[str, OutputLineage]] = {}
+    if with_clause is not None:
+        if with_clause.args.get("recursive"):
+            raise UnsupportedSQL("Recursive CTE lineage is not supported")
+        for cte in with_clause.expressions:
+            alias = cte.alias
+            if not alias:
+                raise UnsupportedSQL("CTE lineage requires named CTEs")
+            if cte.this.args.get("with_"):
+                raise UnsupportedSQL("Nested WITH clauses are not supported for CTE lineage")
+            alias_node = cte.args.get("alias")
+            if alias_node is not None and alias_node.args.get("columns"):
+                raise UnsupportedSQL("CTE column alias lists are not supported")
+            outputs = _lineage_select(cte.this, ctes, dialect)
+            ctes[alias.casefold()] = {item.name.casefold(): item for item in outputs}
+    return _lineage_select(tree, ctes, dialect)
+
+
+def trace_cte_lineage(
+    before: str,
+    after: str,
+    *,
+    dialect: str | None = None,
+) -> CTELineageDiff:
+    """Trace source-column lineage through supported CTE chains and compare outputs.
+
+    Unsupported query shapes are returned explicitly in ``unsupported_reason``.
+    """
+    try:
+        before_outputs = _query_lineage(before, dialect)
+        after_outputs = _query_lineage(after, dialect)
+    except UnsupportedSQL as exc:
+        return CTELineageDiff(supported=False, unsupported_reason=str(exc))
+
+    before_by_name = {item.name.casefold(): item for item in before_outputs}
+    after_by_name = {item.name.casefold(): item for item in after_outputs}
+    changes = []
+    output_names = list(before_by_name)
+    output_names.extend(name for name in after_by_name if name not in before_by_name)
+    for name in output_names:
+        old = before_by_name.get(name)
+        new = after_by_name.get(name)
+        if old is None:
+            changes.append(LineageChange("added", None, new))
+        elif new is None:
+            changes.append(LineageChange("removed", old, None))
+        elif old.expression != new.expression or old.sources != new.sources:
+            changes.append(LineageChange("changed", old, new))
+    return CTELineageDiff(
+        changes=changes,
+        before=before_outputs,
+        after=after_outputs,
+    )
+
+
+def generate_validation_suggestions(
+    before: str,
+    after: str,
+    changes: list[SQLChange],
+    contract: SchemaContractDiff,
+    *,
+    dialect: str | None = None,
+) -> list[ValidationSuggestion]:
+    """Create advisory row-difference and duplicate checks for relevant changes."""
+    if not changes:
+        return []
+
+    kinds = {change.category for change in changes}
+    suggestions: list[ValidationSuggestion] = []
+    row_changes = {
+        "where",
+        "join",
+        "select",
+        "group_by",
+        "aggregation",
+        "cte_lineage",
+        "distinct",
+        "limit",
+        "offset",
+        "schema_contract",
+    }
+    if kinds & row_changes:
+        compatible = contract.supported and not any(
+            change.kind in {"added", "removed", "renamed", "reordered", "type_changed"}
+            for change in contract.changes
+        )
+        if compatible:
+            before_query = before.strip().rstrip(";")
+            after_query = after.strip().rstrip(";")
+            row_sql = (
+                "WITH before_result AS (\n"
+                f"{before_query}\n"
+                "), after_result AS (\n"
+                f"{after_query}\n"
+                ")\n"
+                "SELECT 'before_only' AS diff_side, diff.* FROM (\n"
+                "  SELECT * FROM before_result\n"
+                "  EXCEPT\n"
+                "  SELECT * FROM after_result\n"
+                ") AS diff\n"
+                "UNION ALL\n"
+                "SELECT 'after_only' AS diff_side, diff.* FROM (\n"
+                "  SELECT * FROM after_result\n"
+                "  EXCEPT\n"
+                "  SELECT * FROM before_result\n"
+                ") AS diff;"
+            )
+            suggestions.append(
+                ValidationSuggestion(
+                    "unmatched_rows",
+                    "Compare rows present in only one query result.",
+                    row_sql,
+                    (
+                        "Confirm both query outputs have compatible column order and types.",
+                        "Review unmatched rows against intended filtering and join behavior.",
+                    ),
+                )
+            )
+        else:
+            if not contract.supported:
+                reason = contract.unsupported_reason or "Output schema could not be analyzed."
+            elif any(
+                change.kind in {"added", "removed", "renamed", "reordered"}
+                for change in contract.changes
+            ):
+                reason = "Output columns differ; align names and order before comparing rows."
+            else:
+                reason = "Output types changed; align types before comparing rows."
+            suggestions.append(
+                ValidationSuggestion(
+                    "unmatched_rows",
+                    "Review rows affected by the query change.",
+                    None,
+                    (
+                        "Compare before/after row counts and representative keys.",
+                        "Review unmatched rows after aligning output columns and types.",
+                    ),
+                    reason,
+                )
+            )
+
+    if kinds & {"join", "group_by", "aggregation", "distinct"}:
+        if contract.supported:
+            after_columns = _schema_columns(SqlglotParser().parse(after, dialect), dialect)
+            if after_columns:
+                duplicate_query = after
+                description = "Find duplicate rows in the updated query output."
+                distinct_added = any(
+                    change.category == "distinct"
+                    and change.before == "false"
+                    and change.after == "true"
+                    for change in changes
+                )
+                if distinct_added:
+                    duplicate_query = before
+                    description = "Check duplicates in the input before DISTINCT was added."
+                duplicate_columns = _schema_columns(
+                    SqlglotParser().parse(duplicate_query, dialect), dialect
+                )
+                column_sql = [
+                    f"result.{_quote_identifier(column.name, dialect)}"
+                    for column in duplicate_columns
+                ]
+                grouped = ", ".join(column_sql)
+                duplicate_sql = (
+                    "SELECT "
+                    f"{grouped}, COUNT(*) AS duplicate_count\n"
+                    f"FROM (\n{duplicate_query.strip().rstrip(';')}\n) AS result\n"
+                    f"GROUP BY {grouped}\n"
+                    "HAVING COUNT(*) > 1;"
+                )
+                suggestions.append(
+                    ValidationSuggestion(
+                        "duplicate_rows",
+                        description,
+                        duplicate_sql,
+                        (
+                            "Confirm whether duplicates are valid at the intended output grain.",
+                            "Inspect join keys and grouping columns if duplicates are unexpected.",
+                        ),
+                    )
+                )
+            else:
+                suggestions.append(
+                    ValidationSuggestion(
+                        "duplicate_rows",
+                        "Review duplicate behavior in the updated query.",
+                        None,
+                        ("Check duplicate counts at the intended output grain.",),
+                        "No explicit output columns were found.",
+                    )
+                )
+        else:
+            suggestions.append(
+                ValidationSuggestion(
+                    "duplicate_rows",
+                    "Review duplicate behavior in the updated query.",
+                    None,
+                    ("Check duplicate counts at the intended output grain.",),
+                    contract.unsupported_reason,
+                )
+            )
+    return suggestions
+
+
+def _quote_identifier(name: str, dialect: str | None) -> str:
+    from sqlglot import exp
+
+    return exp.Column(this=exp.to_identifier(name)).sql(dialect=dialect or None)
+
+
+def _identifier_name(node: Any) -> str:
+    from sqlglot import exp
+
+    if isinstance(node, exp.Column):
+        return node.name
+    if isinstance(node, exp.Identifier):
+        return str(node.this)
+    return node.sql()
+
+
+def analyze_migration(
+    sql: str,
+    *,
+    dialect: str | None = None,
+) -> MigrationAnalysisResult:
+    """Analyze common column operations in a multi-statement ALTER TABLE script.
+
+    Only add/drop/rename column, change column type, and nullability changes
+    are interpreted. All other statements and ALTER actions are reported as
+    unsupported instead of being silently ignored.
+    """
+    import sqlglot
+    from sqlglot import exp
+
+    if not sql.strip():
+        raise SQLParseError("SQL input is empty")
+    try:
+        statements = sqlglot.parse(sql, read=dialect or None)
+    except Exception as exc:
+        raise SQLParseError(f"Unable to parse migration SQL: {exc}") from exc
+
+    result = MigrationAnalysisResult()
+    for statement in statements:
+        if statement is None:
+            continue
+        statement_text = statement.sql(dialect=dialect or None)
+        if not isinstance(statement, exp.Alter) or statement.args.get("kind") != "TABLE":
+            result.unsupported.append(
+                UnsupportedMigrationStatement(
+                    statement_text,
+                    "Only ALTER TABLE statements are supported by migration analysis.",
+                )
+            )
+            continue
+        table = statement.this.sql(dialect=dialect or None)
+        actions = statement.args.get("actions") or []
+        if not actions:
+            result.unsupported.append(
+                UnsupportedMigrationStatement(statement_text, "No ALTER TABLE actions found.")
+            )
+            continue
+        for action in actions:
+            operation: MigrationOperation | None = None
+            if isinstance(action, exp.ColumnDef):
+                operation = MigrationOperation(
+                    "column_added",
+                    table,
+                    _identifier_name(action.this),
+                    None,
+                    action.args.get("kind").sql(dialect=dialect or None)
+                    if action.args.get("kind") is not None
+                    else None,
+                    statement_text,
+                    "medium",
+                )
+            elif isinstance(action, exp.Drop) and str(action.args.get("kind")).upper() == "COLUMN":
+                for column in action.args.get("expressions") or action.args.get("tables") or []:
+                    result.operations.append(
+                        MigrationOperation(
+                            "column_removed",
+                            table,
+                            _identifier_name(column),
+                            None,
+                            None,
+                            statement_text,
+                            "high",
+                        )
+                    )
+                continue
+            elif isinstance(action, exp.RenameColumn):
+                operation = MigrationOperation(
+                    "column_renamed",
+                    table,
+                    _identifier_name(action.this),
+                    _identifier_name(action.this),
+                    _identifier_name(action.args["to"]),
+                    statement_text,
+                    "high",
+                )
+            elif isinstance(action, exp.AlterColumn):
+                column = _identifier_name(action.this)
+                data_type = action.args.get("dtype")
+                if data_type is not None:
+                    operation = MigrationOperation(
+                        "column_type_changed",
+                        table,
+                        column,
+                        None,
+                        data_type.sql(dialect=dialect or None),
+                        statement_text,
+                        "medium",
+                    )
+                elif action.args.get("allow_null") is not None:
+                    nullable = bool(action.args["allow_null"])
+                    operation = MigrationOperation(
+                        "nullability_changed",
+                        table,
+                        column,
+                        "NOT NULL" if nullable else "NULL",
+                        "NULL" if nullable else "NOT NULL",
+                        statement_text,
+                        "medium",
+                    )
+            if operation is None:
+                result.unsupported.append(
+                    UnsupportedMigrationStatement(
+                        statement_text,
+                        f"Unsupported ALTER TABLE action: {action.sql(dialect=dialect or None)}",
+                    )
+                )
+            else:
+                result.operations.append(operation)
+    return result