Features

Everything the app does, by the work.

Six chapters — connect, query, edit, design, understand, move — each shown with the app's own pictures and clips, and each naming its guide in the docs.

Connect

Twelve engines. One app.

Every feature is built against one driver contract, so the grid, the designers and the assistant work the same whether the server speaks Postgres, Oracle or Redis.

Hosted services get a tile of their own with the port and SSL mode they expect: SupabaseNeonCockroachDBTimescaleDBYugabyteDBValkeyClickHouse Cloud

Guide: hosted services

New connection

Pick a tile, or paste a string.

Choose the engine or the service and the port and SSL mode follow. Paste a connection string and the fields fill themselves in. Test the connection before you save it; a new one is tried before it is filed.

  • Save Password starts off: the app asks when you connect, and forgets when it quits
  • A colour and a Production switch for the servers that matter
  • Folders in the sidebar, and a filter that never dials a server
Guide: the connection editor

Connect safely, wherever the server is.

Keychain and Touch ID

Passwords are Keychain items, never a file, and using one can ask for Touch ID or your login password first. Or save none: leave Save Password off and the app asks when you connect, then forgets the answer when it quits.

Guide: passwords

SSH, SSL, proxies

SSH tunnels (password, RSA, Ed25519 or ECDSA key) that read your ~/.ssh/config the way ssh does, Host entries, jump hosts and keys included, checked against known_hosts; SSL up to full certificate verification; SOCKS5 and HTTP CONNECT proxies, chained with SSH when you need both. AWS IAM sign-in for RDS and Aurora PostgreSQL, the token signed at every connect.

Guide: tunnels and proxies

Production mode

Mark a connection as production and every session starts with auto-commit off. Writes wait for your commit, and the status bar says so.

Guide: production mode

Reconnects that tell the truth

A dropped server is retried on a keepalive; a read is re-run for you, a write reports that it may have applied and asks you to check.

Guide: dropped connections

Move your set-up

Export connections, folders and saved queries as one readable file; import it on another Mac. Passwords come along only behind Touch ID.

Guide: moving connections

Files open as connections

Drop a SQLite or DuckDB file or a .sql script on the window or the Dock; DBClient reads the bytes, not the extension, and opens the right thing. CSV and Parquet files open from the Data File tile.

Guide: opening files

What each engine gets.

Every engine has the sidebar, the grid, the assistant and a door to its own console client. The kinds of object that exist on an engine are the kinds it shows.

EngineEditable gridDesignersUsers & RolesDiagram
PostgreSQL and Supabase, Neon, CockroachDB, TimescaleDB, YugabyteDB✓✓all kinds✓✓
MySQL and MariaDB✓✓tables, triggers, events, sequences on MariaDB✓✓
SQLite✓with table rebuilds✓tables, indexes, triggers—✓
SQL Server✓✓plus synonyms, partition functions and schemes✓✓
Oracle✓✓tables, sequences, types, synonyms, triggers, tablespaces✓✓
IBM Db2✓tables with an enforced key✓tables, indexes, triggers, sequences✓✓
DuckDB and CSV files✓✓tables, sequences—✓
ClickHouse and ClickHouse Cloud✓✓tables✓✓
Databricks SQL warehouses✓managed tables✓Delta tables, views, routines✓✓
MongoDB✓documents—console✓—
Redis and Valkey✓keys—console✓ACL users—

Oracle and IBM Db2 need their makers' client libraries, which the app does not ship. The first Oracle or Db2 connection offers to download the client from Oracle or IBM, checks every file against the digests the app was built with, and keeps it in your Library folder, where the same sheet updates or removes it.

Databricks needs no client: it talks to a SQL warehouse over HTTPS with an access token, one Unity Catalog per connection. ClickHouse Cloud can sign in through your browser instead of a database password.

Guide: engines and server versions

Query

An editor that knows your schema.

A hand-rolled SQL lexer and an outline of the statement drive the highlighting and the completion, so both stay exact and fast.

Editor

Write, run, repeat.

