Here's a quiet truth about data grids: the grid is never the hard part. The database behind it is. You build a beautiful table on top of MySQL, ship it, and six months later someone asks for a dashboard over a billion analytics events — and suddenly your grid, so happy on MySQL, is the bottleneck. The honest answer used to be "rewrite the data layer."

Elyra DataGrid 0.3 has a nicer answer: change one word.

Grid::table('events')->driver('clickhouse');

That's the whole story of this release. The grid learned to speak more than one dialect — so you can put the right database behind it without touching a single line of your columns, filters, editing, or frontend.

Why this matters

Every database is good at something different. ElyraSQL gives you single-pass facets and semantic search. ClickHouse chews through analytical aggregates like they're nothing. SQLite (and its replication-ready cousin, SQL Anywhere) is perfect for embedded, edge, and read-replica scenarios. MySQL is just... everywhere.

Before 0.3, the grid assumed one dialect. Now it has a small, honest driver layer: each backend knows how to speak its own SQL, and degrades gracefully where a feature isn't native. You declare your columns once. You write your filters once. The grid figures out the rest.

The same contains "50%" filter compiles to LIKE ? ESCAPE '\\' on MySQL, LIKE ? ESCAPE '\' on SQLite (whose string literals don't unescape backslashes), and plain LIKE ? on ClickHouse (which escapes backslashes intrinsically). You never think about any of that. That's the point.

How it looks

Same grid definition, four backends:

// Analytics dashboard — ClickHouse
Grid::table('events')->driver('clickhouse')->connection('clickhouse')
    ->column('revenue', type: 'number', aggregatable: true);
// percentiles → quantile(0.95)(revenue), median → median(revenue),
// distinct → uniqExact(...), subtotals → GROUP BY … WITH ROLLUP

// Embedded / edge / replica — SQLite or SQL Anywhere
Grid::table('reports')->driver('sqlite')->connection('sqlite');
Grid::table('reports')->driver('sqlanywhere');   // SQLite-compatible engine

// The classics
Grid::table('sales')->driver('mysql');            // any MySQL server
Grid::table('sales')->driver('elyrasql');         // the flagship (default)

Each driver advertises what it can do, and the engine adapts:

                    ElyraSQL           ClickHouse    MySQL      SQLite / SQL Anywhere
Facets              single-pass        GROUP BY      GROUP BY   GROUP BY
                    FACET()
Percentiles         ✅                 ✅ quantile   —          —
Roll-up subtotals   ✅                 ✅            ✅         —
Full-text / hybrid  ✅                 —             ✅ MATCH   —

No feature disappears silently — an unsupported aggregate throws a clear exception, and everything else (sorting, filtering, paging, grouping, editing, streamed export) just works. Verified end-to-end: we exported a string-keyed SQLite table and ran full aggregate/facet/group queries against a live SQLite database, watching backend: sqlite come back in the timing.

Trees, everywhere now

0.3 also closes a nagging gap. The Vue and Svelte clients had a tree grid — self-referencing parent/child rows with lazy-loaded children — but Livewire didn't. Now it does, and it's one property:

class OrgGrid extends DataGrid
{
    public bool|array $tree = [
        'parentField' => 'parent_id',
        'rootValue' => 0,
        'hasChildrenField' => 'has_children',
    ];
}

Roots load first; expanding a node fetches its children (one query per open node) and slots them in with the right indentation and a chevron in the first column. Collapse, expand, drill three levels deep — it just flattens the visible tree on the server each render. All three clients now do hierarchies the same way.

The unglamorous half (the part that makes it trustworthy)

A release you'd actually run in production is mostly the boring stuff done right. 0.3 quietly landed a full hardening pass:

• Bulk mutations. Batch-saving 50 edited rows or pasting a block from Excel used to fire 50 sequential HTTP calls. Now, with an optional mutateBatch, it's one request, one transaction — with a clean rollback if something's denied.

• Exports that don't fall over. Streaming export moved to standard keyset pagination (WHERE key > ? ORDER BY key LIMIT n) — correct for string/UUID keys, gap-skipping, and flat memory. (ElyraSQL keeps its bounded key-windows, since it can't stream an unbuffered cursor.)

• Search that doesn't scan everything. A search for % or _ is now escaped, so it matches literally instead of quietly turning into an all-rows table scan.

• Clipboard that doesn't corrupt. Copying cells with tabs or newlines now RFC-4180-quotes them, so pasting into Sheets — or back into the grid — never shifts a column.

• Calmer scrolling & cleaner teardown. Fast virtual scrolling debounces into a single fetch, and destroy() now cancels pending timers and drops subscriptions, so nothing fires after a component unmounts.

None of these make a demo gasp. All of them make the difference between "nice prototype" and "I trust this with our data."

Bring your own database

That's Elyra DataGrid 0.3. The grid you already know — columns, filters, inline/batch editing, grouping, virtual scroll, natural-language "ask the grid," export — now sitting comfortably on top of whichever database the job calls for. Start on SQLite locally, run ClickHouse for the analytics view, keep ElyraSQL for the flagship search experience. Same protocol, same three clients, same code.

Change one word. Keep everything else.

composer require elyra/datagrid-server:^0.3

Full driver matrix and connection notes in the Defining grids guide.