refactor: simplify demo and improve recent results table UI

Remove Datasets and SQL query tabs from the explorer demo, show recent
results in a selectable table instead of a dropdown, and add tab_ui
helpers so mo.stop in result cells does not block the tab layout.

Author: eddietejeda

examples/demo.py

@@ -36,80 +36,31 @@ def _(hm, mo, os):
 def _(hm, workspace):
     client = workspace.client
     status = hm.connections_panel(client)
-    browser = hm.table_browser(client)
-    editor = hm.sql_editor(
-        client,
-        default_sql="SELECT 1 AS ok",
-    )
     recent = hm.recent_results(client, limit=20)
     history = hm.run_history(client, limit=10)
-    return browser, client, editor, history, recent, status
+    return client, history, recent, status
 
 
 @app.cell
 def _(mo):
     mo.md(r"""
     ## HotData explorer
-    Use the tabs below to switch between available workspaces, connection status, dataset browsing, and SQL queries.
+    Use the tabs below to switch between workspaces, connection status, recent results, and run history.
     """)
     return
 
 
 @app.cell
-def _(browser):
-    # Register connection/table widget deps so Marimo reruns layout cells on change.
-    if browser._conn_pick is not None:
-        _ = browser._conn_pick.value
-    _ = browser.table_pick.value
-    return
-
-
-@app.cell
-def _(browser):
-    browser_ui = browser.ui
-    return (browser_ui,)
-
-
-@app.cell
-def _(editor):
-    editor_ui = editor.ui
-    return (editor_ui,)
-
-
-@app.cell
-def _(editor, hm):
-    _run = editor.run.value
-    _rerun = editor.rerun.value
-    _clear = editor.clear.value
-    sql_result = hm.query_result(editor.result)
-    return (sql_result,)
-
-
-@app.cell
-def _(editor_ui, mo, sql_result):
-    sql_tab = mo.vstack([editor_ui, sql_result], gap=2)
-    return (sql_tab,)
-
-
-@app.cell
-def _(hm, recent):
-    recent_result = hm.query_result(recent.result, label="Recent result")
-    return (recent_result,)
-
-
-@app.cell
-def _(mo, recent, recent_result):
-    recent_tab = mo.vstack([recent.ui, recent_result], gap=2)
+def _(recent):
+    recent_tab = recent.tab_ui
     return (recent_tab,)
 
 
 @app.cell
-def _(browser_ui, history, mo, recent_tab, sql_tab, status, workspace):
+def _(history, mo, recent_tab, status, workspace):
     mo.ui.tabs({
         "Workspaces": workspace.ui,
         "Connections": status,
-        "Datasets": browser_ui,
-        "SQL query": sql_tab,
         "Recent results": recent_tab,
         "Run history": history,
     })
