ClickHouse

A ClickHouse client that belongs on a Mac.

Connect over ClickHouse's HTTP interface, or to ClickHouse Cloud — where you can sign in through your browser instead of a database password.

Free for a month, then one price. Pricing

ClickHouse

What ClickHouse gets.

The kinds of object that exist on an engine are the kinds the app shows. This is ClickHouse's row of the features table, and what stands behind it.

EngineEditable gridDesignersUsers & RolesDiagram
ClickHouse and ClickHouse Cloud✓✓tables✓✓

Sign in with your browser

For ClickHouse Cloud, choose Cloud SSO or Cloud SSO (Read-Only) and click Sign In with Browser; no database password is needed.

Guide: ClickHouse in the docs

No transactions, and it says so

ClickHouse has no transactions, so grid changes apply statement by statement. Keys are fixed when a table is created, and its columns have no collation: what the engine cannot do is stated, not hidden.

Guide: the table designer

Accounts and grants

Grants at global, database and table level. Read the SQL preview, then create or save; Edit as SQL hands you the script in a query tab instead.

Guide: users and roles

clickhouse-client in a tab

A console tab runs clickhouse-client in a real terminal. A browser sign-in has no console, and neither has a tunnelled connection: the client speaks ClickHouse's native protocol, which a tunnel set up for the HTTP port does not carry.

Guide: console tabs
Connect

Connect to ClickHouse.

Click Add Connection under the sidebar and pick the ClickHouse tile. Paste a connection string — the field reads clickhouse:// addresses — and the fields fill themselves in, or type the host, port, database, user and password. Click Test Connection, then Add.

Default port
8123, the HTTP interface; ClickHouse Cloud uses 8443
SSL
Disabled, Required, Verify Certificate
Sign-in
Password, Cloud SSO or Cloud SSO (Read-Only). With SSO, click Sign In with Browser; no database password is needed. Cloud SSO (Read-Only) asks through ClickHouse Cloud's own gateway, which runs SELECT only and returns at most 384 KB of a result: a larger result is shown in smaller pages.
Console
clickhouse-client — brew install --cask clickhouse. A browser sign-in has no console.
Notes
ClickHouse has no transactions, so grid changes apply statement by statement. Keys are fixed when a table is created, and there are no foreign keys. A ClickHouse primary key is the table's sort key, which several rows may share, so before a grid edit or delete is saved the app counts the rows that share the row's key and refuses the save when there is not exactly one, naming the key. On a MergeTree table the mutation itself carries the same check, so a twin that appears in between leaves it changing nothing, and a count after the save reports that. ClickHouse allows no such check inside a mutation on a replicated table, so there the save finds the row by its key and by every other column whose value it can compare exactly, floating-point columns and arrays, maps and tuples included (an array, map or tuple is compared as the server's own JSON of it, so a map with a repeated key, or an array holding NaN, names its own row), and refuses when more than one row is the same in all of them. It then reads where the row sits in the table, the part and the offset within it, and the mutation names the row by that position and by its plain columns, in one mutation for the whole save: a row that arrives in between, even one the same in every column, sits in another part and is left alone, and a row someone else changed in between is met by nothing and reported. The part is named whole, version and all, so a row someone else deleted ahead of the saved row in between, which moves the rows behind it, leaves the save meeting nothing rather than the next row. The save first asks the server how it stores each edited value, and counts again once its changes are in and before any new row goes in: an edited row by the content it now has, against the rows that already looked like it, and a deleted row's key. A new row never stands in for a change that missed its row. A row that changed under the edit or the delete is reported, and the change kept for another try; so is a row with the same key that arrived while a delete ran, which a count by key cannot tell from a miss. An array, map or tuple is edited as JSON. Before anything is written, the server reads the text as the column's type with the rules an INSERT in JSON uses, and a value the type cannot hold, such as text that is not JSON, a word where a number belongs or a tuple with an element missing, is refused naming the field and the row. Every element is then converted exactly, and a null where the type takes none or a number past the type's range is refused too; what the server read is written back whole, so a long decimal keeps every digit and a map's key may be a number. A change the server cannot apply, such as one that would leave a nested column's arrays of different lengths, fails as it is applied, and ClickHouse keeps retrying it, holding every later change to the table behind it: the save withdraws such a change of its own and says so, with the server's reason, and while an earlier failed change still holds the table up it refuses up front, naming that change. Only the change the server names in its answer is withdrawn, never another writer's, and only on the table whose command failed: a save over joined tables changes one table at a time, since ClickHouse numbers mutations per table. A change is applied part by part, so the notice also names the rows whose changes had landed before the failure, and never says nothing changed unless every row's count says so; where two changes made their rows alike and only one landed, it says the changes may have landed. Where an edited column is one the save cannot compare, such as a FixedString or a JSON document, no count of the row's content can tell whether that part of the edit landed, whether or not the same edit changes a column the save can compare, so the save also counts, before and after, the rows that hold what it was asked to write in every edited column, and expects one more afterwards: a row that already looked like the change in every column stands in for nothing, and a change that did not land is reported and kept. That count is the server's, so it holds however many rows look alike. Text is compared byte for byte, as ClickHouse compares it: é as one character and as e with a combining accent are two values, and an edit from the one to the other is a change. NaN and the infinities show by name, nan, inf and -inf, in a float cell and inside an array, map or tuple, so an array holding NaN names its own row apart from one holding inf. The app never follows an HTTP redirect from the server: a redirect is refused with a message naming where it pointed, so your user name and password reach no other address. A DateTime or DateTime64 cell shows the server's own text, every digit of a DateTime64(9) kept, and a grid edit names its row by that text.

Guide: ClickHouse in the docs Guide: your first connection

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

ServicePortSSL
ClickHouse Cloud8443Verify Certificate

Guide: hosted services

Every engine

One app for the rest of your databases, too.

Every feature is built against one driver contract, so the grid, the designers and the assistant work the same whichever server you open next.

Try it on your own database.

Free for a month, then one price, and never asking you to sign in.

Download DBClient

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