I am building a Notebook Environment for SQL Inside a Database Client

This post is also available on tabularis.dev.

You know the drill. Write a query, get a table. Need to build on that result? Copy-paste into the next query. Need a chart? Export CSV, open a spreadsheet. Want to document the analysis? Paste SQL into a doc and pray nothing drifts.

I got tired of this loop, so I'm building Notebooks into Tabularis — a cell-based SQL analysis environment that lives inside the database client. No Jupyter, no Python runtime, no context switching. Just SQL + markdown cells, inline charts, and a few features that make multi-query analysis way less painful.

It's still in development, but the core works. Here's what it looks like and how it's shaping up.

How It Works

A notebook is a sequence of cells — SQL or markdown. SQL cells run against your database and show results inline with the same data grid from the query editor (sorting, filtering, resizable panels). Markdown cells are for documentation between queries.

Cell References via CTEs

This is the part I'm most excited about.

Any SQL cell can reference another cell's query with {{cell_N}}. At execution time, it gets resolved as a CTE:

-- Cell 1: Base query SELECT customer_id, SUM(amount) AS total FROM orders GROUP BY customer_id

-- Cell 1: Base query SELECT customer_id, SUM(amount) AS total FROM orders GROUP BY customer_id

-- Cell 3: References Cell 1 SELECT * FROM {{cell_1}} WHERE total > 1000`*

Enter fullscreen mode

Exit fullscreen mode

Becomes:

WITH cell_1 AS (  SELECT customer_id, SUM(amount) AS total  FROM orders  GROUP BY customer_id ) SELECT * FROM cell_1 WHERE total > 1000

WITH cell_1 AS (  SELECT customer_id, SUM(amount) AS total  FROM orders  GROUP BY customer_id ) SELECT * FROM cell_1 WHERE total > 1000

Enter fullscreen mode

Exit fullscreen mode

No temp tables, no copy-paste. Change the base query, re-run downstream cells, everything stays in sync. You can chain across multiple cells and every intermediate result stays visible.

Inline Charts

Any result with 2+ columns and at least one row can be charted — bar, line, or pie — directly in the cell. Pick a label column and value columns, done. Config is saved with the cell.

Not meant to replace BI tools. It's for when you're exploring and want a quick visual check before writing the next query.

Parameters

Define once, use everywhere:

@start_date = '2024-01-01' @end_date = '2024-12-31' @min_amount = 500

@start_date = '2024-01-01' @end_date = '2024-12-31' @min_amount = 500

Enter fullscreen mode

Exit fullscreen mode

Every SQL cell with @start_date gets it substituted before execution. Change the value, re-run — all queries pick it up. Great for monthly reports, cohort comparisons, anything where the logic stays the same but inputs change.

Parallel Execution

Not every cell depends on the previous one. Mark independent cells with the lightning bolt icon and they run concurrently during "Run All" instead of waiting in sequence. For notebooks with heavy queries against different tables, this makes a real difference.

Run All + Stop on Error

Ctrl+Shift+Enter runs every SQL cell top to bottom. Stop on Error controls whether it halts at the first failure or keeps going. After execution, a summary card shows succeeded/failed/skipped counts — click a failed cell to jump straight to it.

Multi-Database in One Notebook

Each SQL cell can target a different database connection. Pull from production PostgreSQL in one cell, compare with your analytics SQLite in the next. Works across MySQL, MariaDB, PostgreSQL, and SQLite.

Execution History

Every cell keeps its last 10 runs — timestamp, duration, row count. You can restore any previous query version. Useful when you've been iterating and need to go back.

AI Assist

Each SQL cell has AI and Explain buttons — describe what you want, get SQL back, or break down an existing query. There's also an auto-naming feature: click the sparkles icon and AI generates a cell name based on the content. Named cells show up in a notebook outline for navigation.

Organization

• Collapse cells to show just headers

• Drag and drop to reorder

• Cell names (manual or AI-generated) for identity

• Markdown cells as section dividers

Import / Export

• .tabularis-notebook — JSON with cells, parameters, charts. No result data. Share it, import it, connect to a different DB, run it.

• HTML export — self-contained document with rendered markdown, syntax highlighting, embedded result tables. Dark-themed.

• Individual results export as CSV or JSON.

What's Not Done Yet

Being honest about rough edges:

• Large notebooks (30+ cells) need better virtualization

• Circular reference detection is missing — needs a dependency graph

• Chart customization is minimal (no axis labels, no color palettes)

• Keyboard navigation between cells is partially implemented

• Notebook-level undo/redo doesn't exist yet (cell-level works via Monaco)

Why Build This?

Database clients haven't really evolved beyond "connect, query, see table." Analysis tooling moved forward — Jupyter, Observable, dbt — but the DB client stayed behind.

Notebooks in Tabularis bet that the database client is the right place for exploratory SQL analysis. You already have the connection, the schema, autocomplete, query history. Cells, charts, references and parameters on top of that means the whole workflow — first query to shareable report — happens without switching tools.

It's not a Jupyter replacement. No Python, no R. It's purpose-built for SQL, and for the kind of work most people actually do with their database every day — ad-hoc exploration, report building, data validation, performance investigation — that focus is a feature.

Landing soon. If you want to try it, check out Tabularis.