@@ -119,10 +70,10 @@ def _(browser_ui, history, mo, recent_tab, sql_tab, status, workspace):
 @app.cell
 def _(client, mo):
     _df = mo.sql(
-        """
+        f"""
         SELECT 1 AS example_value
         """,
-        engine=client,
+        engine=client
     )
     return
 

hotdata_marimo/display.py

@@ -6,8 +6,6 @@
 
 from hotdata_runtime import HotdataClient, QueryResult, workspace_health_lines
 
-from hotdata_marimo._options import empty_dropdown, unique_label_options
-
 
 def query_result(
     result: QueryResult,
@@ -61,36 +59,71 @@ class RecentResults:
     def __init__(self, client: HotdataClient, *, limit: int = 50) -> None:
         self._client = client
         self._results = client.list_recent_results(limit=limit, offset=0)
-        option_pairs = [
-            (f"{r.created_at} · {r.status} · {r.result_id}", r.result_id)
+        self._rows: list[dict[str, object]] = [
+            {
+                "created_at": r.created_at,
+                "status": r.status,
+                "result_id": r.result_id,
+            }
             for r in self._results
         ]
-        options = unique_label_options(option_pairs)
-        self.pick = (
-            empty_dropdown(label="Recent results", message="(no results)")
-            if not options
-            else mo.ui.dropdown(
-                options=options,
+        self.table = (
+            mo.ui.table(
+                self._rows,
                 label="Recent results",
-                full_width=True,
+                pagination=True,
+                page_size=min(10, limit),
+                selection="single",
+                max_height=320,
             )
+            if self._rows
+            else None
         )
 
     @property
     def selected_result_id(self) -> str | None:
-        v = self.pick.value
-        return v if v else None
+        if self.table is None:
+            return None
+        selected = self.table.value
+        if not selected:
+            return None
+        row = selected[0]
+        if not isinstance(row, dict):
+            return None
+        rid = row.get("result_id")
+        return rid if rid else None
 
     @property
     def result(self) -> QueryResult:
         rid = self.selected_result_id
-        mo.stop(rid is None, mo.md("Pick a result id to load."))
+        mo.stop(rid is None, mo.md("Select a result row to load."))
         return self._client.get_result(rid or "")
 
+    @property
+    def result_panel(self):
+        rid = self.selected_result_id
+        if rid is None:
+            return mo.md("_Select a result row to load._")
+        return query_result(self._client.get_result(rid), label="Recent result")
+
+    @property
+    def tab_ui(self):
+        if self.table is not None:
+            _ = self.table.value
+        return mo.vstack([self.ui, self.result_panel], gap=2)
+
     @property
     def ui(self):
-        _ = self.pick.value
-        return mo.vstack([self.pick], gap=1)
+        if self.table is None:
+            return mo.md("_No recent results._")
+        _ = self.table.value
+        return mo.vstack(
+            [
+                mo.md("### Recent results"),
+                self.table,
+            ],
+            gap=1,
+        )
 
 
 def recent_results(client: HotdataClient, *, limit: int = 50) -> RecentResults:

hotdata_marimo/sql_editor.py

@@ -88,33 +88,22 @@ def ui(self):
             gap=1,
         )
 
-    @property
-    def result(self) -> QueryResult:
-        run_n = self.run.value
-        rerun_n = self.rerun.value
-        clear_n = self.clear.value
-
+    def _apply_clear(self, clear_n: int) -> bool:
         if clear_n > 0 and self._last_clear_n != clear_n:
             self._result_cache = None
             self._cached_sql = None
             self._last_clear_n = clear_n
-            mo.stop(True, mo.md("Result cleared. Click **Run on Hotdata** to execute again."))
+            return True
+        return False
 
-        mo.stop(
-            run_n == 0 and rerun_n == 0,
-            mo.md(
-                "**Run on Hotdata** is on the SQL editor UI (a cell that **returns** "
-                "`editor.ui` or `mo.vstack([browser.ui, editor.ui])`). Click it there, "
-                "then this cell will run."
-            ),
-        )
+    def _execute_or_cached(self) -> QueryResult | None:
         sql_text = self.sql.value
+        run_n = self.run.value
+        rerun_n = self.rerun.value
 
         if rerun_n > 0 and rerun_n != self._last_rerun_n:
-            mo.stop(
-                self._cached_sql is None,
-                mo.md("No previous SQL to rerun yet — click **Run on Hotdata** first."),
-            )
+            if self._cached_sql is None:
+                return None
             with mo.status.spinner(
                 title="Running on Hotdata",
                 subtitle="Re-running last query and waiting for results…",
@@ -138,8 +127,69 @@ def result(self) -> QueryResult:
         if self._result_cache is not None and sql_text == self._cached_sql:
             return self._result_cache
 
+        return None
+
+    @property
+    def result_panel(self):
+        from hotdata_marimo.display import query_result
+
+        run_n = self.run.value
+        rerun_n = self.rerun.value
+        clear_n = self.clear.value
+
+        if self._apply_clear(clear_n):
+            return mo.md("Result cleared. Click **Run on Hotdata** to execute again.")
+
+        if run_n == 0 and rerun_n == 0 and self._result_cache is None:
+            return mo.md("_Click **Run on Hotdata** to execute._")
+
+        if rerun_n > 0 and rerun_n != self._last_rerun_n and self._cached_sql is None:
+            return mo.md("No previous SQL to rerun yet — click **Run on Hotdata** first.")
+
+        result = self._execute_or_cached()
+        if result is not None:
+            return query_result(result)
+
+        return mo.md("SQL changed — click **Run on Hotdata** again to execute.")
+
+    @property
+    def tab_ui(self):
+        _ = self.run.value
+        _ = self.rerun.value
+        _ = self.clear.value
+        _ = self.show_history.value
+        return mo.vstack([self.ui, self.result_panel], gap=2)
+
+    @property
+    def result(self) -> QueryResult:
+        run_n = self.run.value
+        rerun_n = self.rerun.value
+        clear_n = self.clear.value
+
+        if self._apply_clear(clear_n):
+            mo.stop(True, mo.md("Result cleared. Click **Run on Hotdata** to execute again."))
+
+        mo.stop(
+            run_n == 0 and rerun_n == 0,
+            mo.md(
+                "**Run on Hotdata** is on the SQL editor UI (a cell that **returns** "
+                "`editor.ui` or `mo.vstack([browser.ui, editor.ui])`). Click it there, "
+                "then this cell will run."
+            ),
+        )
+
+        if rerun_n > 0 and rerun_n != self._last_rerun_n:
+            mo.stop(
+                self._cached_sql is None,
+                mo.md("No previous SQL to rerun yet — click **Run on Hotdata** first."),
+            )
+
+        result = self._execute_or_cached()
+        if result is not None:
+            return result
+
         mo.stop(
-            self._cached_sql is None or sql_text != self._cached_sql,
+            True,
             mo.md("SQL changed — click **Run on Hotdata** again to execute."),
         )
 

tests/test_hotdata_marimo.py

@@ -128,6 +128,28 @@ def test_connections_panel_lists_connections(mock_client):
     assert panel is not None
 
 
+def test_recent_results_table_selection(mock_client):
+    mock_client.list_recent_results.return_value = [
+        SimpleNamespace(
+            created_at="2026-05-18T12:00:00Z",
+            status="succeeded",
+            result_id="res_1",
+        ),
+        SimpleNamespace(
+            created_at="2026-05-18T11:00:00Z",
+            status="failed",
+            result_id="res_2",
+        ),
+    ]
+    table = MagicMock()
+    table.value = [{"result_id": "res_2"}]
+    with patch("hotdata_marimo.display.mo.ui.table", return_value=table):
+        recent = hm.recent_results(mock_client, limit=20)
+    assert recent.selected_result_id == "res_2"
+    table.value = []
+    assert recent.selected_result_id is None
+
+
 def test_table_browser_rebuilds_tables_when_connection_changes(mock_client):
     pick = MagicMock()
     pick.value = ""