Tables, columns, keywords and functions complete as you type, scoped to the tab's database and in the engine's own dialect; a join is written from the foreign keys, and a CTE's or a subquery's columns complete like a table's. ⌘↩ runs the statement under the cursor, ⇧⌘↩ runs everything, and a selection runs alone. Results land per statement, each with its own grid, log and pager.

  • Syntax highlighting, problem marks as you type, and a formatter (⇧⌘F) that never touches your types
  • Explain before you run; Watch to re-run on an interval
  • Comment a block with ⌘/, duplicate or delete a line, find and replace
  • Tabs remember their editor, results and page — ⇧⌘T reopens the one you closed
Guide: the SQL editor
Palette

⌘K to anywhere.

The command palette searches tables and views, their DDL, the schema diagram, the app's actions and your other connections as you type. Arrows and ↩ run the choice.

  • Open a table, show its CREATE statement, start a designer
  • Switch connection without reaching for the sidebar
  • Works from any tab, on any engine
Guide: the command palette
Console

The engine's own client, in a tab.

A console tab is a real terminal running the client you already know — psql, mysql or mariadb, sqlite3, sqlcmd, clickhouse-client, mongosh, redis-cli, SQL*Plus or SQLcl, db2cli, dbsqlcli — signed in with the connection's own host, port, user and password, through its SSH or proxy tunnel too. Its prompt, history, pager and colours are the client's, not an imitation.

  • The door is always there; without the client, the tab names the Homebrew line that installs it, with a copy button and Check Again
  • The password never goes on the command line: the client reads it from its environment or its own prompt
  • MongoDB and Redis also get a command console as their first-class query surface
  • DuckDB is the one engine without a console: a file allows one process, and the app is it
Guide: console tabs
Tabs

Every tab, one grid.

The strip's grid button shows every open tab across every connection as a card with its first lines. Click one, or walk them with the arrow keys and press Return; Escape closes the overview.

  • One strip across connections, grouped in the sidebar's order
  • Cards preview the query, the browse, the designer
  • ⌘W closes, ⇧⌘T brings the last closed tab back
Guide: tabs and the overview

And around the editor.

A sidebar that scales

Folders of connections, one flat tree that stays quick with 900 tables open, a filter that never dials a server.

Guide: the sidebar

Watch and Explain

Re-run a statement on an interval and see the rows change; read the plan before you run it.

Guide: Explain and Watch

Saved queries and tabs

Queries saved per connection and database, every statement you ran remembered and one ⌘K away, tabs that remember their editor, results and page, ⇧⌘T to bring one back.

Guide: saved queries
Edit

A grid built for editing.

Drawn by AppKit, so 60 columns scroll as fast as 6, and every cell is a real control when you edit it.

Grid

Edit in place, review as SQL, commit once.

A single-table SELECT that covers the primary key is editable — typed editors per column kind, rows added and deleted from the row gutter, joins edited cell by cell against each owning table. ⌘S shows the statements; Commit runs them in one transaction.

  • Excel-style selection: rows, columns, cells, ranges
  • Sort from a header's menu, several columns with ranks
  • Long text and JSON open in their own editor, reformatted on demand
  • Set NULL, revert a cell, discard everything
Guide: editing rows in the grid
Review changes. The exact statements, in one transaction — read them before they run. Review and commit
Export. CSV, JSON, SQL inserts or an Excel workbook — all rows or the selection, copied or saved. Export a result
Show DDL. The CREATE statement rebuilt from the catalog, with a JSON schema a click away. Show DDL
Design

Designers for every kind of object.

Tables, indexes, foreign keys, triggers, events, sequences, types, synonyms, aggregates, operators, extensions, casts, tablespaces, partition functions and schemes, users and roles — each one a tab, each one previewing its SQL. Kinds of object

Structure

Alter a table without writing the ALTER.

Columns load as drafts. Rename, retype, reorder, change a default, toggle NOT NULL, add and drop keys and indexes — the diff becomes ordered statements you can read before you apply them. On SQLite, the full rebuild recipe runs in one transaction.

  • Postgres emits USING casts for type changes
  • MySQL restates the full column, and says so
  • Collations picked from the server's own list, and kept when a column is restated
  • Column and table comments, written the way each engine keeps them
  • What an engine cannot do is a note, not a silent failure
  • Compare two databases and read the script that makes one like the other
Guide: the table designer
Compare

Two schemas, and the script between them.

