Add comprehensive tests and fix rewritten queries to SQL format

Changes:
- Added 9 comprehensive tests for model generation functionality
- Fixed rewritten queries to output SQL format instead of Python code
- Rewritten queries now use semantic layer syntax (model.dimension, model.metric)
- Fixed COUNT(DISTINCT col) parsing (use expressions[0] not .this)
- Write rewritten queries as .sql files not .py files

Tests cover:
- Generating models from multiple query types
- COUNT(DISTINCT) metric generation
- Duplicate metric handling
- Rewritten query generation with filters
- Skipping unparseable queries
- Writing models and queries to disk
- Multiple aggregations on same column

All 16 coverage analyzer tests passing.

Author: nicosuave

sidemantic/core/coverage_analyzer.py

@@ -194,9 +194,10 @@ def _extract_aggregations(self, parsed: exp.Expression, analysis: QueryAnalysis)
                     analysis.aggregations.append((agg_name, "*", ""))
                 elif isinstance(col, exp.Distinct):
                     # COUNT(DISTINCT col) - handle specially
-                    if isinstance(col.this, exp.Column):
-                        col_name = col.this.name
-                        table_name = col.this.table if col.this.table else None
+                    if col.expressions and isinstance(col.expressions[0], exp.Column):
+                        distinct_col = col.expressions[0]
+                        col_name = distinct_col.name
+                        table_name = distinct_col.table if distinct_col.table else None
                         analysis.aggregations.append(("count_distinct", col_name, table_name or ""))
 
     def _extract_group_by(self, parsed: exp.Expression, analysis: QueryAnalysis) -> None:
@@ -591,29 +592,30 @@ def write_model_files(self, models: dict[str, dict], output_dir: str) -> None:
             print(f"Generated: {file_path}")
 
     def generate_rewritten_queries(self, report: CoverageReport) -> dict[str, str]:
-        """Generate rewritten queries using semantic layer.
+        """Generate rewritten SQL queries using semantic layer syntax.
 
         Args:
             report: Coverage report
 
         Returns:
