Use pandas formatting for tables

Author: luisggoncalves

pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
   "rich>=14.2.0",
   "SQLAlchemy>=2.0.0",
   "numpy!=2.4.0",
-  "tabulate>=0.9.0",
+  "pandas>=2.0.0",
   "typer>=0.21.0",
   "openpyxl>=3.1.0",
   "duckdb>=1.0.0",

sqlcompare/analysis/utils.py

@@ -77,7 +77,15 @@ def _display(
             if not filtered_rows:
                 log.info(f"❌ No statistics found for column containing '{column}'")
                 return
-        log.info(format_table(columns, filtered_rows[:limit]))
+        display_rows = filtered_rows[:limit]
+        log.info(
+            format_table(
+                columns,
+                display_rows,
+                max_rows=len(display_rows),
+                max_cols=len(columns),
+            )
+        )
         return
 
     effective_total = total_differences if total_differences is not None else len(rows)

sqlcompare/query.py

@@ -7,6 +7,7 @@
 from sqlcompare.db import DBConnection
 from sqlcompare.helpers import resolve_output_filename
 from sqlcompare.log import log
+from sqlcompare.utils.format import format_table
 
 
 def query(q: str, connection: str | None, output: str) -> None:
@@ -35,9 +36,7 @@ def query(q: str, connection: str | None, output: str) -> None:
 
     if output == "terminal":
         if rows:
-            from tabulate import tabulate
-
-            print(tabulate(rows, headers=columns, tablefmt="pretty"))
+            print(format_table(columns, rows))
             print(f"\nTotal rows: {len(rows)}")
         else:
             print("Query executed successfully. No rows returned.")

sqlcompare/utils/format.py

@@ -1,82 +1,35 @@
 from __future__ import annotations
 
-from typing import Iterable, Sequence, Any
-from tabulate import tabulate
+from typing import Any
 
-
-def _trim_cell(x: Any, max_width: int | None) -> Any:
-    """Truncate long cell strings with … (does not wrap)."""
-    if max_width is None:
-        return x
-    s = "" if x is None else str(x)
-    if len(s) <= max_width:
-        return s
-    if max_width <= 1:
-        return "…"
-    return s[: max_width - 1] + "…"
+import pandas as pd
 
 
 def format_table(
     columns: list[str],
     rows: list[tuple],
     *,
-    tablefmt: str = "pretty",
     max_rows: int = 20,
     max_cols: int = 12,
     max_cell_width: int | None = 60,
-    **tabulate_kwargs,
 ) -> str:
-    """
-    pandas-like summary output for tabulate:
-      - If too many columns: show left + '…' + right (inserts an ellipsis column)
-      - If too many rows: show head + ellipsis row + tail
-    """
-    n_cols = len(columns)
-    if n_cols == 0:
-        return tabulate([], headers=[], tablefmt="pretty", **tabulate_kwargs)
-
-    # ---- column trimming ----
-    use_col_ellipsis = n_cols > max_cols and max_cols >= 2
-    if use_col_ellipsis:
-        left = max_cols // 2
-        right = max_cols - left
-        left_idx = list(range(left))
-        right_idx = list(range(n_cols - right, n_cols))
-        keep_idx = left_idx + right_idx
-
-        out_columns = columns[:left] + ["…"] + columns[-right:]
+    """Render a dataframe-like table using pandas output formatting."""
+    if not columns:
+        return ""
 
-        out_rows = []
-        for r in rows:
-            r_list = list(r)
-            kept = (
-                [r_list[i] for i in keep_idx[:left]]
-                + ["…"]
-                + [r_list[i] for i in keep_idx[left:]]
-            )
-            out_rows.append(tuple(kept))
-    else:
-        out_columns = (
-            columns[:max_cols] if (n_cols > max_cols and max_cols >= 1) else columns
-        )
-        keep_idx = list(range(len(out_columns)))
-        out_rows = [tuple(r[i] for i in keep_idx) for r in rows]
+    df = pd.DataFrame(list(rows), columns=columns)
 
-    # ---- row trimming ----
-    n_rows = len(out_rows)
-    use_row_ellipsis = n_rows > max_rows and max_rows >= 2
-    if use_row_ellipsis:
-        top = max_rows // 2
-        bottom = max_rows - top
-        head = out_rows[:top]
-        tail = out_rows[-bottom:]
-        ellipsis_row = tuple("…" for _ in out_columns)
-        out_rows = head + [ellipsis_row] + tail
-    else:
-        out_rows = out_rows[:max_rows]
+    display_max_rows = None if max_rows is None or max_rows <= 0 else max_rows
+    display_max_cols = None if max_cols is None or max_cols <= 0 else max_cols
 
-    # ---- cell trimming ----
+    option_kwargs: dict[str, Any] = {
+        "display.max_rows": display_max_rows,
+        "display.max_columns": display_max_cols,
+        "display.width": 0,
+        "display.expand_frame_repr": False,
+    }
     if max_cell_width is not None:
-        out_rows = [tuple(_trim_cell(v, max_cell_width) for v in r) for r in out_rows]
+        option_kwargs["display.max_colwidth"] = max_cell_width
 
-    return tabulate(out_rows, headers=out_columns, tablefmt=tablefmt, **tabulate_kwargs)
+    with pd.option_context(*sum(option_kwargs.items(), ())):
+        return df.to_string(index=False)

sqlcompare/utils/test_types/stats.py

@@ -97,13 +97,20 @@ def compare_table_stats(table1: str, table2: str, connection: str | None) -> Non
         "ROWS_DIFF",
         "NULLS_DIFF",
         "DISTINCT_DIFF",
+        "STATUS_PCT",
     ]
     rows = []
