Fix diff/list edge cases and add resolver fallback tests

Author: luisggoncalves

sqlcompare/compare/comparator.py

@@ -163,19 +163,35 @@ def get_column_diff_query(self, column: str) -> str:
             f"FROM {self.tables['join']} WHERE {cond}"
         )
 
+    def _empty_diff_query(self) -> str:
+        idx_expr = ", ".join(
+            [f'CAST(NULL AS VARCHAR) AS "{c}"' for c in self.index_cols]
+        )
+        select_parts = [idx_expr] if idx_expr else []
+        select_parts.extend(
+            [
+                'CAST(NULL AS VARCHAR) AS "COLUMN"',
+                'CAST(NULL AS VARCHAR) AS "BEFORE"',
+                'CAST(NULL AS VARCHAR) AS "CURRENT"',
+            ]
+        )
+        return "SELECT " + ", ".join(select_parts) + " WHERE 1=0"
+
     def get_diff_query(self, column: str = None, limit: int = None) -> str:
         if column:
             # Case-insensitive match for the specific column
             match = next(
                 (c for c in self.common_cols if c.upper() == column.upper()), None
             )
             if not match:
-                # Still return an empty result if column not found in common cols
-                return "SELECT NULL AS ID, NULL AS COLUMN, NULL AS BEFORE, NULL AS CURRENT WHERE 1=0"
+                return self._empty_diff_query()
             query = self.get_column_diff_query(match)
         else:
-            queries = [self.get_column_diff_query(c) for c in self.common_cols]
-            query = " UNION ALL ".join(queries)
+            if not self.common_cols:
+                query = self._empty_diff_query()
+            else:
+                queries = [self.get_column_diff_query(c) for c in self.common_cols]
+                query = " UNION ALL ".join(queries)
 
         if limit:
             query += f" LIMIT {limit}"

sqlcompare/db/connection.py

@@ -38,7 +38,7 @@ class DBConnection:
         1. Use default connection if conn_id is None (SQLCOMPARE_CONN_DEFAULT, DTK_CONN_DEFAULT)
         2. Direct URL (if contains "://")
         3. Environment variables: SQLCOMPARE_CONN_<NAME>, DTK_CONN_<NAME>
-        4. YAML files: ~/.sqlcompare/connections.yml, ~/.dtk/connections.yml
+        4. YAML files: ~/.config/sqlcompare/connections.yaml/.yml, ~/.dtk/connections.yml
     """
 
     conn_id: str | None = None

sqlcompare/db/resolver.py

@@ -83,14 +83,37 @@ def _build_not_found_error(conn_id: str, normalized_name: str) -> str:
 
     message_parts.append("")
     message_parts.append("Searched YAML files:")
-    for yaml_file in LIBRARY_CONNECTIONS:
+    for yaml_file in _iter_yaml_candidates(LIBRARY_CONNECTIONS):
         expanded = Path(yaml_file).expanduser()
         exists = " (found)" if expanded.exists() else " (not found)"
         message_parts.append(f"  - {yaml_file}{exists}")
 
     return "\n".join(message_parts)
 
 
+def _iter_yaml_candidates(paths: list[str]) -> list[str]:
+    """Return configured YAML paths plus sibling .yml/.yaml fallbacks."""
+    candidates: list[str] = []
+    seen: set[str] = set()
+
+    for raw_path in paths:
+        expanded = str(Path(raw_path).expanduser())
+        base = Path(expanded)
+        options = [expanded]
+        if base.suffix.lower() == ".yml":
+            options.append(str(base.with_suffix(".yaml")))
+        elif base.suffix.lower() == ".yaml":
+            options.append(str(base.with_suffix(".yml")))
+
+        for candidate in options:
+            if candidate in seen:
+                continue
+            seen.add(candidate)
+            candidates.append(candidate)
+
+    return candidates
+
+
 def resolve_connection_url(conn_id_or_url: str | None) -> str:
     """
     Resolve a connection ID to a database URL.
@@ -127,7 +150,7 @@ def resolve_connection_url(conn_id_or_url: str | None) -> str:
         url = resolve_connection_url("/path/to/data.csv")
 
         # YAML file lookup (if not in env)
