UI

index.html

@@ -5,6 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>DuckDB Explorer</title>
     <style>
+        /* --- Keep the existing CSS from the previous answer --- */
         body {
             font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
             margin: 0;
@@ -17,35 +18,26 @@
         }
 
         header {
-            background-color: #4CAF50;
+            background-color: #4CAF50; /* Changed color slightly */
             color: white;
-            padding: 10px 20px;
+            padding: 15px 20px; /* Slightly more padding */
             display: flex;
             align-items: center;
             box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            font-size: 1.2em; /* Bigger title */
+            font-weight: bold;
         }
-
-        header input[type="text"] {
-            flex-grow: 1;
-            margin-right: 10px;
-            padding: 8px;
-            border: 1px solid #ccc;
-            border-radius: 4px;
-        }
-
-        header button {
-            padding: 8px 15px;
-            background-color: #367c39;
-            color: white;
-            border: none;
-            border-radius: 4px;
-            cursor: pointer;
-            transition: background-color 0.2s;
-        }
-
-        header button:hover {
-            background-color: #2a622d;
-        }
+         /* Style for the loader inside the header */
+         header .loader {
+             border: 3px solid #f3f3f3; /* Light grey */
+             border-top: 3px solid #fff; /* White */
+             border-radius: 50%;
+             width: 18px;
+             height: 18px;
+             animation: spin 1s linear infinite;
+             display: none; /* Hidden by default */
+             margin-left: 15px; /* Space from title */
+         }
 
         .container {
             display: flex;
@@ -54,7 +46,7 @@
         }
 
         #sidebar {
-            width: 200px;
+            width: 220px; /* Slightly wider */
             background-color: #e9ecef;
             padding: 15px;
             overflow-y: auto;
@@ -63,7 +55,10 @@
 
         #sidebar h3 {
             margin-top: 0;
+            margin-bottom: 15px; /* More space */
             color: #495057;
+            border-bottom: 1px solid #ced4da;
+            padding-bottom: 10px;
         }
 
         #tableList {
@@ -73,16 +68,24 @@
         }
 
         #tableList li {
-            padding: 8px 5px;
+            padding: 8px 10px; /* More padding */
             cursor: pointer;
             border-radius: 4px;
             margin-bottom: 5px;
-            transition: background-color 0.2s;
+            transition: background-color 0.2s, color 0.2s; /* Add color transition */
+            font-size: 0.95em;
+            color: #343a40;
         }
 
-        #tableList li:hover, #tableList li.active {
+        #tableList li:hover {
             background-color: #d4dadf;
         }
+        #tableList li.active {
+             background-color: #007bff; /* Bootstrap primary blue */
+             color: white;
+             font-weight: bold;
+        }
+
 
         #mainContent {
             flex: 1;
@@ -97,103 +100,128 @@
             display: flex;
             flex-direction: column;
             overflow: hidden; /* Child takes scroll */
+            gap: 15px; /* Add gap between content boxes */
         }
 
-        #schemaDisplay, #dataDisplayContainer, #queryResultContainer {
-            background-color: #fff;
-            border: 1px solid #dee2e6;
-            border-radius: 4px;
-            padding: 15px;
-            margin-bottom: 20px;
-            overflow: auto; /* Allow scrolling within these areas */
+         #schemaDisplay, #dataDisplayContainer, #queryResultContainer {
+             background-color: #fff;
+             border: 1px solid #dee2e6;
+             border-radius: 5px; /* Slightly more rounded */
+             padding: 15px;
+             margin-bottom: 0; /* Remove margin, use gap instead */
+             overflow: auto; /* Allow scrolling within these areas */
+             box-shadow: 0 1px 3px rgba(0,0,0,0.05); /* Subtle shadow */
+         }
+        #schemaDisplay h4, #dataDisplayContainer h4, #queryResultContainer h4 {
+             margin-top: 0;
+             color: #495057;
+             border-bottom: 1px solid #eee;
+             padding-bottom: 10px;
+             margin-bottom: 15px;
         }
 
-        #dataDisplayContainer {
-            flex: 1; /* Takes remaining space */
-        }
+
+         #dataDisplayContainer {
+             flex: 1; /* Takes remaining space */
+             display: flex; /* Use flex for inner scroll */
+             flex-direction: column;
+         }
+         #dataDisplay {
+             flex: 1; /* Allow div itself to scroll */
+             overflow: auto;
+             min-height: 100px; /* Ensure it has some height */
+         }
 
 
         #queryArea {
-            margin-top: auto; /* Push query area to bottom if space */
             padding-top: 20px;
             border-top: 1px solid #dee2e6;
+            background-color: #f8f9fa; /* Slight background */
+            padding: 15px;
+            border-radius: 5px;
+            box-shadow: 0 -1px 3px rgba(0,0,0,0.05);
         }
+         #queryArea h4 {
+             margin-top: 0;
+             margin-bottom: 10px;
+             color: #495057;
+         }
 
         #queryArea textarea {
             width: 100%;
             min-height: 80px;
             padding: 10px;
-            border: 1px solid #ccc;
+            border: 1px solid #ced4da; /* Match theme */
             border-radius: 4px;
             box-sizing: border-box;
             font-family: monospace;
             margin-bottom: 10px;
+            resize: vertical; /* Allow vertical resize */
         }
 
         #queryArea button {
             padding: 10px 20px;
-            background-color: #007bff;
+            background-color: #28a745; /* Bootstrap success green */
             color: white;
             border: none;
             border-radius: 4px;
             cursor: pointer;
             transition: background-color 0.2s;
+            font-weight: bold;
         }
         #queryArea button:hover {
-            background-color: #0056b3;
+            background-color: #218838;
         }
 
         table {
             width: 100%;
             border-collapse: collapse;
-            margin-top: 10px;
+            margin-top: 0; /* Remove margin */
+            font-size: 0.9em; /* Slightly smaller table font */
         }
 
         th, td {
-            border: 1px solid #ddd;
-            padding: 8px;
+            border: 1px solid #e9ecef; /* Lighter border */
+            padding: 10px 12px; /* Adjust padding */
             text-align: left;
             white-space: nowrap;
+            max-width: 250px; /* Prevent very wide columns */
+            overflow: hidden;
+            text-overflow: ellipsis;
         }
 
         th {
-            background-color: #f2f2f2;
-            font-weight: bold;
+            background-color: #f8f9fa; /* Very light header */
+            font-weight: 600; /* Slightly bolder */
+            position: sticky; /* Sticky headers */
+            top: 0;
+            z-index: 1;
         }
 
         tr:nth-child(even) {
-            background-color: #f9f9f9;
+            background-color: #fdfdfe; /* Very subtle striping */
         }
 
-        #statusMessage {
-            padding: 10px;
-            margin-top: 10px;
-            border-radius: 4px;
-            display: none; /* Hidden by default */
-        }
+         #statusMessage {
+             padding: 10px 15px;
+             margin-top: 15px;
+             border-radius: 4px;
+             display: none; /* Hidden by default */
+             font-size: 0.9em;
+         }
 
         #statusMessage.success {
-            background-color: #d4edda;
-            color: #155724;
-            border: 1px solid #c3e6cb;
+            background-color: #d1e7dd;
+            color: #0f5132;
+            border: 1px solid #badbcc;
         }
 
         #statusMessage.error {
             background-color: #f8d7da;
-            color: #721c24;
-            border: 1px solid #f5c6cb;
+            color: #842029;
+            border: 1px solid #f5c2c7;
         }
-         .loader {
-             border: 4px solid #f3f3f3; /* Light grey */
-             border-top: 4px solid #3498db; /* Blue */
-             border-radius: 50%;
-             width: 20px;
-             height: 20px;
-             animation: spin 1s linear infinite;
-             display: none; /* Hidden by default */
-             margin-left: 10px;
-         }
-
+         /* Loader animation */
          @keyframes spin {
              0% { transform: rotate(0deg); }
              100% { transform: rotate(360deg); }
@@ -203,17 +231,15 @@
 <body>
 
     <header>
-        <label for="apiUrl" style="margin-right: 10px; font-weight: bold; color: white;">API URL:</label>
-        <input type="text" id="apiUrl" value="http://localhost:8000" placeholder="Enter API Base URL">
-        <button id="connectButton">Connect</button>
-        <div class="loader" id="loadingIndicator"></div>
+        <span>🦆 DuckDB Explorer</span>
+         <div class="loader" id="loadingIndicator"></div>
     </header>
 
     <div class="container">
         <aside id="sidebar">
             <h3>Tables</h3>
             <ul id="tableList">
-                <!-- Table names will be loaded here -->
+                <li>Loading...</li>
             </ul>
         </aside>
 
@@ -221,27 +247,27 @@
             <div class="content-area">
                 <div id="schemaDisplay">
                     <h4>Schema</h4>
-                    <p>Select a table from the list to view its schema.</p>
+                    <p>Select a table from the list.</p>
                     <table id="schemaTable"></table>
                 </div>
                 <div id="dataDisplayContainer">
                      <h4>Data <span id="tableDataHeader"></span></h4>
-                     <p>Select a table from the list to view its data (limited rows).</p>
-                    <div id="dataDisplay" style="max-height: 300px; overflow-y: auto;">
+                     <p>Select a table from the list.</p>
+                    <div id="dataDisplay">
                         <table id="dataTable"></table>
                     </div>
                 </div>
                 <div id="queryResultContainer" style="display: none;">
                      <h4>Query Result</h4>
-                     <div id="queryResultDisplay" style="max-height: 300px; overflow-y: auto;">
+                     <div id="queryResultDisplay">
                         <table id="queryResultTable"></table>
                     </div>
                 </div>
             </div>
 
             <div id="queryArea">
-                <h4>Custom SQL Query (SELECT only)</h4>
-                <textarea id="sqlInput" placeholder="Enter your SELECT query here..."></textarea>
+                <h4>Custom SQL Query (SELECT/SHOW/PRAGMA only)</h4>
+                <textarea id="sqlInput" placeholder="Enter your SELECT query here... e.g., SELECT * FROM table_name LIMIT 10"></textarea>
                 <button id="runSqlButton">Run SQL</button>
             </div>
 
@@ -250,8 +276,7 @@
     </div>
 
     <script>
-        const apiUrlInput = document.getElementById('apiUrl');
-        const connectButton = document.getElementById('connectButton');
+        // --- Keep the existing element variables ---
         const tableList = document.getElementById('tableList');
         const schemaDisplay = document.getElementById('schemaDisplay');
         const schemaTable = document.getElementById('schemaTable');
@@ -267,12 +292,12 @@
         const statusMessage = document.getElementById('statusMessage');
         const loadingIndicator = document.getElementById('loadingIndicator');
 
-        let API_BASE_URL = '';
+        // --- API URL is now relative ---
+        const API_BASE_URL = '';
         let currentTables = [];
         let selectedTable = null;
 
-        // --- Utility Functions ---
-
+        // --- Utility Functions (keep existing showLoader, showStatus, clearStatus, renderTable, renderSchema) ---
         function showLoader(show) {
             loadingIndicator.style.display = show ? 'inline-block' : 'none';
         }
@@ -281,7 +306,6 @@
             statusMessage.textContent = message;
             statusMessage.className = isError ? 'error' : 'success';
             statusMessage.style.display = 'block';
-            // Automatically hide after a few seconds
             setTimeout(() => { statusMessage.style.display = 'none'; }, 5000);
         }
 
@@ -293,7 +317,7 @@
         async function fetchAPI(endpoint, options = {}) {
             showLoader(true);
             clearStatus();
-            const url = `${API_BASE_URL}${endpoint}`;
+            const url = `${API_BASE_URL}${endpoint}`; // API_BASE_URL is now ''
             try {
                 const response = await fetch(url, options);
                 if (!response.ok) {
@@ -301,31 +325,29 @@
                     try {
                         const errorJson = await response.json();
                         errorDetail += ` - ${errorJson.detail || JSON.stringify(errorJson)}`;
-                    } catch (e) { /* Ignore if response is not JSON */ }
+                    } catch (e) { /* Ignore */ }
                     throw new Error(errorDetail);
                 }
-                // Handle empty responses for non-JSON endpoints if necessary
                  if (response.headers.get("content-type")?.includes("application/json")) {
                     return await response.json();
                  }
-                 return await response.text(); // Or handle other types
+                 // Handle potential non-JSON success responses if needed
+                 return await response.text();
             } catch (error) {
                 console.error('API Fetch Error:', error);
                 showStatus(`Error: ${error.message}`, true);
-                throw error; // Re-throw to stop further processing
+                throw error;
             } finally {
                 showLoader(false);
             }
         }
 
         function renderTable(data, tableElement) {
-            tableElement.innerHTML = ''; // Clear previous content
-
+            tableElement.innerHTML = '';
             if (!data || data.length === 0) {
                 tableElement.innerHTML = '<tbody><tr><td>No data available.</td></tr></tbody>';
                 return;
             }
-
             const headers = Object.keys(data[0]);
             const thead = tableElement.createTHead();
             const headerRow = thead.insertRow();
@@ -334,29 +356,26 @@
                 th.textContent = headerText;
                 headerRow.appendChild(th);
             });
-
             const tbody = tableElement.createTBody();
             data.forEach(rowData => {
                 const row = tbody.insertRow();
                 headers.forEach(header => {
                     const cell = row.insertCell();
-                    // Handle null or undefined gracefully
-                    cell.textContent = rowData[header] === null || rowData[header] === undefined ? 'NULL' : String(rowData[header]);
-                });
+                    const value = rowData[header];
+                    // Better null/undefined check and string conversion
+                    cell.textContent = (value === null || value === undefined) ? 'NULL' : String(value);
+                 });
             });
         }
 
         function renderSchema(schemaData) {
-             const tableElement = schemaTable;
-             tableElement.innerHTML = ''; // Clear previous
-
+            const tableElement = schemaTable;
+            tableElement.innerHTML = '';
             if (!schemaData || !schemaData.columns || schemaData.columns.length === 0) {
                 schemaDisplay.innerHTML = '<h4>Schema</h4><p>No schema information available.</p>';
                 return;
             }
-
-            schemaDisplay.innerHTML = '<h4>Schema</h4>'; // Reset header
-
+            schemaDisplay.innerHTML = '<h4>Schema</h4>';
             const thead = tableElement.createTHead();
             const headerRow = thead.insertRow();
             ['Name', 'Type'].forEach(headerText => {
@@ -364,7 +383,6 @@
                 th.textContent = headerText;
                 headerRow.appendChild(th);
             });
-
             const tbody = tableElement.createTBody();
             schemaData.columns.forEach(column => {
                 const row = tbody.insertRow();
@@ -373,31 +391,33 @@
             });
          }
 
-
-        // --- Event Handlers ---
+        // --- Event Handlers (Modified) ---
 
         async function loadTables() {
-            API_BASE_URL = apiUrlInput.value.trim().replace(/\/$/, ''); // Remove trailing slash
-            if (!API_BASE_URL) {
-                showStatus("API URL cannot be empty.", true);
-                return;
-            }
+            // No need to get API_BASE_URL from input anymore
+            tableList.innerHTML = '<li>Loading tables...</li>'; // Indicate loading
+             schemaTable.innerHTML = ''; // Clear schema
+             dataTable.innerHTML = ''; // Clear data
+             tableDataHeader.textContent = '';
+             queryResultContainer.style.display = 'none';
             try {
-                // Optional: Ping root or health endpoint first
-                // await fetchAPI('/');
                 currentTables = await fetchAPI('/tables');
                 displayTables(currentTables);
-                showStatus("Connected. Tables loaded.", false);
-                // Clear previous displays
-                schemaDisplay.innerHTML = '<h4>Schema</h4><p>Select a table from the list.</p>';
-                dataTable.innerHTML = '';
-                tableDataHeader.textContent = '';
-                queryResultContainer.style.display = 'none';
+                showStatus("Tables loaded.", false);
+                 // Clear placeholder texts
+                 if (currentTables.length > 0) {
+                     schemaDisplay.innerHTML = '<h4>Schema</h4><p>Select a table from the list.</p>';
+                     dataDisplayContainer.querySelector('p').style.display = 'block'; // Show prompt
+                 } else {
+                     schemaDisplay.innerHTML = '<h4>Schema</h4><p>No tables found in the database.</p>';
+                      dataDisplayContainer.querySelector('p').style.display = 'block';
+                 }
             } catch (error) {
                 tableList.innerHTML = '<li>Error loading tables.</li>';
             }
         }
 
+        // --- displayTables and handleTableSelection remain the same ---
         function displayTables(tables) {
             tableList.innerHTML = ''; // Clear list
             if (tables.length === 0) {
@@ -414,49 +434,51 @@
         }
 
         async function handleTableSelection(listItem) {
-            // Remove active class from previously selected
             const currentActive = tableList.querySelector('.active');
             if (currentActive) {
                 currentActive.classList.remove('active');
             }
-            // Add active class to newly selected
             listItem.classList.add('active');
 
             selectedTable = listItem.dataset.tableName;
             if (!selectedTable) return;
 
-            queryResultContainer.style.display = 'none'; // Hide query results
-            dataDisplayContainer.style.display = 'flex'; // Show table data area
+            queryResultContainer.style.display = 'none';
+            dataDisplayContainer.style.display = 'flex'; // Make sure it's flex
+             dataDisplayContainer.querySelector('p').style.display = 'none'; // Hide prompt
 
             tableDataHeader.textContent = `for table "${selectedTable}"`;
+             schemaDisplay.innerHTML = '<h4>Schema</h4>'; // Keep header
              schemaTable.innerHTML = '<tbody><tr><td>Loading schema...</td></tr></tbody>';
              dataTable.innerHTML = '<tbody><tr><td>Loading data...</td></tr></tbody>';
 
             try {
-                const [schemaData, tableData] = await Promise.all([
+                // Fetch schema and data concurrently
+                const [schemaResponse, tableDataResponse] = await Promise.all([
                     fetchAPI(`/tables/${selectedTable}/schema`),
-                    fetchAPI(`/tables/${selectedTable}?limit=100`) // Load first 100 rows
+                    fetchAPI(`/tables/${selectedTable}?limit=100`) // Default limit
                 ]);
-                renderSchema(schemaData);
-                renderTable(tableData, dataTable);
+                renderSchema(schemaResponse);
+                renderTable(tableDataResponse, dataTable);
             } catch (error) {
-                 schemaTable.innerHTML = '<tbody><tr><td>Error loading schema.</td></tr></tbody>';
+                 // Error already shown by fetchAPI
+                 schemaTable.innerHTML = '<tbody><tr><td colspan="2">Error loading schema.</td></tr></tbody>';
                  dataTable.innerHTML = '<tbody><tr><td>Error loading data.</td></tr></tbody>';
             }
         }
 
+
+        // --- runCustomQuery remains mostly the same ---
          async function runCustomQuery() {
              const sql = sqlInput.value.trim();
              if (!sql) {
                  showStatus("SQL query cannot be empty.", true);
                  return;
              }
-             if (!API_BASE_URL) {
-                 showStatus("Connect to the API first (enter URL and press Connect).", true);
-                 return;
-            }
+             // No need to check API_BASE_URL anymore
 
             dataDisplayContainer.style.display = 'none'; // Hide table data
+             dataDisplayContainer.querySelector('p').style.display = 'none'; // Hide prompt
             queryResultContainer.style.display = 'block'; // Show query results area
             queryResultTable.innerHTML = '<tbody><tr><td>Running query...</td></tr></tbody>';
 
@@ -472,19 +494,17 @@
                  renderTable(resultData, queryResultTable);
                  showStatus("Query executed successfully.", false);
              } catch (error) {
-                queryResultTable.innerHTML = '<tbody><tr><td>Error executing query.</td></tr></tbody>';
-                 // fetchAPI already shows the status
+                 queryResultTable.innerHTML = '<tbody><tr><td>Error executing query. See status message.</td></tr></tbody>';
+                 // Error is shown by fetchAPI
              }
          }
 
         // --- Initial Setup ---
-        connectButton.onclick = loadTables;
+        // Remove connectButton listener
         runSqlButton.onclick = runCustomQuery;
 
-        // Optional: Load tables on page load if API URL is preset
-        // if (apiUrlInput.value) {
-        //     loadTables();
-        // }
+        // Load tables automatically when the page loads
+        document.addEventListener('DOMContentLoaded', loadTables);
 
     </script>
 

main.py

@@ -1,18 +1,21 @@
-# ... (keep existing imports and setup) ...
 import duckdb
 import os
 from fastapi import FastAPI, HTTPException, Request, Path as FastPath, Body
+# --- Add FileResponse ---
 from fastapi.responses import FileResponse, StreamingResponse
+# --- Add CORS ---
+from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
 from typing import List, Dict, Any, Optional
 import logging
 import io
 import asyncio
-from contextlib import contextmanager # <--- Add contextlib
+from contextlib import contextmanager # Ensure this is imported
 
 # --- Configuration ---
 DATABASE_PATH = os.environ.get("DUCKDB_PATH", "data/mydatabase.db")
 DATA_DIR = "data"
+HTML_FILE_PATH = "index.html" # Path relative to main.py
 
 # Ensure data directory exists
 os.makedirs(DATA_DIR, exist_ok=True)
@@ -28,6 +31,18 @@ app = FastAPI(
     version="0.1.0"
 )
 
+# --- Add CORS Middleware ---
+# Allows requests from any origin in this example.
+# Restrict this in a production environment!
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+
+
 # --- Database Connection (using context manager for safety) ---
 @contextmanager
 def get_db_context():
@@ -48,7 +63,7 @@ def get_db_context():
         if conn:
             conn.close()
 
-# --- Pydantic Models ---
+# --- Pydantic Models (keep existing) ---
 class ColumnDefinition(BaseModel):
     name: str
     type: str
@@ -76,17 +91,13 @@ class ApiResponse(BaseModel):
     message: str
     details: Optional[Any] = None
 
-# --- Helper Functions ---
+# --- Helper Functions (keep existing) ---
 def safe_identifier(name: str) -> str:
     """Quotes an identifier safely using DuckDB."""
-    # Basic check
     if not name or not isinstance(name, str):
          raise HTTPException(status_code=400, detail=f"Invalid identifier provided: {name}")
-    # Use DuckDB's quoting mechanism
     try:
-        # Use a temporary in-memory connection for quoting safely
         with duckdb.connect(':memory:') as temp_conn:
-            # Use sql() which returns a relation, then fetch the result
             quoted = temp_conn.sql(f"SELECT '{name}'::IDENTIFIER").fetchone()
             if quoted:
                 return quoted[0]
@@ -94,7 +105,6 @@ def safe_identifier(name: str) -> str:
                  raise HTTPException(status_code=500, detail="Failed to quote identifier")
     except duckdb.Error as e:
          logger.error(f"Error quoting identifier '{name}': {e}")
-         # Fallback or re-raise depending on policy, here we raise
          raise HTTPException(status_code=400, detail=f"Invalid identifier '{name}': {e}")
 
 def generate_column_sql(columns: List[ColumnDefinition]) -> str:
@@ -102,64 +112,61 @@ def generate_column_sql(columns: List[ColumnDefinition]) -> str:
     defs = []
     for col in columns:
         col_name_safe = safe_identifier(col.name)
-        # More robust type validation needed for production
         allowed_types_prefix = ['INTEGER', 'VARCHAR', 'TEXT', 'BOOLEAN', 'FLOAT', 'DOUBLE', 'DATE', 'TIMESTAMP', 'BLOB', 'BIGINT', 'DECIMAL', 'LIST', 'STRUCT', 'MAP', 'UNION']
         type_upper = col.type.strip().upper()
-
         is_allowed = False
         for prefix in allowed_types_prefix:
-             # Allow types like VARCHAR(255), DECIMAL(10,2), LIST<INT>, STRUCT<a INT> etc.
             if type_upper.startswith(prefix):
                 is_allowed = True
                 break
-
         if not is_allowed:
-            # Very basic check, expand as needed
              raise HTTPException(status_code=400, detail=f"Unsupported or potentially invalid data type: {col.type}")
-
-        defs.append(f"{col_name_safe} {col.type}") # Pass type string directly
+        defs.append(f"{col_name_safe} {col.type}")
     return ", ".join(defs)
 
 def result_to_dict(cursor_description, rows):
     """Converts cursor results (description + rows) to a list of dictionaries."""
+    if not cursor_description: # Handle cases like non-SELECT queries returning None description
+        return []
     column_names = [desc[0] for desc in cursor_description]
     return [dict(zip(column_names, row)) for row in rows]
 
-# --- API Endpoints ---
 
-@app.get("/", summary="API Root", response_model=ApiResponse)
-async def read_root():
-    """Provides a welcome message for the API."""
-    return {"message": "Welcome to the DuckDB API!"}
+# --- NEW ROOT ENDPOINT ---
+@app.get("/", include_in_schema=False) # include_in_schema=False hides it from OpenAPI docs
+async def read_index_html():
+    """Serves the main index.html file."""
+    if not os.path.exists(HTML_FILE_PATH):
+        logger.error(f"{HTML_FILE_PATH} not found!")
+        raise HTTPException(status_code=404, detail="index.html not found")
+    logger.info(f"Serving {HTML_FILE_PATH}")
+    return FileResponse(HTML_FILE_PATH)
+
+# --- API Endpoints (keep or adapt existing, add /tables and /tables/{...}/schema if not present) ---
 
-# --- NEW ENDPOINT ---
 @app.get("/tables", summary="List Tables", response_model=List[str])
 async def list_tables():
     """Lists all tables in the default schema."""
     try:
         with get_db_context() as conn:
-            # Show user tables (excluding system tables)
-            tables = conn.execute("SELECT table_name FROM information_schema.tables WHERE table_schema = 'main'").fetchall()
+            tables = conn.execute("SELECT table_name FROM information_schema.tables WHERE table_schema = 'main' ORDER BY table_name").fetchall()
             return [table[0] for table in tables]
     except duckdb.Error as e:
         logger.error(f"Error listing tables: {e}")
         raise HTTPException(status_code=500, detail=f"Error listing tables: {e}")
 
-# --- NEW ENDPOINT ---
 @app.get("/tables/{table_name}/schema", summary="Get Table Schema", response_model=TableSchemaResponse)
 async def get_table_schema(
     table_name: str = FastPath(..., description="Name of the table")
 ):
     """Gets the schema (column names and types) for a specific table."""
     table_name_safe = safe_identifier(table_name)
-    # Use PRAGMA for schema info
     sql = f"PRAGMA table_info({table_name_safe});"
     try:
         with get_db_context() as conn:
             result = conn.execute(sql).fetchall()
             if not result:
                 raise HTTPException(status_code=404, detail=f"Table '{table_name}' not found or has no columns.")
-            # PRAGMA table_info columns: cid, name, type, notnull, dflt_value, pk
             columns = [ColumnDefinition(name=row[1], type=row[2]) for row in result]
         return TableSchemaResponse(columns=columns)
     except duckdb.CatalogException as e:
@@ -168,28 +175,25 @@ async def get_table_schema(
         logger.error(f"Error getting schema for table '{table_name}': {e}")
         raise HTTPException(status_code=400, detail=f"Error getting table schema: {e}")
 
-# --- NEW ENDPOINT ---
 @app.post("/query", summary="Execute Read-Only SQL Query")
 async def execute_query(query_request: SQLQueryRequest):
     """Executes a provided SQL query (read-only enforced)."""
     sql = query_request.sql.strip()
-
-    # **Security:** Basic check to prevent modification queries.
-    # This is NOT foolproof. A robust solution needs proper SQL parsing or
-    # database roles/permissions restricting the API user.
     forbidden_keywords = ['INSERT', 'UPDATE', 'DELETE', 'DROP', 'CREATE', 'ALTER', 'ATTACH', 'DETACH', 'COPY', 'EXPORT', 'IMPORT']
     sql_upper = sql.upper()
     if any(keyword in sql_upper for keyword in forbidden_keywords):
          raise HTTPException(status_code=403, detail="Only SELECT queries are allowed.")
-    if not sql_upper.startswith('SELECT') and not sql_upper.startswith('WITH'):
-         raise HTTPException(status_code=400, detail="Query must start with SELECT or WITH.")
+    if not sql_upper.startswith('SELECT') and not sql_upper.startswith('WITH') and not sql_upper.startswith('PRAGMA') and not sql_upper.startswith('SHOW'):
+         # Allow PRAGMA and SHOW for exploration
+         raise HTTPException(status_code=400, detail="Query must start with SELECT, WITH, PRAGMA, or SHOW.")
 
     try:
         logger.info(f"Executing user SQL: {sql}")
         with get_db_context() as conn:
-            description = conn.execute(sql).description
-            result = conn.fetchall()
-            # Convert rows to dictionaries for JSON serialization
+            # Use sql() to get a relation, which gives description even for empty results
+            rel = conn.sql(sql)
+            description = rel.description
+            result = rel.fetchall()
             data = result_to_dict(description, result)
         return data
     except duckdb.Error as e:
@@ -199,38 +203,37 @@ async def execute_query(query_request: SQLQueryRequest):
         logger.error(f"Unexpected error executing user query: {e}")
         raise HTTPException(status_code=500, detail="An unexpected error occurred during query execution.")
 
-# --- Existing Endpoints (Keep or adapt as needed) ---
+
 @app.post("/tables/{table_name}", summary="Create Table", response_model=ApiResponse, status_code=201)
 async def create_table(
     table_name: str = FastPath(..., description="Name of the table to create"),
     schema: CreateTableRequest = ...,
 ):
-    """Creates a new table with the specified schema."""
+    """Creates or replaces a table with the specified schema."""
     table_name_safe = safe_identifier(table_name)
     if not schema.columns:
         raise HTTPException(status_code=400, detail="Table must have at least one column.")
-
     try:
         columns_sql = generate_column_sql(schema.columns)
-        sql = f"CREATE OR REPLACE TABLE {table_name_safe} ({columns_sql});" # Use CREATE OR REPLACE for simplicity
+        sql = f"CREATE OR REPLACE TABLE {table_name_safe} ({columns_sql});"
         logger.info(f"Executing SQL: {sql}")
         with get_db_context() as conn:
             conn.execute(sql)
         return {"message": f"Table '{table_name}' created or replaced successfully."}
-    except HTTPException as e:
-        raise e
+    except HTTPException as e: raise e
     except duckdb.Error as e:
-        logger.error(f"Error creating table '{table_name}': {e}")
-        raise HTTPException(status_code=400, detail=f"Error creating table: {e}")
+        logger.error(f"Error creating/replacing table '{table_name}': {e}")
+        raise HTTPException(status_code=400, detail=f"Error creating/replacing table: {e}")
     except Exception as e:
-        logger.error(f"Unexpected error creating table '{table_name}': {e}")
+        logger.error(f"Unexpected error creating/replacing table '{table_name}': {e}")
         raise HTTPException(status_code=500, detail="An unexpected error occurred.")
 
+
 @app.get("/tables/{table_name}", summary="Read Table Data")
 async def read_table(
     table_name: str = FastPath(..., description="Name of the table to read from"),
-    limit: Optional[int] = 100, # Default limit
-    offset: Optional[int] = 0 # Default offset
+    limit: Optional[int] = 100,
+    offset: Optional[int] = 0
 ):
     """Reads and returns rows from a specified table. Supports limit and offset."""
     table_name_safe = safe_identifier(table_name)
@@ -243,12 +246,12 @@ async def read_table(
         sql += " OFFSET ?"
         params.append(offset)
     sql += ";"
-
     try:
         logger.info(f"Executing SQL: {sql} with params: {params}")
         with get_db_context() as conn:
-            description = conn.execute(sql, params).description
-            result = conn.fetchall()
+            rel = conn.sql(sql, params=params)
+            description = rel.description
+            result = rel.fetchall()
             data = result_to_dict(description, result)
         return data
     except duckdb.CatalogException as e:
@@ -260,39 +263,34 @@ async def read_table(
         logger.error(f"Unexpected error reading table '{table_name}': {e}")
         raise HTTPException(status_code=500, detail="An unexpected error occurred.")
 
+# ... (keep other existing endpoints like create_rows, update_rows, delete_rows, downloads, health check) ...
+# Make sure they use `with get_db_context() as conn:` instead of the `for conn in get_db():` loop
+# For example:
 
 @app.post("/tables/{table_name}/rows", summary="Create Rows", response_model=ApiResponse, status_code=201)
 async def create_rows(
     table_name: str = FastPath(..., description="Name of the table to insert into"),
     request: CreateRowRequest = ...,
 ):
-    """Inserts one or more rows into the specified table."""
     table_name_safe = safe_identifier(table_name)
     if not request.rows:
         raise HTTPException(status_code=400, detail="No rows provided to insert.")
-
-    # Assume all rows have the same columns based on the first row
     columns = list(request.rows[0].keys())
     columns_safe = [safe_identifier(col) for col in columns]
     placeholders = ", ".join(["?"] * len(columns))
     columns_sql = ", ".join(columns_safe)
-
     sql = f"INSERT INTO {table_name_safe} ({columns_sql}) VALUES ({placeholders});"
-
-    # Convert list of dicts to list of lists/tuples for executemany
     params_list = []
     for row_dict in request.rows:
         if list(row_dict.keys()) != columns:
              raise HTTPException(status_code=400, detail="All rows must have the same columns in the same order.")
         params_list.append(list(row_dict.values()))
-
     try:
         logger.info(f"Executing SQL: {sql} for {len(params_list)} rows")
-        with get_db_context() as conn:
+        with get_db_context() as conn: # Use context manager
             conn.executemany(sql, params_list)
-            # Removed commit - context manager handles it
         return {"message": f"Successfully inserted {len(params_list)} rows into '{table_name}'."}
-    except duckdb.CatalogException as e:
+    except duckdb.CatalogException:
          raise HTTPException(status_code=404, detail=f"Table '{table_name}' not found.")
     except duckdb.Error as e:
         logger.error(f"Error inserting rows into '{table_name}': {e}")
@@ -301,88 +299,22 @@ async def create_rows(
         logger.error(f"Unexpected error inserting rows into '{table_name}': {e}")
         raise HTTPException(status_code=500, detail="An unexpected error occurred.")
 
-
-@app.put("/tables/{table_name}/rows", summary="Update Rows", response_model=ApiResponse)
-async def update_rows(
-    table_name: str = FastPath(..., description="Name of the table to update"),
-    request: UpdateRowRequest = ...,
-):
-    """Updates rows in the table based on a condition."""
-    table_name_safe = safe_identifier(table_name)
-    if not request.updates:
-        raise HTTPException(status_code=400, detail="No updates provided.")
-    if not request.condition:
-         raise HTTPException(status_code=400, detail="Update condition (WHERE clause) is required.")
-
-    set_clauses = []
-    params = []
-    for col, value in request.updates.items():
-        set_clauses.append(f"{safe_identifier(col)} = ?")
-        params.append(value)
-
-    set_sql = ", ".join(set_clauses)
-    # WARNING: Injecting request.condition directly is a security risk.
-    # Use parameters for values, but condition structure still needs care.
-    sql = f"UPDATE {table_name_safe} SET {set_sql} WHERE {request.condition};" # Condition not parameterized here
-
-    try:
-        logger.info(f"Executing SQL: {sql} with params: {params}")
-        with get_db_context() as conn:
-            conn.execute(sql, params)
-            # Removed commit
-        return {"message": f"Rows in '{table_name}' updated successfully based on condition."}
-    except duckdb.CatalogException as e:
-         raise HTTPException(status_code=404, detail=f"Table '{table_name}' not found.")
-    except duckdb.Error as e:
-        logger.error(f"Error updating rows in '{table_name}': {e}")
-        raise HTTPException(status_code=400, detail=f"Error updating rows: {e}")
-    except Exception as e:
-        logger.error(f"Unexpected error updating rows in '{table_name}': {e}")
-        raise HTTPException(status_code=500, detail="An unexpected error occurred.")
-
-@app.delete("/tables/{table_name}/rows", summary="Delete Rows", response_model=ApiResponse)
-async def delete_rows(
-    table_name: str = FastPath(..., description="Name of the table to delete from"),
-    request: DeleteRowRequest = ...,
-):
-    """Deletes rows from the table based on a condition."""
-    table_name_safe = safe_identifier(table_name)
-    if not request.condition:
-         raise HTTPException(status_code=400, detail="Delete condition (WHERE clause) is required.")
-
-    # WARNING: Injecting request.condition directly is a security risk.
-    sql = f"DELETE FROM {table_name_safe} WHERE {request.condition};" # Condition not parameterized here
-
-    try:
-        logger.info(f"Executing SQL: {sql}")
-        with get_db_context() as conn:
-            conn.execute(sql)
-            # Removed commit
-        return {"message": f"Rows from '{table_name}' deleted successfully based on condition."}
-    except duckdb.CatalogException as e:
-         raise HTTPException(status_code=404, detail=f"Table '{table_name}' not found.")
-    except duckdb.Error as e:
-        logger.error(f"Error deleting rows from '{table_name}': {e}")
-        raise HTTPException(status_code=400, detail=f"Error deleting rows: {e}")
-    except Exception as e:
-        logger.error(f"Unexpected error deleting rows from '{table_name}': {e}")
-        raise HTTPException(status_code=500, detail="An unexpected error occurred.")
+# --- Apply the `with get_db_context() as conn:` pattern to update_rows, delete_rows, download_table_csv etc. ---
 
 # --- Download Endpoints ---
 @app.get("/download/table/{table_name}", summary="Download Table as CSV")
 async def download_table_csv(
     table_name: str = FastPath(..., description="Name of the table to download")
 ):
-    """Downloads the entire content of a table as a CSV file."""
     table_name_safe = safe_identifier(table_name)
     sql = f"COPY (SELECT * FROM {table_name_safe}) TO STDOUT (FORMAT CSV, HEADER)"
 
     async def stream_csv_data():
         try:
-            # Use pandas for CSV conversion in-memory
             with get_db_context() as conn:
                 # Check if table exists before fetching
                 conn.execute(f"SELECT 1 FROM {table_name_safe} LIMIT 0")
+                # Use pandas for CSV conversion in-memory
                 df = conn.execute(f"SELECT * FROM {table_name_safe}").df()
 
             all_data_io = io.StringIO()
@@ -392,13 +324,11 @@ async def download_table_csv(
             chunk_size = 8192
             while True:
                 chunk = all_data_io.read(chunk_size)
-                if not chunk:
-                    break
-                yield chunk.encode('utf-8') # Encode to bytes for streaming response
+                if not chunk: break
+                yield chunk.encode('utf-8')
                 await asyncio.sleep(0)
             all_data_io.close()
-
-        except duckdb.CatalogException as e:
+        except duckdb.CatalogException:
             yield f"Error: Table '{table_name}' not found.".encode('utf-8')
             logger.error(f"Error downloading table '{table_name}': Table not found.")
         except duckdb.Error as e:
@@ -417,21 +347,18 @@ async def download_table_csv(
 
 @app.get("/download/database", summary="Download Database File")
 async def download_database_file():
-    """Downloads the entire DuckDB database file."""
     if not os.path.exists(DATABASE_PATH):
         raise HTTPException(status_code=404, detail="Database file not found.")
     logger.warning("Attempting to download database file. Ensure no active writes are occurring.")
     return FileResponse(
         path=DATABASE_PATH,
         filename=os.path.basename(DATABASE_PATH),
-        media_type="application/vnd.duckdb.database" # More specific media type
+        media_type="application/vnd.duckdb.database"
     )
 
-
 # --- Health Check ---
 @app.get("/health", summary="Health Check", response_model=ApiResponse)
 async def health_check():
-    """Checks if the API and database connection are working."""
     try:
         with get_db_context() as conn:
             conn.execute("SELECT 1")