sql-diff-explainer 0.1.0__tar.gz → 0.1.1__tar.gz

{sql_diff_explainer-0.1.0 → sql_diff_explainer-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sql-diff-explainer
-Version: 0.1.0
+Version: 0.1.1
 Summary: Explain SQL schema and migration differences
 Author: zmodz1010
 License: MIT
@@ -22,6 +22,10 @@ implementation changes. It reports changes to projections, joins, filters,
 grouping, aggregation, ordering, pagination, and `DISTINCT`, with a static
 low/medium/high risk classification.
 
+The current patch release is **0.1.1**. It includes the stable `risk_level`
+compatibility property, semantic join-type pairing, and high-risk classification
+for outer-to-inner join changes.
+
 ## Development
 
 This project uses a `src/` layout and requires Python 3.10 or newer.

{sql_diff_explainer-0.1.0 → sql_diff_explainer-0.1.1}/README.md

@@ -8,6 +8,10 @@ implementation changes. It reports changes to projections, joins, filters,
 grouping, aggregation, ordering, pagination, and `DISTINCT`, with a static
 low/medium/high risk classification.
 
+The current patch release is **0.1.1**. It includes the stable `risk_level`
+compatibility property, semantic join-type pairing, and high-risk classification
+for outer-to-inner join changes.
+
 ## Development
 
 This project uses a `src/` layout and requires Python 3.10 or newer.

{sql_diff_explainer-0.1.0 → sql_diff_explainer-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sql-diff-explainer"
-version = "0.1.0"
+version = "0.1.1"
 description = "Explain SQL schema and migration differences"
 readme = "README.md"
 requires-python = ">=3.10"

{sql_diff_explainer-0.1.0 → sql_diff_explainer-0.1.1}/src/sql_diff_explainer/__init__.py

@@ -23,4 +23,4 @@ __all__ = [
     "explain_diff",
     "explain_sql_change",
 ]
-__version__ = "0.2.0"
+__version__ = "0.1.1"

{sql_diff_explainer-0.1.0 → sql_diff_explainer-0.1.1}/src/sql_diff_explainer/core.py

@@ -81,6 +81,11 @@ class SQLDiffResult:
     risk_reasons: list[str] = field(default_factory=list)
     dialect: str | None = None
 
+    @property
+    def risk_level(self) -> str:
+        """Backward-compatible alias for the overall risk classification."""
+        return self.risk
+
     @property
     def summary(self) -> str:
         if not self.changes:
@@ -91,6 +96,7 @@ class SQLDiffResult:
         return {
             "summary": self.summary,
             "risk": self.risk,
+            "risk_level": self.risk_level,
             "risk_reasons": list(self.risk_reasons),
             "dialect": self.dialect,
             "changes": [change.to_dict() for change in self.changes],
@@ -129,12 +135,24 @@ def _select_expression(tree: Any) -> Any:
     return select
 
 
-def _features(tree: Any, dialect: str | None) -> dict[str, list[str] | str | bool | None]:
+def _join_values(select: Any, dialect: str | None) -> list[tuple[str, str]]:
+    joins = []
+    for join in select.args.get("joins", []):
+        side = (join.args.get("side") or "INNER").upper()
+        target = _sql(join.args.get("this"), dialect) or ""
+        condition = _sql(join.args.get("on"), dialect) or ""
+        joins.append((f"{target} ON {condition}", f"{side} JOIN {target} ON {condition}"))
+    return joins
+
+
+def _features(
+    tree: Any, dialect: str | None
+) -> dict[str, list[str] | list[tuple[str, str]] | str | bool | None]:
     from sqlglot import exp
 
     select = _select_expression(tree)
     projections = [_sql(expression, dialect) or "" for expression in select.expressions]
-    joins = [_sql(join, dialect) or "" for join in select.args.get("joins", [])]
+    joins = _join_values(select, dialect)
     aggregations = sorted(
         {_sql(node, dialect) or "" for node in select.find_all(exp.AggFunc)}
     )
@@ -174,6 +192,10 @@ _RISK = {
     "offset": ("medium", "Changing OFFSET changes which rows are returned."),
     "where": ("medium", "Changing a WHERE predicate changes which rows qualify."),
     "join": ("medium", "Changing a JOIN can change row matching or cardinality."),
+    "join_type": (
+        "high",
+        "Changing an outer JOIN to INNER JOIN can exclude unmatched rows.",
+    ),
 }
 
 
@@ -182,10 +204,11 @@ def _change(
     before: Any,
     after: Any,
     dialect: str | None,
+    risk_key: str | None = None,
 ) -> SQLChange:
     before_text = before if isinstance(before, str) or before is None else _sql(before, dialect)
     after_text = after if isinstance(after, str) or after is None else _sql(after, dialect)
-    key = "removed_" + category if after_text is None else category
+    key = risk_key or ("removed_" + category if after_text is None else category)
     risk = _RISK.get(key, ("medium", f"{category.title()} changed."))[0]
     action = "removed" if after_text is None else "changed" if before_text else "added"
     return SQLChange(
@@ -215,6 +238,48 @@ def _sequence_changes(
     return changes
 
 
+def _join_changes(
+    before: list[tuple[str, str]],
+    after: list[tuple[str, str]],
+    dialect: str | None,
+) -> list[SQLChange]:
+    """Pair joins by target and predicate so join-type changes stay semantic."""
+    before_by_signature = Counter(signature for signature, _ in before)
+    after_by_signature = Counter(signature for signature, _ in after)
+    changes: list[SQLChange] = []
+    for signature in before_by_signature.keys() & after_by_signature.keys():
+        before_rendered = [rendered for item, rendered in before if item == signature]
+        after_rendered = [rendered for item, rendered in after if item == signature]
+        for before_rendered_value, after_rendered_value in zip(
+            before_rendered, after_rendered, strict=True
+        ):
+            if before_rendered_value != after_rendered_value:
+                changes.append(
+                    _change(
+                        "join",
+                        before_rendered_value,
+                        after_rendered_value,
+                        dialect,
+                        risk_key=(
+                            "join_type"
+                            if before_rendered_value.split(" ", 1)[0].upper()
+                            in {"LEFT", "RIGHT", "FULL"}
+                            and after_rendered_value.split(" ", 1)[0].upper() == "INNER"
+                            else None
+                        ),
+                    )
+                )
+    removed = list((before_by_signature - after_by_signature).elements())
+    added = list((after_by_signature - before_by_signature).elements())
+    for signature in removed:
+        rendered = next(rendered for item, rendered in before if item == signature)
+        changes.append(_change("join", rendered, None, dialect))
+    for signature in added:
+        rendered = next(rendered for item, rendered in after if item == signature)
+        changes.append(_change("join", None, rendered, dialect))
+    return changes
+
+
 def explain_sql_change(
     before: str,
     after: str,
@@ -230,7 +295,13 @@ def explain_sql_change(
     after_features = _features(after_tree, dialect)
     changes: list[SQLChange] = []
 
-    sequence_categories = ("select", "joins", "group_by", "aggregation", "order_by")
+    before_joins = before_features["joins"]
+    after_joins = after_features["joins"]
+    if not isinstance(before_joins, list) or not isinstance(after_joins, list):
+        raise UnsupportedSQL("Unable to compare joins")
+    changes.extend(_join_changes(before_joins, after_joins, dialect))
+
+    sequence_categories = ("select", "group_by", "aggregation", "order_by")
     for category in sequence_categories:
         before_values = before_features[category]
         after_values = after_features[category]
@@ -256,8 +327,19 @@ def explain_sql_change(
     for change in changes:
         if severity[change.risk] > severity[overall]:
             overall = change.risk
+        join_type_change = (
+            change.category == "join"
+            and change.before is not None
+            and change.after is not None
+            and change.before.split(" ", 1)[0].upper() in {"LEFT", "RIGHT", "FULL"}
+            and change.after.split(" ", 1)[0].upper() == "INNER"
+        )
         reason = _RISK.get(
-            ("removed_" + change.category if change.after is None else change.category),
+            (
+                "join_type"
+                if join_type_change
+                else ("removed_" + change.category if change.after is None else change.category)
+            ),
             ("medium", ""),
         )[1]
         if reason and reason not in reasons:

{sql_diff_explainer-0.1.0 → sql_diff_explainer-0.1.1}/tests/test_core.py

@@ -27,6 +27,7 @@ def test_explain_sql_change_detects_core_query_features() -> None:
 
     assert {"select", "join", "aggregation", "distinct", "limit", "offset"}.issubset(categories)
     assert result.risk == "high"
+    assert result.risk_level == "high"
     assert result.to_dict()["changes"]
 
 
@@ -62,3 +63,17 @@ def test_identical_queries_have_no_changes() -> None:
 
     assert result.changes == []
     assert result.risk == "low"
+
+
+def test_join_type_change_is_one_semantic_change() -> None:
+    result = explain_sql_change(
+        "SELECT users.id FROM users LEFT JOIN orders ON users.id = orders.user_id",
+        "SELECT users.id FROM users INNER JOIN orders ON users.id = orders.user_id",
+    )
+
+    assert len(result.changes) == 1
+    assert result.changes[0].category == "join"
+    assert result.changes[0].risk == "high"
+    assert result.risk_level == "high"
+    assert result.changes[0].before.startswith("LEFT JOIN")
+    assert result.changes[0].after.startswith("INNER JOIN")