Fix inspect diff totals with separate count query

Author: luisggoncalves

sqlcompare/analysis/utils.py

@@ -55,6 +55,7 @@ def _display(
     *,
     is_stats: bool = False,
     list_columns: bool = False,
+    total_differences: int | None = None,
 ):
     if not columns:
         log.info("No results returned.")
@@ -79,7 +80,8 @@ def _display(
         log.info(format_table(columns, filtered_rows[:limit]))
         return
 
-    log.info(f"📂 Loaded diff data: {len(rows)} total differences")
+    effective_total = total_differences if total_differences is not None else len(rows)
+    log.info(f"📂 Loaded diff data: {effective_total} total differences")
     if list_columns:
         if column_idx is None:
             log.warning("⚠️  Column metadata not available.")
@@ -94,23 +96,24 @@ def _display(
         return
 
     filtered_rows = rows
+    filtered_total = effective_total
     if column and column_idx is not None:
         column_upper = column.upper()
         filtered_rows = [
             row for row in rows if str(row[column_idx]).upper() == column_upper
         ]
+        if total_differences is None:
+            filtered_total = len(filtered_rows)
         if not filtered_rows:
             log.warning(f"⚠️  No differences found for column '{column}'")
             return
-        log.info(
-            f"🔍 Filtered to {len(filtered_rows)} differences for column '{column}'"
-        )
+        log.info(f"🔍 Filtered to {filtered_total} differences for column '{column}'")
 
     display_rows = filtered_rows[:limit]
-    log.info(f"📊 Showing {len(display_rows)} of {len(filtered_rows)} differences:")
+    log.info(f"📊 Showing {len(display_rows)} of {filtered_total} differences:")
     log.info(format_table(columns, display_rows))
-    if len(filtered_rows) > limit:
-        log.info(f"💡 Use --limit {len(filtered_rows)} to see all results")
+    if filtered_total > limit:
+        log.info(f"💡 Use --limit {filtered_total} to see all results")
 
 
 def _column_index(columns: list[str], name: str) -> int | None:

sqlcompare/compare/comparator.py

@@ -181,6 +181,13 @@ def get_diff_query(self, column: str = None, limit: int = None) -> str:
             query += f" LIMIT {limit}"
         return query
 
+    def get_diff_count_query(self, column: str = None) -> str:
+        return (
+            "SELECT COUNT(*) AS diff_count FROM ("
+            + self.get_diff_query(column=column, limit=None)
+            + ") AS diff_rows"
+        )
+
     def get_stats_query(self, column: str = None) -> str:
         cols_to_stat = self.common_cols
         if column:

sqlcompare/inspect.py

@@ -253,12 +253,26 @@ def _inspect_db_run(
         _display(columns, rows, column, limit, diff_id, list_columns=list_columns)
         return
 
-    sql_limit = limit if not list_columns else None
-    rows, columns = db.query(
-        comp.get_diff_query(column=column, limit=sql_limit),
-        include_columns=True,
-    )
-    _display(columns, rows, column, limit, diff_id, list_columns=list_columns)
+    if save_mode == "none":
+        total_differences: int | None = None
+        if not list_columns:
+            count_rows = db.query(comp.get_diff_count_query(column=column))
+            count_value = count_rows[0][0] if count_rows and count_rows[0] else 0
+            total_differences = int(count_value or 0)
+        sql_limit = limit if not list_columns else None
+        rows, columns = db.query(
+            comp.get_diff_query(column=column, limit=sql_limit),
+            include_columns=True,
+        )
+        _display(
+            columns,
+            rows,
+            column,
+            limit,
+            diff_id,
+            list_columns=list_columns,
+            total_differences=total_differences,
+        )
 
     if save_mode != "none":
         _save_inspect_report(

tests/test_cli_analyze.py

@@ -7,6 +7,7 @@
 
 from sqlcompare.cli import app
 from sqlcompare.config import load_test_runs
+from sqlcompare.db import DBConnection
 from tests.cli_helpers import seed_duckdb, set_cli_env
 
 
@@ -82,6 +83,7 @@ def test_analyze_diff_save_modes_and_missing_filters(tmp_path, monkeypatch) -> N
         )
         assert save_summary.exit_code == 0, save_summary.output
         assert "Report saved to:" in save_summary.output
+        assert "Loaded diff data" not in save_summary.output
         summary_path = Path.cwd() / "reports" / "inspect_summary.xlsx"
         assert summary_path.exists()
 
@@ -128,3 +130,44 @@ def test_analyze_diff_save_mode_validation(tmp_path, monkeypatch) -> None:
     )
     assert incompatible.exit_code != 0
     assert "Report export (--save summary/complete)" in incompatible.output
+
+
+def test_analyze_diff_column_limit_uses_total_count(tmp_path, monkeypatch) -> None:
+    db_path = tmp_path / "sqlcompare_many.duckdb"
+    with DBConnection(f"duckdb:///{db_path}") as db:
+        db.execute("CREATE TABLE previous (id INTEGER, value INTEGER)")
+        db.execute("CREATE TABLE current (id INTEGER, value INTEGER)")
+        db.execute("INSERT INTO previous VALUES (1, 10), (2, 20), (3, 30), (4, 40), (5, 50)")
+        db.execute("INSERT INTO current VALUES (1, 11), (2, 21), (3, 31), (4, 41), (5, 51)")
+
+    config_dir = tmp_path / "config"
+    set_cli_env(
+        monkeypatch,
+        config_dir,
+        "duckdb_many",
+        f"duckdb:///{db_path}",
+    )
+    runner = CliRunner()
+    compare_result = runner.invoke(
+        app,
+        [
+            "table",
+            "previous",
+            "current",
+            "id",
+            "--connection",
+            "duckdb_many",
+        ],
+    )
+    assert compare_result.exit_code == 0, compare_result.output
+
+    runs = load_test_runs()
+    diff_id = next(iter(runs.keys()))
+
+    inspect_result = runner.invoke(
+        app, ["inspect", diff_id, "--column", "value", "--limit", "2"]
+    )
+    assert inspect_result.exit_code == 0, inspect_result.output
+    assert "Loaded diff data: 5 total differences" in inspect_result.output
+    assert "Filtered to 5 differences for column 'value'" in inspect_result.output
+    assert "Showing 2 of 5 differences" in inspect_result.output