-        # Searches ~/.sqlcompare/connections.yml, then ~/.dtk/connections.yml
+        # Searches ~/.config/sqlcompare/connections.yaml/.yml, then ~/.dtk/connections.yml
     """
     # Step 0: Use default connection if None (search all DEFAULT_CONN_IDS)
     if conn_id_or_url is None:
@@ -161,8 +184,8 @@ def resolve_connection_url(conn_id_or_url: str | None) -> str:
         if url_str:
             return url_str
 
-    # Step 4: Search ALL YAML files (in order)
-    for yaml_path in LIBRARY_CONNECTIONS:
+    # Step 4: Search ALL YAML files (in order), with .yml/.yaml fallback for each path
+    for yaml_path in _iter_yaml_candidates(LIBRARY_CONNECTIONS):
         connections = _load_connections_from_yaml(yaml_path)
 
         # YAML uses raw conn_id (not normalized) for matching

sqlcompare/list_diffs.py

@@ -39,9 +39,10 @@ def list_diffs(pattern: str | None, test: str | None) -> None:
     for run_id, run in runs.items():
         if pattern and pattern.lower() not in run_id.lower():
             continue
-        if test and test.lower() not in run.get("conn", "").lower():
+        conn_name = run.get("conn") or ""
+        if test and test.lower() not in conn_name.lower():
             continue
-        filtered_matches.append((run_id, run.get("conn", "db"), 0, datetime.now()))
+        filtered_matches.append((run_id, conn_name or "db", 0, datetime.now()))
 
     if not filtered_matches:
         log.info("📭 No diff data found matching your criteria.")

tests/test_cli_analyze.py

@@ -179,3 +179,38 @@ def test_analyze_diff_column_limit_uses_total_count(tmp_path, monkeypatch) -> No
     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
+
+
+def test_analyze_diff_with_only_index_columns(tmp_path, monkeypatch) -> None:
+    db_path = tmp_path / "sqlcompare_index_only.duckdb"
+    with DBConnection(f"duckdb:///{db_path}") as db:
+        db.execute("CREATE TABLE previous (id INTEGER)")
+        db.execute("CREATE TABLE current (id INTEGER)")
+        db.execute("INSERT INTO previous VALUES (1), (2)")
+        db.execute("INSERT INTO current VALUES (1), (3)")
+
+    config_dir = tmp_path / "config"
+    set_cli_env(
+        monkeypatch,
+        config_dir,
+        "duckdb_index_only",
+        f"duckdb:///{db_path}",
+    )
+    runner = CliRunner()
+    compare_result = runner.invoke(
+        app,
+        [
+            "table",
+            "previous",
+            "current",
+            "id",
+            "--connection",
+            "duckdb_index_only",
+        ],
+    )
+    assert compare_result.exit_code == 0, compare_result.output
+
+    diff_id = next(iter(load_test_runs().keys()))
+    inspect_result = runner.invoke(app, ["inspect", diff_id])
+    assert inspect_result.exit_code == 0, inspect_result.output
+    assert "Loaded diff data: 0 total differences" in inspect_result.output

tests/test_cli_list_diffs.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import yaml
 from typer.testing import CliRunner
 
 from sqlcompare.cli import app
@@ -46,3 +47,28 @@ def test_list_diffs_with_filters(tmp_path, monkeypatch) -> None:
     no_match = runner.invoke(app, ["list-diffs", "no_such_diff"])
     assert no_match.exit_code == 0, no_match.output
     assert "No diff data found" in no_match.output
+
+
+def test_list_diffs_filter_handles_none_conn(tmp_path, monkeypatch) -> None:
+    config_dir = tmp_path / "config"
+    runs_dir = config_dir / "runs"
+    runs_dir.mkdir(parents=True, exist_ok=True)
+    (runs_dir / "manual_run.yaml").write_text(
+        yaml.safe_dump(
+            {
+                "tables": {"previous": "p", "new": "n", "join": "j"},
+                "index_cols": ["id"],
+                "cols_prev": ["id"],
+                "cols_new": ["id"],
+                "common_cols": [],
+                "conn": None,
+            }
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setenv("SQLCOMPARE_CONFIG_DIR", str(config_dir))
+
+    runner = CliRunner()
+    result = runner.invoke(app, ["list-diffs", "--test", "duckdb"])
+    assert result.exit_code == 0, result.output
+    assert "No diff data found" in result.output

tests/test_db_resolver.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import yaml
+
+from sqlcompare.db import resolver
+
+
+def test_resolve_connection_url_falls_back_from_yaml_to_yml(tmp_path, monkeypatch) -> None:
+    configured_path = tmp_path / "connections.yaml"
+    fallback_path = tmp_path / "connections.yml"
+    fallback_path.write_text(
+        yaml.safe_dump(
+            {
+                "yaml_fallback_conn": {
+                    "drivername": "sqlite",
+                    "database": ":memory:",
+                }
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    monkeypatch.setattr(resolver, "ENV_PREFIXS", [])
+    monkeypatch.setattr(resolver, "LIBRARY_CONNECTIONS", [str(configured_path)])
+
+    resolved = resolver.resolve_connection_url("yaml_fallback_conn")
+    assert resolved == "sqlite:///:memory:"
+
+
+def test_resolve_connection_url_falls_back_from_yml_to_yaml(tmp_path, monkeypatch) -> None:
+    configured_path = tmp_path / "connections.yml"
+    fallback_path = tmp_path / "connections.yaml"
+    fallback_path.write_text(
+        yaml.safe_dump(
+            {
+                "yml_fallback_conn": {
+                    "drivername": "sqlite",
+                    "database": ":memory:",
+                }
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    monkeypatch.setattr(resolver, "ENV_PREFIXS", [])
+    monkeypatch.setattr(resolver, "LIBRARY_CONNECTIONS", [str(configured_path)])
+
+    resolved = resolver.resolve_connection_url("yml_fallback_conn")
+    assert resolved == "sqlite:///:memory:"