Support SQL inputs for stats

Author: luisggoncalves

sqlcompare/run_cmd.py

@@ -23,10 +23,10 @@ def _resolve_connection(connection: str | None) -> str:
 
 
 def run_cmd(
-    table1: str = typer.Argument(
+    previous: str = typer.Argument(
         ..., help="Previous table name, CSV/XLSX file path, or SQL"
     ),
-    table2: str = typer.Argument(
+    current: str = typer.Argument(
         ..., help="Current table name, CSV/XLSX file path, or SQL"
     ),
     index: str = typer.Argument(
@@ -70,8 +70,8 @@ def run_cmd(
     """
     schema = schema or get_default_schema()
 
-    prev_spec = detect_input(table1)
-    new_spec = detect_input(table2)
+    prev_spec = detect_input(previous)
+    new_spec = detect_input(current)
 
     if prev_spec.kind == "file" or new_spec.kind == "file":
         if prev_spec.kind != "file" or new_spec.kind != "file":
@@ -123,8 +123,8 @@ def run_cmd(
         return
 
     compare_table(
-        table1,
-        table2,
+        previous,
+        current,
         index,
         connection,
         schema,

sqlcompare/stats.py

@@ -6,8 +6,10 @@
 
 
 def stats_cmd(
-    table1: str = typer.Argument(..., help="Previous table name or CSV/XLSX file path"),
-    table2: str = typer.Argument(..., help="Current table name or CSV/XLSX file path"),
+    previous: str = typer.Argument(
+        ..., help="Previous table name or CSV/XLSX file path"
+    ),
+    current: str = typer.Argument(..., help="Current table name or CSV/XLSX file path"),
     connection: str | None = typer.Option(
         None, "--connection", "-c", help="Database connector name"
     ),
@@ -42,4 +44,4 @@ def stats_cmd(
         PREV_DISTINCT, NEW_DISTINCT: Unique value counts
         *_DIFF: Calculated differences
     """
-    compare_table_stats(table1, table2, connection)
+    compare_table_stats(previous, current, connection)

sqlcompare/utils/test_types/stats.py

@@ -1,7 +1,11 @@
+import os
+import uuid
 from pathlib import Path
 
+from sqlcompare.config import get_default_schema
 from sqlcompare.db import DBConnection
 from sqlcompare.log import log
+from sqlcompare.helpers import create_table_from_select, detect_input, ensure_schema
 from sqlcompare.utils.format import format_table
 
 
@@ -51,23 +55,65 @@ def _is_supported_file(path: Path) -> bool:
     return path.exists() and path.suffix.lower() in (".csv", ".xlsx")
 
 
+def _resolve_connection(connection: str | None) -> str:
+    if connection:
+        return connection
+    default_conn = os.getenv("SQLCOMPARE_CONN_DEFAULT") or os.getenv("DTK_CONN_DEFAULT")
+    if not default_conn:
+        raise ValueError(
+            "No connection specified. Use --connection or set SQLCOMPARE_CONN_DEFAULT."
+        )
+    return default_conn
+
+
 def compare_table_stats(table1: str, table2: str, connection: str | None) -> None:
     table1_name = table1
     table2_name = table2
     connection_id = connection
 
-    if connection is None:
-        path1 = Path(table1).expanduser()
-        path2 = Path(table2).expanduser()
-        if _is_supported_file(path1) and _is_supported_file(path2):
+    spec_prev = detect_input(table1)
+    spec_new = detect_input(table2)
+
+    if spec_prev.kind == "file" or spec_new.kind == "file":
+        if spec_prev.kind != "file" or spec_new.kind != "file":
+            raise ValueError(
+                "Both table arguments must be file paths when using CSV/XLSX inputs."
+            )
+        if connection is None:
             connection_id = "duckdb:///:memory:"
-            table1_name = path1.stem
-            table2_name = path2.stem
+        table1_name = Path(spec_prev.value).stem
+        table2_name = Path(spec_new.value).stem
+    elif spec_prev.kind == "sql" or spec_new.kind == "sql":
+        connection_id = _resolve_connection(connection)
+        schema = get_default_schema()
+        schema_prefix = f"{schema}." if schema else ""
+        suffix = uuid.uuid4().hex[:8]
+        table1_name = (
+            spec_prev.value
+            if spec_prev.kind == "table"
+            else f"{schema_prefix}sqlcompare_stats_{suffix}_previous"
+        )
+        table2_name = (
+            spec_new.value
+            if spec_new.kind == "table"
+            else f"{schema_prefix}sqlcompare_stats_{suffix}_new"
+        )
+    else:
+        table1_name = spec_prev.value
+        table2_name = spec_new.value
 
     with DBConnection(connection_id) as db:
-        if connection is None and connection_id == "duckdb:///:memory:":
-            db.create_table_from_file(table1_name, table1)
-            db.create_table_from_file(table2_name, table2)
+        if spec_prev.kind == "file" and spec_new.kind == "file":
+            if connection is None and connection_id == "duckdb:///:memory:":
+                db.create_table_from_file(table1_name, spec_prev.value)
+                db.create_table_from_file(table2_name, spec_new.value)
+        if spec_prev.kind == "sql" or spec_new.kind == "sql":
+            schema = get_default_schema()
+            ensure_schema(db, schema)
+            if spec_prev.kind == "sql":
+                create_table_from_select(db, table1_name, spec_prev.value)
+            if spec_new.kind == "sql":
+                create_table_from_select(db, table2_name, spec_new.value)
 
         cols_prev = db.get_table_columns(table1_name)
         cols_new = db.get_table_columns(table2_name)

tests/test_stats_comparison.py

@@ -100,3 +100,81 @@ def test_table_command_with_stats_from_files() -> None:
 
     assert result.exit_code == 0, result.output
     assert "Table statistics comparison" in result.output
+
+
+def test_stats_command_with_inline_sql(tmp_path, monkeypatch) -> None:
+    db_path = tmp_path / "sqlcompare.duckdb"
+    seed_duckdb(db_path)
+    config_dir = tmp_path / "config"
+    set_cli_env(
+        monkeypatch,
+        config_dir,
+        "duckdb_test",
+        f"duckdb:///{db_path}",
+        schema="analysis_schema",
+    )
+    runner = CliRunner()
+
+    result = runner.invoke(
+        app,
+        [
+            "stats",
+            "SELECT * FROM previous",
+            "SELECT * FROM current",
+            "--connection",
+            "duckdb_test",
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert "Table statistics comparison" in result.output
+
+
+def test_stats_command_with_sql_files(tmp_path, monkeypatch) -> None:
+    db_path = tmp_path / "sqlcompare.duckdb"
+    seed_duckdb(db_path)
+    config_dir = tmp_path / "config"
+    set_cli_env(
+        monkeypatch,
+        config_dir,
+        "duckdb_test",
+        f"duckdb:///{db_path}",
+        schema="analysis_schema",
+    )
+    prev_sql = tmp_path / "previous.sql"
+    new_sql = tmp_path / "current.sql"
+    prev_sql.write_text("SELECT * FROM previous", encoding="utf-8")
+    new_sql.write_text("SELECT * FROM current", encoding="utf-8")
+    runner = CliRunner()
+
+    result = runner.invoke(
+        app,
+        [
+            "stats",
+            str(prev_sql),
+            str(new_sql),
+            "--connection",
+            "duckdb_test",
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert "Table statistics comparison" in result.output
+
+
+def test_stats_command_sql_requires_connection(tmp_path, monkeypatch) -> None:
+    monkeypatch.delenv("SQLCOMPARE_CONN_DEFAULT", raising=False)
+    monkeypatch.delenv("DTK_CONN_DEFAULT", raising=False)
+    runner = CliRunner()
+
+    result = runner.invoke(
+        app,
+        [
+            "stats",
+            "SELECT * FROM previous",
+            "SELECT * FROM current",
+        ],
+    )
+
+    assert result.exit_code != 0
+    assert "No connection specified" in str(result.exception)