Add SQL view tab to workbench and fix duplicate columns in CTEs

- Add SQL tab to results panel showing rendered SQL query
- Fix duplicate column issue in CTE generation (e.g., id AS id, id AS id)
- Track all columns added to CTEs to prevent duplicates from PKs/FKs/dimensions
- Update theme support for SQL display area

Author: nicosuave

sidemantic/cli.py

@@ -110,6 +110,15 @@ class SidequeryWorkbench(App):
         display: none;
     }
 
+    #sql-view {
+        height: 1fr;
+        display: none;
+    }
+
+    #sql-display {
+        height: 100%;
+    }
+
     #results-table {
         height: 100%;
     }
@@ -146,6 +155,7 @@ def __init__(self, directory: Path, show_sql: bool = False, demo_mode: bool = Fa
         self.directory = directory
         self.layer = None
         self.last_result = None
+        self.last_rendered_sql = None
         self.demo_mode = demo_mode
 
     def compose(self) -> ComposeResult:
@@ -193,8 +203,11 @@ def compose(self) -> ComposeResult:
                     with Horizontal(id="view-buttons"):
                         yield Button("Table", id="btn-table", classes="active")
                         yield Button("Chart", id="btn-chart")
+                        yield Button("SQL", id="btn-sql")
                     with Vertical(id="table-view"):
                         yield DataTable(id="results-table")
+                    with Vertical(id="sql-view"):
+                        yield TextArea("", language="sql", show_line_numbers=True, read_only=True, id="sql-display")
                     with Vertical(id="chart-view"):
                         with Horizontal(id="chart-config", classes="config-row"):
                             yield Label("X:", classes="config-label")
@@ -234,6 +247,13 @@ def watch_theme(self, theme_name: str) -> None:
         for editor in self.query(".sql-editor").results(TextArea):
             editor.theme = editor_theme
 
+        # Update SQL display
+        try:
+            sql_display = self.query_one("#sql-display", TextArea)
+            sql_display.theme = editor_theme
+        except Exception:
+            pass  # SQL display may not exist yet
+
     def on_mount(self) -> None:
         """Load semantic layer and populate tree."""
         # Show first query editor
@@ -243,16 +263,41 @@ def on_mount(self) -> None:
             # Setup database connection
             if self.demo_mode:
                 # Create in-memory demo database
-                from sidemantic.examples.multi_format_demo.demo_data import create_demo_database
+                try:
+                    # Try packaged import first
+                    from sidemantic.examples.multi_format_demo.demo_data import create_demo_database
+                except ModuleNotFoundError:
+                    # Fall back to dev environment import
+                    import sys
+                    demo_data_path = self.directory / "demo_data.py"
+                    if demo_data_path.exists():
+                        import importlib.util
+                        spec = importlib.util.spec_from_file_location("demo_data", demo_data_path)
+                        demo_data_module = importlib.util.module_from_spec(spec)
+                        sys.modules["demo_data"] = demo_data_module
+                        spec.loader.exec_module(demo_data_module)
+                        create_demo_database = demo_data_module.create_demo_database
+                    else:
+                        raise ImportError(f"Could not find demo_data.py at {demo_data_path}")
 
                 # Create layer with in-memory DB
                 self.layer = SemanticLayer(connection="duckdb:///:memory:")
                 # Populate with demo data
                 demo_conn = create_demo_database()
                 # Copy data from demo connection to layer's connection
                 for table in ["customers", "products", "orders"]:
-                    table_data = demo_conn.execute(f"SELECT * FROM {table}").df()  # noqa: F841
-                    self.layer.conn.execute(f"CREATE TABLE {table} AS SELECT * FROM table_data")
+                    # Get table data as regular Python objects (no pandas)
+                    rows = demo_conn.execute(f"SELECT * FROM {table}").fetchall()
+                    columns = [desc[0] for desc in demo_conn.execute(f"SELECT * FROM {table} LIMIT 0").description]
+
+                    # Create table in target connection
+                    create_sql = demo_conn.execute(f"SELECT sql FROM duckdb_tables() WHERE table_name = '{table}'").fetchone()[0]
+                    self.layer.conn.execute(create_sql)
+
+                    # Insert data if there are rows
+                    if rows:
+                        placeholders = ", ".join(["?" for _ in columns])
+                        self.layer.conn.executemany(f"INSERT INTO {table} VALUES ({placeholders})", rows)
             else:
                 # Try to find database file
                 db_path = None
@@ -487,8 +532,17 @@ def action_run_query(self) -> None:
             if not sql:
                 return
 
-            # Execute query
-            result = self.layer.sql(sql)
+            # Execute query and get rendered SQL
+            from sidemantic.sql.query_rewriter import QueryRewriter
+
+            rewriter = QueryRewriter(self.layer.graph, dialect=self.layer.dialect)
+            rendered_sql = rewriter.rewrite(sql)
+
+            # Store rendered SQL
+            self.last_rendered_sql = rendered_sql
+
+            # Execute the query
+            result = self.layer.conn.execute(rendered_sql)
 
             # Get column names and rows
             columns = [desc[0] for desc in result.description]
@@ -497,6 +551,11 @@ def action_run_query(self) -> None:
             # Store for chart rendering
             self.last_result = {"columns": columns, "rows": rows}
 
+            # Update SQL display
+            if rendered_sql:
+                sql_display = self.query_one("#sql-display", TextArea)
+                sql_display.text = rendered_sql
+
             # Update table
             table.clear(columns=True)
             for col in columns:
@@ -628,20 +687,32 @@ def on_button_pressed(self, event: Button.Pressed) -> None:
                     else:
                         btn.remove_class("active")
 
-        # Handle table/chart view switching
+        # Handle table/chart/sql view switching
         table_view = self.query_one("#table-view")
         chart_view = self.query_one("#chart-view")
+        sql_view = self.query_one("#sql-view")
 
         if event.button.id == "btn-table":
             table_view.styles.display = "block"
             chart_view.styles.display = "none"
+            sql_view.styles.display = "none"
             self.query_one("#btn-table", Button).add_class("active")
             self.query_one("#btn-chart", Button).remove_class("active")
+            self.query_one("#btn-sql", Button).remove_class("active")
         elif event.button.id == "btn-chart":
             table_view.styles.display = "none"
             chart_view.styles.display = "block"
+            sql_view.styles.display = "none"
             self.query_one("#btn-table", Button).remove_class("active")
             self.query_one("#btn-chart", Button).add_class("active")
+            self.query_one("#btn-sql", Button).remove_class("active")
+        elif event.button.id == "btn-sql":
+            table_view.styles.display = "none"
+            chart_view.styles.display = "none"
+            sql_view.styles.display = "block"
+            self.query_one("#btn-table", Button).remove_class("active")
+            self.query_one("#btn-chart", Button).remove_class("active")
+            self.query_one("#btn-sql", Button).add_class("active")
 
     def on_select_changed(self, event: Select.Changed) -> None:
         """Handle chart axis selection changes."""
@@ -1144,15 +1215,41 @@ def mcp_serve(
 
         # If demo mode, populate with demo data
         if demo:
-            from sidemantic.examples.multi_format_demo.demo_data import create_demo_database
+            try:
+                # Try packaged import first
+                from sidemantic.examples.multi_format_demo.demo_data import create_demo_database
+            except ModuleNotFoundError:
+                # Fall back to dev environment import
+                import sys
+                import importlib.util
+                demo_data_path = directory / "demo_data.py"
+                if demo_data_path.exists():
+                    spec = importlib.util.spec_from_file_location("demo_data", demo_data_path)
+                    demo_data_module = importlib.util.module_from_spec(spec)
+                    sys.modules["demo_data"] = demo_data_module
+                    spec.loader.exec_module(demo_data_module)
+                    create_demo_database = demo_data_module.create_demo_database
+                else:
+                    raise ImportError(f"Could not find demo_data.py at {demo_data_path}")
+
             from sidemantic.mcp_server import get_layer
 
             layer = get_layer()
             demo_conn = create_demo_database()
             # Copy data from demo connection to layer's connection
             for table in ["customers", "products", "orders"]:
-                table_data = demo_conn.execute(f"SELECT * FROM {table}").df()  # noqa: F841
-                layer.conn.execute(f"CREATE TABLE {table} AS SELECT * FROM table_data")
+                # Get table data as regular Python objects (no pandas)
+                rows = demo_conn.execute(f"SELECT * FROM {table}").fetchall()
+                columns = [desc[0] for desc in demo_conn.execute(f"SELECT * FROM {table} LIMIT 0").description]
+
+                # Create table in target connection
+                create_sql = demo_conn.execute(f"SELECT sql FROM duckdb_tables() WHERE table_name = '{table}'").fetchone()[0]
+                layer.conn.execute(create_sql)
+
+                # Insert data if there are rows
+                if rows:
+                    placeholders = ", ".join(["?" for _ in columns])
+                    layer.conn.executemany(f"INSERT INTO {table} VALUES ({placeholders})", rows)
 
         typer.echo(f"Starting MCP server for: {directory}", err=True)
         if db_path and db_path != ":memory:":

sidemantic/sql/generator.py

@@ -478,21 +478,21 @@ def _build_model_cte(
         # Build SELECT columns
         select_cols = []
 
-        # Add join keys
-        join_keys_added = set()
+        # Track all columns added (not just join keys) to avoid duplicates
+        columns_added = set()
 
         # Include this model's primary key
-        if model.primary_key and model.primary_key not in join_keys_added:
+        if model.primary_key and model.primary_key not in columns_added:
             select_cols.append(f"{model.primary_key} AS {model.primary_key}")
-            join_keys_added.add(model.primary_key)
+            columns_added.add(model.primary_key)
 
         # Include foreign keys from belongs_to joins
         for relationship in model.relationships:
             if relationship.type == "many_to_one":
                 fk = relationship.sql_expr
-                if fk not in join_keys_added:
+                if fk not in columns_added:
                     select_cols.append(f"{fk} AS {fk}")
-                    join_keys_added.add(fk)
+                    columns_added.add(fk)
 
         # Check if other models have has_many/has_one pointing to this model
         for other_model_name, other_model in self.graph.models.items():
@@ -504,14 +504,16 @@ def _build_model_cte(
                     # Other model expects this model to have a foreign key
                     # For has_many/has_one, foreign_key is the FK column in THIS model
                     fk = other_join.foreign_key or other_join.sql_expr
-                    if fk not in join_keys_added:
+                    if fk not in columns_added:
                         select_cols.append(f"{fk} AS {fk}")
-                        join_keys_added.add(fk)
+                        columns_added.add(fk)
 
         # Add dimension columns
         # First, add all dimensions from this model (needed for filters/joins)
         for dimension in model.dimensions:
-            select_cols.append(f"{dimension.sql_expr} AS {dimension.name}")
+            if dimension.name not in columns_added:
+                select_cols.append(f"{dimension.sql_expr} AS {dimension.name}")
+                columns_added.add(dimension.name)
 
         # Then, add time dimensions with specific granularities
         for dim_ref, gran in dimensions:
@@ -528,7 +530,9 @@ def _build_model_cte(
                 # Apply time granularity (in addition to base column)
                 dim_sql = dimension.with_granularity(gran)
                 alias = f"{dim_name}__{gran}"
-                select_cols.append(f"{dim_sql} AS {alias}")
+                if alias not in columns_added:
+                    select_cols.append(f"{dim_sql} AS {alias}")
+                    columns_added.add(alias)
 
         # Add measure columns (raw, not aggregated in CTE)
         # Collect all measures needed for metrics