-            Dictionary mapping query names to rewritten Python code
+            Dictionary mapping query names to rewritten SQL
         """
         rewritten = {}
 
         for i, analysis in enumerate(report.query_analyses, 1):
-            if analysis.parse_error or not analysis.can_rewrite:
+            if analysis.parse_error:
                 continue
 
-            # Build dimension references
-            dimensions = []
+            # Build SELECT clause with model.dimension and model.metric format
+            select_parts = []
+
+            # Add dimensions
             for table_name, col_name in analysis.group_by_columns:
                 if not table_name and len(analysis.tables) == 1:
                     table_name = list(analysis.tables)[0]
-                dimensions.append(f"{table_name}.{col_name}")
+                select_parts.append(f"{table_name}.{col_name}")
 
-            # Build metric references
-            metrics = []
+            # Add metrics
             for agg_type, col_name, table_name in analysis.aggregations:
                 if not table_name and len(analysis.tables) == 1:
                     table_name = list(analysis.tables)[0]
@@ -626,32 +628,32 @@ def generate_rewritten_queries(self, report: CoverageReport) -> dict[str, str]:
                 else:
                     metric_name = f"{agg_type}_{col_name}"
 
-                metrics.append(f"{table_name}.{metric_name}")
+                select_parts.append(f"{table_name}.{metric_name}")
+
+            if not select_parts:
+                continue
+
+            # Build SQL query
+            sql = "SELECT\n"
+            sql += "    " + ",\n    ".join(select_parts)
+
+            # Determine main table
+            if len(analysis.tables) == 1:
+                main_table = list(analysis.tables)[0]
+                sql += f"\nFROM {main_table}"
 
-            # Build filter clause
-            where_clause = None
+            # Add WHERE clause
             if analysis.filters:
                 where_clause = analysis.filters[0]
-
-            # Generate Python code
-            parts = []
-            if dimensions:
-                parts.append(f"    dimensions={dimensions}")
-            if metrics:
-                parts.append(f"    metrics={metrics}")
-            if where_clause:
-                parts.append(f'    where="{where_clause}"')
+                sql += f"\nWHERE {where_clause}"
 
             query_name = f"query_{i}"
-            code = f"# Original query:\n# {analysis.query.strip()}\n\n"
-            code += "result = layer.query(\n" + ",\n".join(parts) + "\n)"
-
-            rewritten[query_name] = code
+            rewritten[query_name] = sql
 
         return rewritten
 
     def write_rewritten_queries(self, queries: dict[str, str], output_dir: str) -> None:
-        """Write rewritten queries to Python files.
+        """Write rewritten queries to SQL files.
 
         Args:
             queries: Dictionary of rewritten queries from generate_rewritten_queries()
@@ -662,10 +664,10 @@ def write_rewritten_queries(self, queries: dict[str, str], output_dir: str) -> N
         output_path = Path(output_dir)
         output_path.mkdir(parents=True, exist_ok=True)
 
-        for query_name, code in queries.items():
-            file_path = output_path / f"{query_name}.py"
+        for query_name, sql in queries.items():
+            file_path = output_path / f"{query_name}.sql"
             with open(file_path, "w") as f:
-                f.write(code)
+                f.write(sql)
                 f.write("\n")
 
             print(f"Generated: {file_path}")

tests/test_coverage_analyzer_generation.py

@@ -0,0 +1,266 @@
+"""Tests for coverage analyzer model and query generation."""
+
+from sidemantic import SemanticLayer
+from sidemantic.core.coverage_analyzer import CoverageAnalyzer
+
+
+def test_generate_models_from_queries():
+    """Test generating model definitions from queries."""
+    layer = SemanticLayer(auto_register=False)
+    analyzer = CoverageAnalyzer(layer)
+
+    queries = [
+        """
+        SELECT status, region, SUM(amount), COUNT(*)
+        FROM orders
+        GROUP BY status, region
+        """,
+        """
+        SELECT category, AVG(price), COUNT(DISTINCT product_id)
+        FROM products
+        GROUP BY category
+        """,
+    ]
+
+    report = analyzer.analyze_queries(queries)
+    models = analyzer.generate_models(report)
+
+    # Should generate 2 models
+    assert len(models) == 2
+    assert "orders" in models
+    assert "products" in models
+
+    # Check orders model
+    orders = models["orders"]
+    assert orders["model"]["name"] == "orders"
+    assert orders["model"]["table"] == "orders"
+
+    # Check orders dimensions
+    assert len(orders["dimensions"]) == 2
+    dim_names = {d["name"] for d in orders["dimensions"]}
+    assert "status" in dim_names
+    assert "region" in dim_names
+
+    # Check orders metrics
+    assert len(orders["metrics"]) == 2
+    metric_names = {m["name"] for m in orders["metrics"]}
+    assert "sum_amount" in metric_names
+    assert "count" in metric_names
+
+    # Check products model
+    products = models["products"]
+    assert products["model"]["name"] == "products"
+
+    # Check products dimensions
+    assert len(products["dimensions"]) == 1
+    assert products["dimensions"][0]["name"] == "category"
+
+    # Check products metrics
+    assert len(products["metrics"]) == 2
+    metric_names = {m["name"] for m in products["metrics"]}
+    assert "avg_price" in metric_names
+    assert "product_id_count" in metric_names
+
+
+def test_generate_models_count_distinct():
+    """Test COUNT(DISTINCT col) generates correct metric."""
+    layer = SemanticLayer(auto_register=False)
+    analyzer = CoverageAnalyzer(layer)
+
+    queries = [
+        """
+        SELECT status, COUNT(DISTINCT customer_id)
+        FROM orders
+        GROUP BY status
+        """
+    ]
+
+    report = analyzer.analyze_queries(queries)
+    models = analyzer.generate_models(report)
+
+    orders = models["orders"]
+    metrics = {m["name"]: m for m in orders["metrics"]}
+
+    assert "customer_id_count" in metrics
+    assert metrics["customer_id_count"]["agg"] == "count_distinct"
+    assert metrics["customer_id_count"]["sql"] == "customer_id"
+
+
+def test_generate_models_no_duplicate_metrics():
+    """Test that duplicate metrics are not generated."""
+    layer = SemanticLayer(auto_register=False)
+    analyzer = CoverageAnalyzer(layer)
+
+    queries = [
+        "SELECT status, SUM(amount) FROM orders GROUP BY status",
+        "SELECT region, SUM(amount) FROM orders GROUP BY region",
+    ]
+
+    report = analyzer.analyze_queries(queries)
+    models = analyzer.generate_models(report)
+
+    orders = models["orders"]
+    metric_names = [m["name"] for m in orders["metrics"]]
+
+    # sum_amount should only appear once
+    assert metric_names.count("sum_amount") == 1
+
+
+def test_generate_rewritten_queries():
+    """Test generating rewritten queries."""
+    layer = SemanticLayer(auto_register=False)
+    analyzer = CoverageAnalyzer(layer)
+
+    queries = [
+        """
+        SELECT status, SUM(amount), COUNT(*)
+        FROM orders
+        GROUP BY status
+        """
+    ]
+
+    report = analyzer.analyze_queries(queries)
+    rewritten = analyzer.generate_rewritten_queries(report)
+
+    # Should generate 1 rewritten query
+    assert len(rewritten) == 1
+    assert "query_1" in rewritten
+
+    sql = rewritten["query_1"]
+
+    # Check it's SQL format
+    assert "SELECT" in sql
+    assert "FROM orders" in sql
+
+    # Check it uses semantic layer syntax (model.dimension, model.metric)
+    assert "orders.status" in sql
+    assert "orders.count" in sql
+    assert "orders.sum_amount" in sql
+
+
+def test_generate_rewritten_queries_with_filter():
+    """Test generating rewritten queries with WHERE clause."""
+    layer = SemanticLayer(auto_register=False)
+    analyzer = CoverageAnalyzer(layer)
+
+    queries = [
+        """
+        SELECT status, SUM(amount)
+        FROM orders
+        WHERE status = 'completed'
+        GROUP BY status
+        """
+    ]
+
+    report = analyzer.analyze_queries(queries)
+    rewritten = analyzer.generate_rewritten_queries(report)
+
+    sql = rewritten["query_1"]
+
+    # Check it includes WHERE clause
+    assert "WHERE" in sql
+    assert "status = 'completed'" in sql or "status='completed'" in sql
+
+
+def test_generate_rewritten_queries_skips_unparseable():
+    """Test that unparseable queries are skipped."""
+    layer = SemanticLayer(auto_register=False)
+    analyzer = CoverageAnalyzer(layer)
+
+    queries = [
+        "SELECT FROM WHERE",  # Invalid
+        "SELECT status, COUNT(*) FROM orders GROUP BY status",  # Valid
+    ]
+
+    report = analyzer.analyze_queries(queries)
+    rewritten = analyzer.generate_rewritten_queries(report)
+
+    # Should only generate 1 query (skip the invalid one)
+    assert len(rewritten) == 1
+
+
+def test_write_model_files(tmp_path):
+    """Test writing model files to disk."""
+    layer = SemanticLayer(auto_register=False)
+    analyzer = CoverageAnalyzer(layer)
+
+    queries = [
+        "SELECT status, SUM(amount) FROM orders GROUP BY status",
+    ]
+
+    report = analyzer.analyze_queries(queries)
+    models = analyzer.generate_models(report)
+
+    output_dir = tmp_path / "models"
+    analyzer.write_model_files(models, str(output_dir))
+
+    # Check file was created
+    orders_file = output_dir / "orders.yml"
+    assert orders_file.exists()
+
+    # Check file contents
+    import yaml
+
+    with open(orders_file) as f:
+        data = yaml.safe_load(f)
+
+    assert data["model"]["name"] == "orders"
+    assert len(data["dimensions"]) == 1
+    assert len(data["metrics"]) == 1
+
+
+def test_write_rewritten_queries(tmp_path):
+    """Test writing rewritten queries to disk."""
+    layer = SemanticLayer(auto_register=False)
+    analyzer = CoverageAnalyzer(layer)
+
+    queries = [
+        "SELECT status, COUNT(*) FROM orders GROUP BY status",
+    ]
+
+    report = analyzer.analyze_queries(queries)
+    rewritten = analyzer.generate_rewritten_queries(report)
+
+    output_dir = tmp_path / "queries"
+    analyzer.write_rewritten_queries(rewritten, str(output_dir))
+
+    # Check file was created
+    query_file = output_dir / "query_1.sql"
+    assert query_file.exists()
+
+    # Check file contents
+    content = query_file.read_text()
+    assert "SELECT" in content
+    assert "FROM orders" in content
+    assert "orders.status" in content
+    assert "orders.count" in content
+
+
+def test_generate_models_multiple_aggregations_same_column():
+    """Test handling multiple aggregation types on same column."""
+    layer = SemanticLayer(auto_register=False)
+    analyzer = CoverageAnalyzer(layer)
+
+    queries = [
+        """
+        SELECT
+            status,
+            SUM(amount),
+            AVG(amount),
+            MIN(amount),
+            MAX(amount)
+        FROM orders
+        GROUP BY status
+        """
+    ]
+
+    report = analyzer.analyze_queries(queries)
+    models = analyzer.generate_models(report)
+
+    orders = models["orders"]
+    metric_names = {m["name"] for m in orders["metrics"]}
+
+    assert "sum_amount" in metric_names
+    assert "avg_amount" in metric_names
+    assert "min_amount" in metric_names
+    assert "max_amount" in metric_names