Pick a source and a target of the same engine, both connected, and the Compare Schemas tab lists every table that differs: columns to add or change, indexes and keys to add or replace, tables the target lacks. The script that brings the target up comes from the designers' own planners, in the target's dialect, one block per table.

  • Staging against production, or one branch's database against another's
  • What only the target has is kept unless you ask to drop it
  • Open it in a query tab on the target and run it there, or copy it
Guide: comparing schemas
Overview

Each database at a glance.

Click a database and see every kind of object it holds with a count, the server's version, and a door to create what is missing. Cards open the same listings the sidebar does.

  • Server-level kinds — extensions, casts, tablespaces, accounts — beside the schema's
  • New Schema, New Table, New Role from one place
  • The diagram and the console, one click away
Guide: the database overview
Users & Roles

Accounts, memberships and grants.

On every engine that has accounts, the sidebar files them under Users & Roles: superusers, connection limits, expiry, role membership and grants at every scope. The role editor writes the GRANTs and REVOKEs for you.

  • Postgres, MySQL, MariaDB, SQL Server, Oracle, IBM Db2, Databricks, MongoDB, Redis ACLs, ClickHouse
  • SQL Server's three-state DENY handled as its own thing
  • Every change previewed as SQL
Guide: users and roles
Understand

Pictures of your data.

Diagram

The schema as a diagram.

Drawn from real foreign keys, laid out by relationship, edges routed around boxes. Drag tables; the layout keeps your placements and arranges the rest around them.

  • Self-references and multiple keys between two tables drawn distinctly
  • Filter to a name and the picture narrows
  • Double-click a table to open it
Guide: the schema diagram
Charts

A chart of any result.

Bar, line, area, pie and scatter over the result you already have. Choose the X column, the measures, a series column and the aggregate; the chart follows re-runs.

  • A pie folds its long tail into Other
  • Eight-colour palette validated for both appearances
  • Toggle back to the grid at any time
Guide: charts
Assistant

An assistant that reads, never writes.

Ask in plain words. The assistant sees your schema, runs read-only queries to check its answer, and replies with tables and SQL. A statement that would change data is handed back to you as text — the guard is code, not a prompt.

  • Claude, OpenAI, Gemini, xAI, DeepSeek, Mistral — your key, your choice
  • Streaming replies; one click puts the SQL in the editor
  • Inline suggestions in the editor, which you can switch off
Guide: the AI assistant
Move data

In, out, and across engines.

A table is not stuck where it was made. Drag it to another server, or take its rows away as a file and bring others in.

Copy

Drag a table to another engine.

Drop a table from one connection onto another's database and a sheet shows what will run: the CREATE in the target's dialect, the rows to copy, structure or data or both. Tables move between any two of the ten SQL engines, columns and types translated; views and routines move where the dialect matches.

  • PostgreSQL to SQLite, MySQL to DuckDB, Oracle to Db2, and every other pair
  • Replace or keep what is already there
  • One transaction where the target has them
Guide: copying between engines
In and out

Export, read the DDL, import.

Export the rows in front of you as CSV, JSON, SQL inserts or an Excel workbook, copied or saved. Read any object's CREATE statement. Import a CSV into a table with a header check, column mapping and NULL handling, in one transaction.

  • All rows or the selection
  • DDL for tables, views, routines, types and the rest
  • The import opens the table it filled
Guide: importing a CSV
Backups: dump and restore

A whole database out, and back in.

Dump Database… runs the engine's own tool — pg_dump, mysqldump, sqlite3 or mongodump — with the file, the scope and the connection's settings filled in, in a console tab that shows the tool's own output and, at its foot, how far the job has got. Every dump that finishes is listed under Backups, a double-click from Restore, and the file stays where you chose to write it: no hidden folder, no schedules. Restore Database… reads any file back the same way with psql, mysql, sqlite3 or mongorestore.

  • Structure, data, or both
  • Backups per connection: each file with its size and date, Restore a double-click away, and the Trash for the ones you are done with
  • The console's password and tunnel handling, so nothing is typed twice
  • A missing tool is named, with its Homebrew line
Guide: backups, dump and restore

Try it on your own database.

Free for the databases on your Mac, and never asking you to sign in.

Download DBClient

$brew install --cask az-code-lab/taps/dbclient