+    row_base = max(prev_count, new_count, 1)
     for key in common_keys:
         prev_nulls = prev_stats.get(key, {}).get("null_count", 0)
         new_nulls = new_stats.get(key, {}).get("null_count", 0)
         prev_distinct = prev_stats.get(key, {}).get("distinct_count", 0)
         new_distinct = new_stats.get(key, {}).get("distinct_count", 0)
+        distinct_base = max(prev_distinct, new_distinct, 1)
+        row_sim = 1 - (abs(new_count - prev_count) / row_base)
+        null_sim = 1 - (abs(new_nulls - prev_nulls) / row_base)
+        distinct_sim = 1 - (abs(new_distinct - prev_distinct) / distinct_base)
+        status_pct = max(0.0, min(100.0, (row_sim + null_sim + distinct_sim) / 3 * 100))
         rows.append(
             (
                 prev_map[key],
@@ -116,8 +123,18 @@ def compare_table_stats(table1: str, table2: str, connection: str | None) -> Non
                 new_count - prev_count,
                 new_nulls - prev_nulls,
                 new_distinct - prev_distinct,
+                round(status_pct, 2),
             )
         )
 
+    rows.sort(key=lambda row: row[-1])
+
     log.info("📊 Table statistics comparison:")
-    log.info(format_table(output_columns, rows))
+    log.info(
+        format_table(
+            output_columns,
+            rows,
+            max_rows=len(rows),
+            max_cols=len(output_columns),
+        )
+    )

tests/test_stats_comparison.py

@@ -35,13 +35,16 @@ def test_table_command_with_stats(tmp_path, monkeypatch) -> None:
     assert result.exit_code == 0, result.output
     assert "Table statistics comparison" in result.output
 
-    lines = [line for line in result.output.splitlines() if line.startswith("|")]
+    lines = [line for line in result.output.splitlines() if line.strip()]
     assert lines, result.output
 
     header = []
-    rows = {}
+    rows: dict[str, list[str]] = {}
     for line in lines:
-        cells = [cell.strip() for cell in line.strip().strip("|").split("|")]
+        stripped = line.strip()
+        if not stripped:
+            continue
+        cells = stripped.split()
         if not cells:
             continue
         if cells[0] == "COLUMN_NAME":
@@ -60,12 +63,24 @@ def test_table_command_with_stats(tmp_path, monkeypatch) -> None:
         "ROWS_DIFF",
         "NULLS_DIFF",
         "DISTINCT_DIFF",
+        "STATUS_PCT",
     ]
     assert header == expected_header
 
     for col_name in ("id", "name", "value"):
         assert col_name in rows, result.output
-        assert rows[col_name][1:] == ["2", "2", "0", "0", "2", "2", "0", "0", "0"]
+        assert rows[col_name][1:] == [
+            "2",
+            "2",
+            "0",
+            "0",
+            "2",
+            "2",
+            "0",
+            "0",
+            "0",
+            "100.0",
+        ]
 
 
 def test_table_command_with_stats_from_files() -> None: