Update app.py

app.py

@@ -1,37 +1,61 @@
 import time
+import io
+import traceback
+from typing import Dict, Callable, Any, Tuple
+
 import numpy as np
 import pandas as pd
 import duckdb
 import gradio as gr
 import matplotlib.pyplot as plt
 from PIL import Image
-import io
-import os
+
+# ----------------- 1. Global Setup -----------------
 
 duckdb_con = duckdb.connect(database=":memory:")
 
-# ----------------------------------------------------------
-# Synthetic Data Generator
-# ----------------------------------------------------------
+# ----------------- 2. Data Generation & Loading -----------------
 
-def generate_data(n_rows: int, n_groups: int = 50) -> pd.DataFrame:
+def generate_data(n_rows, n_groups=50):
     rng = np.random.default_rng(42)
-    ids = np.arange(n_rows)
+    ids = np.arange(n_rows, dtype=np.int64)
+
     categories = rng.integers(0, n_groups, size=n_rows)
-    categories = np.array([f"cat_{c}" for c in categories])
+    categories = np.array(["cat_" + str(c) for c in categories], dtype=object)
+
     value1 = rng.normal(0, 1, size=n_rows)
     value2 = rng.normal(10, 5, size=n_rows)
+
+    null_mask = rng.random(n_rows) < 0.05
+    value1[null_mask] = np.nan
+
     start_date = np.datetime64("2020-01-01")
     dates = start_date + rng.integers(0, 365, size=n_rows).astype("timedelta64[D]")
 
-    return pd.DataFrame(
-        {"id": ids, "category": categories, "value1": value1, "value2": value2, "date": dates}
+    df = pd.DataFrame(
+        {
+            "id": ids,
+            "category": categories,
+            "value1": value1,
+            "value2": value2,
+            "date": dates,
+        }
     )
+    return df
 
+def load_custom_dataset(file) -> pd.DataFrame:
+    if file is None:
+        raise ValueError("No file uploaded.")
+    name = file.name.lower()
+    if name.endswith(".csv"):
+        return pd.read_csv(file.name)
+    if name.endswith(".parquet"):
+        return pd.read_parquet(file.name)
+    if name.endswith(".arrow") or name.endswith(".feather"):
+        return pd.read_feather(file.name)
+    raise ValueError("Unsupported file format. Use CSV, Parquet, or Arrow/Feather.")
 
-# ----------------------------------------------------------
-# Timing utility
-# ----------------------------------------------------------
+# ----------------- 3. Timing Utils -----------------
 
 def time_function(fn, repeats=3):
     repeats = int(repeats)
@@ -41,57 +65,106 @@ def time_function(fn, repeats=3):
         fn()
         end = time.perf_counter()
         times.append(end - start)
-    return np.mean(times), np.std(times), times
+    return float(np.mean(times)), float(np.std(times)), [float(t) for t in times]
 
+def build_result(pm, ps, pr, dm, ds, dr):
+    if dm > 1e-9:
+        speedup = pm / dm
+    else:
+        speedup = 0.0
+    return {
+        "pandas_mean_s": pm,
+        "pandas_std_s": ps,
+        "duckdb_mean_s": dm,
+        "duckdb_std_s": ds,
+        "speedup": speedup,
+        "raw_pandas_runs": pr,
+        "raw_duckdb_runs": dr,
+    }
 
-# ----------------------------------------------------------
-# Benchmark Operations (Compute + I/O)
-# ----------------------------------------------------------
+# ----------------- 4. Benchmarks -----------------
 
-# ---- Filter ----
-def bench_filter(df, repeats=3):
+def bench_filter_simple(df, repeats=3):
     def pandas_op():
-        _ = df[(df["value1"] > 0.5) & (df["category"] == df["category"].iloc[0])]
+        _ = df[(df["value1"] > 0.5) & (df["category"] == "cat_1")]
 
     def duckdb_op():
         duckdb_con.register("df", df)
-        duckdb_con.execute(f"""
-            SELECT *
-            FROM df
-            WHERE value1 > 0.5
-              AND category='{df['category'].iloc[0]}'
-        """).fetchdf()
+        duckdb_con.execute(
+            "SELECT * FROM df WHERE value1 > 0.5 AND category = 'cat_1';"
+        ).fetchdf()
 
-    p_mean, p_std, p_all = time_function(pandas_op, repeats)
-    d_mean, d_std, d_all = time_function(duckdb_op, repeats)
+    pm, ps, pr = time_function(pandas_op, repeats)
+    dm, ds, dr = time_function(duckdb_op, repeats)
+    return build_result(pm, ps, pr, dm, ds, dr)
 
-    return build_result("Filter rows", p_mean, p_std, p_all, d_mean, d_std, d_all)
-
-
-# ---- Groupby ----
-def bench_groupby(df, repeats=3):
+def bench_filter_complex(df, repeats=3):
     def pandas_op():
-        _ = df.groupby("category")[["value1", "value2"]].mean()
+        _ = df[
+            (df["value1"] > 0)
+            & (df["value2"] < 12)
+            & (df["date"].between("2020-03-01", "2020-09-30"))
+        ]
 
     def duckdb_op():
         duckdb_con.register("df", df)
-        duckdb_con.execute("""
-            SELECT category, AVG(value1), AVG(value2)
-            FROM df GROUP BY category
-        """).fetchdf()
+        duckdb_con.execute(
+            "SELECT * FROM df "
+            "WHERE value1 > 0 "
+            "AND value2 < 12 "
+            "AND date BETWEEN DATE '2020-03-01' AND DATE '2020-09-30';"
+        ).fetchdf()
+
+    pm, ps, pr = time_function(pandas_op, repeats)
+    dm, ds, dr = time_function(duckdb_op, repeats)
+    return build_result(pm, ps, pr, dm, ds, dr)
+
+def bench_groupby_basic(df, repeats=3):
+    def pandas_op():
+        _ = df.groupby("category").agg(
+            mean_value1=("value1", "mean"),
+            sum_value2=("value2", "sum"),
+            cnt=("id", "count"),
+        )
 
-    p_mean, p_std, p_all = time_function(pandas_op, repeats)
-    d_mean, d_std, d_all = time_function(duckdb_op, repeats)
+    def duckdb_op():
+        duckdb_con.register("df", df)
+        duckdb_con.execute(
+            "SELECT category, "
+            "AVG(value1) AS mean_value1, "
+            "SUM(value2) AS sum_value2, "
+            "COUNT(*) AS cnt "
+            "FROM df GROUP BY category;"
+        ).fetchdf()
+
+    pm, ps, pr = time_function(pandas_op, repeats)
+    dm, ds, dr = time_function(duckdb_op, repeats)
+    return build_result(pm, ps, pr, dm, ds, dr)
+
+def bench_groupby_having(df, repeats=3):
+    def pandas_op():
+        agg = df.groupby("category").agg(mean_value1=("value1", "mean"))
+        _ = agg[agg["mean_value1"] > 0]
 
-    return build_result("Groupby mean", p_mean, p_std, p_all, d_mean, d_std, d_all)
+    def duckdb_op():
+        duckdb_con.register("df", df)
+        duckdb_con.execute(
+            "SELECT category, AVG(value1) AS mean_value1 "
+            "FROM df GROUP BY category HAVING AVG(value1) > 0;"
+        ).fetchdf()
 
+    pm, ps, pr = time_function(pandas_op, repeats)
+    dm, ds, dr = time_function(duckdb_op, repeats)
+    return build_result(pm, ps, pr, dm, ds, dr)
 
-# ---- Join ----
 def bench_join(df, repeats=3):
     categories = df["category"].unique()
     rng = np.random.default_rng(123)
     dim_df = pd.DataFrame(
-        {"category": categories, "weight": rng.uniform(0.5, 2.0, len(categories))}
+        {
+            "category": categories,
+            "weight": rng.uniform(0.5, 2.0, size=len(categories)),
+        }
     )
 
     def pandas_op():
@@ -100,243 +173,445 @@ def bench_join(df, repeats=3):
     def duckdb_op():
         duckdb_con.register("df", df)
         duckdb_con.register("dim_df", dim_df)
-        duckdb_con.execute("""
-            SELECT d.*, dim.weight
-            FROM df d
-            LEFT JOIN dim_df dim
-            ON d.category = dim.category
-        """).fetchdf()
+        duckdb_con.execute(
+            "SELECT d.*, dim.weight "
+            "FROM df d LEFT JOIN dim_df dim "
+            "ON d.category = dim.category;"
+        ).fetchdf()
 
-    p_mean, p_std, p_all = time_function(pandas_op, repeats)
-    d_mean, d_std, d_all = time_function(duckdb_op, repeats)
+    pm, ps, pr = time_function(pandas_op, repeats)
+    dm, ds, dr = time_function(duckdb_op, repeats)
+    return build_result(pm, ps, pr, dm, ds, dr)
 
-    return build_result("Join on category", p_mean, p_std, p_all, d_mean, d_std, d_all)
-
-
-# ---- Read CSV ----
-def bench_read_csv(temp_csv_path, repeats=3):
+def bench_order_by(df, repeats=3):
     def pandas_op():
-        _ = pd.read_csv(temp_csv_path)
+        _ = df.sort_values(["value1", "date"], ascending=[False, True])
 
     def duckdb_op():
-        _ = duckdb.read_csv_auto(temp_csv_path)
-
-    p_mean, p_std, p_all = time_function(pandas_op, repeats)
-    d_mean, d_std, d_all = time_function(duckdb_op, repeats)
-
-    return build_result("Read CSV", p_mean, p_std, p_all, d_mean, d_std, d_all)
+        duckdb_con.register("df", df)
+        duckdb_con.execute(
+            "SELECT * FROM df ORDER BY value1 DESC, date ASC;"
+        ).fetchdf()
 
+    pm, ps, pr = time_function(pandas_op, repeats)
+    dm, ds, dr = time_function(duckdb_op, repeats)
+    return build_result(pm, ps, pr, dm, ds, dr)
 
-# ---- Read Parquet ----
-def bench_read_parquet(temp_parquet_path, repeats=3):
+def bench_window_row_number(df, repeats=3):
     def pandas_op():
-        _ = pd.read_parquet(temp_parquet_path)
+        temp = df.sort_values(["category", "value1"], ascending=[True, False]).copy()
+        temp["rn"] = temp.groupby("category").cumcount() + 1
+        _ = temp
 
     def duckdb_op():
-        _ = duckdb.read_parquet(temp_parquet_path)
-
-    p_mean, p_std, p_all = time_function(pandas_op, repeats)
-    d_mean, d_std, d_all = time_function(duckdb_op, repeats)
-
-    return build_result("Read Parquet", p_mean, p_std, p_all, d_mean, d_std, d_all)
+        duckdb_con.register("df", df)
+        duckdb_con.execute(
+            "SELECT *, "
+            "ROW_NUMBER() OVER (PARTITION BY category ORDER BY value1 DESC) AS rn "
+            "FROM df;"
+        ).fetchdf()
 
+    pm, ps, pr = time_function(pandas_op, repeats)
+    dm, ds, dr = time_function(duckdb_op, repeats)
+    return build_result(pm, ps, pr, dm, ds, dr)
 
-# ---- Write Parquet ----
-def bench_write_parquet(df, repeats=3):
+def bench_window_running_total(df, repeats=3):
     def pandas_op():
-        df.to_parquet("temp_pd.parquet")
+        temp = df.sort_values("date").copy()
+        temp["running_sum"] = temp["value1"].fillna(0).cumsum()
+        _ = temp
 
     def duckdb_op():
         duckdb_con.register("df", df)
-        duckdb_con.execute("COPY df TO 'temp_duck.parquet' (FORMAT PARQUET)")
-
-    p_mean, p_std, p_all = time_function(pandas_op, repeats)
-    d_mean, d_std, d_all = time_function(duckdb_op, repeats)
-
-    return build_result("Write Parquet", p_mean, p_std, p_all, d_mean, d_std, d_all)
-
+        duckdb_con.execute(
+            "SELECT *, "
+            "SUM(COALESCE(value1, 0)) OVER (ORDER BY date "
+            "ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS running_sum "
+            "FROM df;"
+        ).fetchdf()
+
+    pm, ps, pr = time_function(pandas_op, repeats)
+    dm, ds, dr = time_function(duckdb_op, repeats)
+    return build_result(pm, ps, pr, dm, ds, dr)
+
+def bench_drop_nulls(df, repeats=3):
+    def pandas_op():
+        _ = df[df["value1"].notna()]
 
-# ----------------------------------------------------------
-# Shared result formatting
-# ----------------------------------------------------------
+    def duckdb_op():
+        duckdb_con.register("df", df)
+        duckdb_con.execute(
+            "SELECT * FROM df WHERE value1 IS NOT NULL;"
+        ).fetchdf()
 
-def build_result(op_name, p_mean, p_std, p_all, d_mean, d_std, d_all):
-    speedup = p_mean / d_mean if d_mean > 0 else None
+    pm, ps, pr = time_function(pandas_op, repeats)
+    dm, ds, dr = time_function(duckdb_op, repeats)
+    return build_result(pm, ps, pr, dm, ds, dr)
 
-    return {
-        "operation": op_name,
-        "pandas_mean_s": p_mean,
-        "pandas_std_s": p_std,
-        "duckdb_mean_s": d_mean,
-        "duckdb_std_s": d_std,
-        "speedup": speedup,
-        "raw_pandas_runs": p_all,
-        "raw_duckdb_runs": d_all,
-    }
+def bench_fill_nulls(df, repeats=3):
+    def pandas_op():
+        _ = df["value1"].fillna(0)
 
+    def duckdb_op():
+        duckdb_con.register("df", df)
+        duckdb_con.execute(
+            "SELECT COALESCE(value1, 0) AS value1_filled FROM df;"
+        ).fetchdf()
 
-# ----------------------------------------------------------
-# Benchmark Dispatcher
-# ----------------------------------------------------------
+    pm, ps, pr = time_function(pandas_op, repeats)
+    dm, ds, dr = time_function(duckdb_op, repeats)
+    return build_result(pm, ps, pr, dm, ds, dr)
 
-def run_benchmark(operation, df=None, repeats=3):
-    repeats = int(repeats)
+def bench_distinct_count(df, repeats=3):
+    def pandas_op():
+        _ = df["category"].nunique()
 
-    if operation == "Filter": return bench_filter(df, repeats)
-    if operation == "Groupby": return bench_groupby(df, repeats)
-    if operation == "Join": return bench_join(df, repeats)
-    if operation == "Write Parquet": return bench_write_parquet(df, repeats)
+    def duckdb_op():
+        duckdb_con.register("df", df)
+        duckdb_con.execute(
+            "SELECT COUNT(DISTINCT category) AS distinct_categories FROM df;"
+        ).fetchdf()
 
-    raise ValueError(f"Unsupported operation: {operation}")
+    pm, ps, pr = time_function(pandas_op, repeats)
+    dm, ds, dr = time_function(duckdb_op, repeats)
+    return build_result(pm, ps, pr, dm, ds, dr)
 
+def bench_materialize_parquet(df, repeats=3):
+    def pandas_op():
+        agg = df.groupby("category").agg(
+            mean_value1=("value1", "mean"),
+            sum_value2=("value2", "sum"),
+        )
+        agg.to_parquet("pandas_grouped.parquet")
 
-# ----------------------------------------------------------
-# Chart generator (PIL Image)
-# ----------------------------------------------------------
+    def duckdb_op():
+        duckdb_con.register("df", df)
+        duckdb_con.execute(
+            "CREATE OR REPLACE TEMP TABLE agg AS "
+            "SELECT category, AVG(value1) AS mean_value1, "
+            "SUM(value2) AS sum_value2 FROM df GROUP BY category;"
+        )
+        duckdb_con.execute(
+            "COPY agg TO 'duck_grouped.parquet' (FORMAT PARQUET);"
+        )
+
+    pm, ps, pr = time_function(pandas_op, repeats)
+    dm, ds, dr = time_function(duckdb_op, repeats)
+    return build_result(pm, ps, pr, dm, ds, dr)
+
+# ----------------- 5. Operation Registry -----------------
+
+OPERATIONS = {
+    "Filter (simple WHERE)": {
+        "sql": "SELECT * FROM df WHERE value1 > 0.5 AND category = 'cat_1';",
+        "pandas": 'df[(df["value1"] > 0.5) & (df["category"] == "cat_1")]',
+        "bench": bench_filter_simple,
+    },
+    "Filter (complex WHERE + date range)": {
+        "sql": (
+            "SELECT * FROM df\n"
+            "WHERE value1 > 0\n"
+            "  AND value2 < 12\n"
+            "  AND date BETWEEN DATE '2020-03-01' AND DATE '2020-09-30';"
+        ),
+        "pandas": (
+            'df[(df["value1"] > 0)\n'
+            '   & (df["value2"] < 12)\n'
+            '   & (df["date"].between("2020-03-01", "2020-09-30"))]'
+        ),
+        "bench": bench_filter_complex,
+    },
+    "Groupby (multi-agg)": {
+        "sql": (
+            "SELECT category,\n"
+            "       AVG(value1) AS mean_value1,\n"
+            "       SUM(value2) AS sum_value2,\n"
+            "       COUNT(*)    AS cnt\n"
+            "FROM df\n"
+            "GROUP BY category;"
+        ),
+        "pandas": (
+            'df.groupby("category").agg(\n'
+            '    mean_value1=("value1", "mean"),\n'
+            '    sum_value2=("value2", "sum"),\n'
+            '    cnt=("id", "count"),\n'
+            ")"
+        ),
+        "bench": bench_groupby_basic,
+    },
+    "Groupby + HAVING": {
+        "sql": (
+            "SELECT category,\n"
+            "       AVG(value1) AS mean_value1\n"
+            "FROM df\n"
+            "GROUP BY category\n"
+            "HAVING AVG(value1) > 0;"
+        ),
+        "pandas": (
+            'agg = df.groupby("category").agg(mean_value1=("value1", "mean"))\n'
+            'agg[agg["mean_value1"] > 0]'
+        ),
+        "bench": bench_groupby_having,
+    },
+    "Join (fact ⨝ dim on category)": {
+        "sql": (
+            "WITH dim AS (\n"
+            "  SELECT category, AVG(value1) AS weight\n"
+            "  FROM df\n"
+            "  GROUP BY category\n"
+            ")\n"
+            "SELECT d.*, dim.weight\n"
+            "FROM df d\n"
+            "LEFT JOIN dim ON d.category = dim.category;"
+        ),
+        "pandas": (
+            "dim = df.groupby('category', as_index=False)['value1']"
+            ".mean().rename(columns={'value1':'weight'})\n"
+            "df.merge(dim, on='category', how='left')"
+        ),
+        "bench": bench_join,
+    },
+    "Order By (value1 DESC, date ASC)": {
+        "sql": "SELECT * FROM df ORDER BY value1 DESC, date ASC;",
+        "pandas": 'df.sort_values(["value1", "date"], ascending=[False, True])',
+        "bench": bench_order_by,
+    },
+    "Window: ROW_NUMBER() PARTITION BY category": {
+        "sql": (
+            "SELECT *,\n"
+            "       ROW_NUMBER() OVER (\n"
+            "           PARTITION BY category\n"
+            "           ORDER BY value1 DESC\n"
+            "       ) AS rn\n"
+            "FROM df;"
+        ),
+        "pandas": (
+            'temp = df.sort_values(["category", "value1"], ascending=[True, False])\n'
+            'temp["rn"] = temp.groupby("category").cumcount() + 1'
+        ),
+        "bench": bench_window_row_number,
+    },
+    "Window: Running SUM(value1) OVER (ORDER BY date)": {
+        "sql": (
+            "SELECT *,\n"
+            "       SUM(COALESCE(value1, 0)) OVER (\n"
+            "           ORDER BY date\n"
+            "           ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n"
+            "       ) AS running_sum\n"
+            "FROM df;"
+        ),
+        "pandas": (
+            'temp = df.sort_values("date")\n'
+            'temp["running_sum"] = temp["value1"].fillna(0).cumsum()'
+        ),
+        "bench": bench_window_running_total,
+    },
+    "Drop NULLs (value1 IS NOT NULL)": {
+        "sql": "SELECT * FROM df WHERE value1 IS NOT NULL;",
+        "pandas": 'df[df["value1"].notna()]',
+        "bench": bench_drop_nulls,
+    },
+    "Fill NULLs (COALESCE(value1, 0))": {
+        "sql": "SELECT COALESCE(value1, 0) AS value1_filled FROM df;",
+        "pandas": 'df["value1"].fillna(0)',
+        "bench": bench_fill_nulls,
+    },
+    "Distinct count (COUNT(DISTINCT category))": {
+        "sql": "SELECT COUNT(DISTINCT category) AS distinct_categories FROM df;",
+        "pandas": 'df["category"].nunique()',
+        "bench": bench_distinct_count,
+    },
+    "Materialize Groupby → Parquet": {
+        "sql": (
+            "CREATE OR REPLACE TEMP TABLE agg AS\n"
+            "SELECT category,\n"
+            "       AVG(value1) AS mean_value1,\n"
+            "       SUM(value2) AS sum_value2\n"
+            "FROM df\n"
+            "GROUP BY category;\n"
+            "COPY agg TO 'duck_grouped.parquet' (FORMAT PARQUET);"
+        ),
+        "pandas": (
+            'agg = df.groupby("category").agg(\n'
+            '    mean_value1=("value1", "mean"),\n'
+            '    sum_value2=("value2", "sum"),\n'
+            ")\n"
+            'agg.to_parquet("pandas_grouped.parquet")'
+        ),
+        "bench": bench_materialize_parquet,
+    },
+}
+
+# ----------------- 6. Logic & Formatting -----------------
+
+def run_benchmark(operation_label, df, repeats):
+    if operation_label not in OPERATIONS:
+        raise ValueError("Unknown operation: " + str(operation_label))
+    op_meta = OPERATIONS[operation_label]
+    bench_fn = op_meta["bench"]
+    result = bench_fn(df, repeats)
+    result["operation"] = operation_label
+    return result, op_meta
 
 def generate_chart(result):
-    fig, ax = plt.subplots(figsize=(4, 3))
-
+    fig, ax = plt.subplots(figsize=(6, 4))
     engines = ["Pandas", "DuckDB"]
     times = [result["pandas_mean_s"], result["duckdb_mean_s"]]
-
-    ax.bar(engines, times)
+    colors = ["#1f77b4", "#ff7f0e"]
+    ax.bar(engines, times, color=colors)
     ax.set_ylabel("Time (seconds)")
-    ax.set_title(result["operation"])
-
+    ax.set_title(str(result.get("operation", "Benchmark Result")))
+    for i, v in enumerate(times):
+        ax.text(i, v, "{0:.4f}s".format(v), ha="center", va="bottom")
     buf = io.BytesIO()
     plt.tight_layout()
-    plt.savefig(buf, format="png")
+    plt.savefig(buf, format="png", dpi=100)
     buf.seek(0)
     plt.close(fig)
-
     return Image.open(buf)
 
-
-# ----------------------------------------------------------
-# Markdown result
-# ----------------------------------------------------------
-
-def format_result(result):
+def format_result(result, op_meta):
     speed = result["speedup"]
-    verdict = (
-        f"🚀 **DuckDB is ~{speed:.2f}× faster**"
-        if speed > 1
-        else f"🐼 **Pandas is ~{1/speed:.2f}× faster**"
+    if speed is None or speed <= 0:
+        verdict = "Speedup could not be computed."
+    elif speed > 1:
+        verdict = "DuckDB is about {0:.2f}x faster than Pandas.".format(speed)
+    else:
+        verdict = "Pandas is about {0:.2f}x faster than DuckDB.".format(1.0 / speed)
+
+    sql_code = op_meta["sql"]
+    pandas_code = op_meta["pandas"]
+
+    raw_pandas_list = ["{0:.6f}".format(x) for x in result["raw_pandas_runs"]]
+    raw_duck_list = ["{0:.6f}".format(x) for x in result["raw_duckdb_runs"]]
+
+    raw_pandas = ", ".join(raw_pandas_list)
+    raw_duck = ", ".join(raw_duck_list)
+
+    lines = []
+    lines.append("Benchmark: " + str(result["operation"]))
+    lines.append("")
+    lines.append(
+        "Pandas mean: {0:.6f} s (std {1:.6f})".format(
+            result["pandas_mean_s"], result["pandas_std_s"]
+        )
     )
-
-    md = f"""
-### 🔬 Benchmark Result — {result['operation']}
-
-| Engine | Mean (s) | Std (s) |
-|--------|----------|---------|
-| Pandas | `{result['pandas_mean_s']:.6f}` | `{result['pandas_std_s']:.6f}` |
-| DuckDB | `{result['duckdb_mean_s']:.6f}` | `{result['duckdb_std_s']:.6f}` |
-
-**Verdict:** {verdict}
-
-<details><summary>Raw timings</summary>
-
-- Pandas: `{[round(x,6) for x in result['raw_pandas_runs']]}`
-- DuckDB: `{[round(x,6) for x in result['raw_duckdb_runs']]}`
-</details>
-"""
-    return md
-
-
-# ----------------------------------------------------------
-# Helper to load custom dataset
-# ----------------------------------------------------------
-
-def load_custom_dataset(file):
-    if file.name.endswith(".csv"):
-        return pd.read_csv(file.name)
-    if file.name.endswith(".parquet"):
-        return pd.read_parquet(file.name)
-    if file.name.endswith(".arrow"):
-        return pd.read_feather(file.name)
-    raise ValueError("Unsupported file format")
-
-
-# ----------------------------------------------------------
-# Gradio App
-# ----------------------------------------------------------
+    lines.append(
+        "DuckDB mean: {0:.6f} s (std {1:.6f})".format(
+            result["duckdb_mean_s"], result["duckdb_std_s"]
+        )
+    )
+    lines.append("Verdict: " + verdict)
+    lines.append("")
+    lines.append("Raw timings (seconds):")
+    lines.append("  Pandas: [" + raw_pandas + "]")
+    lines.append("  DuckDB: [" + raw_duck + "]")
+    lines.append("")
+    lines.append("SQL (DuckDB):")
+    lines.append(sql_code)
+    lines.append("")
+    lines.append("Pandas equivalent:")
+    lines.append(pandas_code)
+    return "\n".join(lines)
+
+# ----------------- 7. Gradio App -----------------
 
 theme = gr.themes.Soft(primary_hue="indigo", neutral_hue="slate")
 
-with gr.Blocks(title="DuckDB vs Pandas Benchmark", theme=theme) as demo:
-
-    gr.Markdown("# 🐼 vs 🦆 DuckDB vs Pandas — Performance Playground")
+with gr.Blocks(title="DuckDB vs Pandas — SQL Analytics Benchmark", theme=theme) as demo:
+    gr.Markdown(
+        "# DuckDB vs Pandas — SQL Analytics Benchmark\n\n"
+        "Compare DuckDB (SQL) and Pandas (Python) on realistic analytics operations."
+    )
 
     with gr.Tabs():
-
-        # ==================================================
-        # 🔥 Synthetic Mode
-        # ==================================================
-        with gr.Tab("🔥 Synthetic Dataset Benchmarks"):
-
-            dataset_size = gr.Radio(["100k", "500k", "2M"], value="100k", label="Dataset Size")
-
-            operation_synth = gr.Radio(
-                ["Filter", "Groupby", "Join", "Write Parquet"],
-                label="Operation",
-                value="Filter"
-            )
-
-            repeats_synth = gr.Slider(1, 7, value=3, label="Repeats")
-
-            btn_synth = gr.Button("🚀 Run Benchmark")
-
-            out_md_synth = gr.Markdown()
-            out_chart_synth = gr.Image()
-
-            def synthetic_runner(size, operation, repeats):
-                repeats = int(repeats)
-                n = {"100k": 100_000, "500k": 500_000, "2M": 2_000_000}[size]
-
-                df = generate_data(n)
-                result = run_benchmark(operation, df, repeats)
-                chart = generate_chart(result)
-
-                return format_result(result), chart
+        with gr.Tab("Synthetic Dataset Benchmarks"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    dataset_size = gr.Radio(
+                        ["100k", "500k", "2M"],
+                        value="100k",
+                        label="Dataset Size (synthetic rows)",
+                    )
+                    operation_synth = gr.Dropdown(
+                        choices=list(OPERATIONS.keys()),
+                        value="Filter (simple WHERE)",
+                        label="Operation",
+                    )
+                    repeats_synth = gr.Slider(
+                        1,
+                        7,
+                        value=3,
+                        step=1,
+                        label="Timing repeats (average over N runs)",
+                    )
+                    btn_synth = gr.Button("Run Benchmark", variant="primary")
+
+                with gr.Column(scale=1):
+                    out_chart_synth = gr.Image(label="Performance Chart", type="pil")
+                    out_text_synth = gr.Textbox(label="Result", lines=20)
+
+            def synthetic_runner(size, op, repeats):
+                try:
+                    repeats = int(repeats)
+                    n_map = {"100k": 100000, "500k": 500000, "2M": 2000000}
+                    df = generate_data(n_map[size])
+                    result, meta = run_benchmark(op, df, repeats)
+                    chart = generate_chart(result)
+                    return chart, format_result(result, meta)
+                except Exception:
+                    return None, "Error:\n" + traceback.format_exc()
 
             btn_synth.click(
                 synthetic_runner,
                 [dataset_size, operation_synth, repeats_synth],
-                [out_md_synth, out_chart_synth],
+                [out_chart_synth, out_text_synth],
             )
 
-
-        # ==================================================
-        # 📁 Custom Dataset Mode
-        # ==================================================
-        with gr.Tab("📁 Custom Dataset Upload"):
-
-            file_in = gr.File(label="Upload CSV / Parquet / Arrow")
-            
-            operation_custom = gr.Radio(
-                ["Filter", "Groupby", "Join", "Write Parquet"],
-                label="Operation",
-                value="Filter"
+        with gr.Tab("Custom Dataset Upload"):
+            gr.Markdown(
+                "Your file must contain these columns: id, category, value1, value2, date"
             )
 
-            repeats_custom = gr.Slider(1, 7, value=3, label="Repeats")
-
-            btn_custom = gr.Button("Run on Uploaded Dataset")
-
-            out_md_custom = gr.Markdown()
-            out_chart_custom = gr.Image()
-
-            def custom_runner(file, operation, repeats):
-                repeats = int(repeats)
-                df = load_custom_dataset(file)
-                result = run_benchmark(operation, df, repeats)
-                return format_result(result), generate_chart(result)
+            with gr.Row():
+                with gr.Column(scale=1):
+                    file_in = gr.File(label="Upload CSV / Parquet / Arrow")
+                    operation_custom = gr.Dropdown(
+                        choices=list(OPERATIONS.keys()),
+                        value="Filter (simple WHERE)",
+                        label="Operation",
+                    )
+                    repeats_custom = gr.Slider(
+                        1,
+                        7,
+                        value=3,
+                        step=1,
+                        label="Timing repeats",
+                    )
+                    btn_custom = gr.Button("Run Benchmark", variant="primary")
+
+                with gr.Column(scale=1):
+                    out_chart_custom = gr.Image(label="Performance Chart", type="pil")
+                    out_text_custom = gr.Textbox(label="Result", lines=20)
+
+            def custom_runner(file, op, repeats):
+                try:
+                    repeats = int(repeats)
+                    df = load_custom_dataset(file)
+                    required = {"id", "category", "value1", "value2", "date"}
+                    missing = required - set(df.columns)
+                    if missing:
+                        raise ValueError("Missing columns: " + str(sorted(missing)))
+                    result, meta = run_benchmark(op, df, repeats)
+                    chart = generate_chart(result)
+                    return chart, format_result(result, meta)
+                except Exception:
+                    return None, "Error:\n" + traceback.format_exc()
 
             btn_custom.click(
                 custom_runner,
                 [file_in, operation_custom, repeats_custom],
-                [out_md_custom, out_chart_custom],
+                [out_chart_custom, out_text_custom],
             )
 
 if __name__ == "__main__":