How many databases? Sixteen, twenty-six, or forty-two
Three different true answers to the simplest question anyone asks about a database tool, and why the registry behind them records a refusal as carefully as it records a success.
Blog
Notes, arguments and the decisions they turned into
A dated record of what we discussed, what broke afterwards and what we chose to do about it — kept as written rather than tidied up. It continues into the work in front of us: databases, SQL and NoSQL, LLMs and agents.
What one interface across seventeen engines actually costs
One tree, one editor and one results grid for relational, document, key-value, analytical, search and federated engines — and the capability flags that stop that promise from breaking on the fourth engine.
The admin-only audit trail of executed queries
A searchable history of statements, outcomes and error detail, readable by admins only, and on this engine it also records what the agent was permitted to run.
Nine servers, one connection type, different answers
MariaDB, Percona, TiDB, Vitess and five more arrive through the same MySQL connection, and protocol compatibility is not capability compatibility.
What a pasted managed PostgreSQL URL configures
Host-heuristic SSL turns encryption on without verifying the certificate, and two sslmode values are declined by name rather than guessed at.
MongoDB slow queries stay empty until you enable the profiler
The panel names the command to run instead of showing a blank table, and the metrics beside it are omitted rather than reported as zero.
With performance_schema off, MySQL metrics are absent not zero
Cache hit ratio, queries per second and buffer-pool usage are omitted rather than defaulted, and two more figures mean less than their names suggest.
Which PostgreSQL health numbers need an extension or a grant
A tour of the health surface organised by what is missing and why, because a panel that reads Not measured is the only version an operator can act on.
Connecting ScyllaDB through the Cassandra integration
The editor, the object browser and every CQL type read back identically, and the panels that go quiet do so because one virtual keyspace is not there.
Redis over TLS, and what the rediss scheme does not decide
A pasted rediss URL selects encryption without verification, because nothing in a URL says whose certificate to trust; verification stays an explicit choice.
Browsing an un-indexed Couchbase collection
On recent server versions a sequential scan makes an un-indexed keyspace open slowly, so a primary index is a recommendation now rather than a prerequisite.
MongoDB has no constraint for a diagram to discover
The empty relation list here means impossible rather than none found, and the relationships a document model leaves for you to know live in the shape and in the pipeline.
Trino refuses a password over plain HTTP
Measured against a coordinator with authentication switched off, a basic auth header over plain HTTP still answers 401, so the connection is refused early.
TLS to ClickHouse, and why a self-signed node fails
An https URL sets TLS and moves the default port, but only the platform trust store applies, so a custom CA has nowhere to go on this transport.
DuckDB storage answers, sessions and slow queries do not exist
Two catalog functions other engines have are absent here, so both panels stay empty carrying the engine own error, and table bytes are block-granular.
A SQLite connection is a path on the server
There is no network protocol, so the form collapses to one input and a remote user of a hosted deployment cannot open a file from their own machine.
Reading MySQL EXPLAIN FORMAT=JSON as a plan tree
What the plan tree answers on MySQL, and where the surrounding introspection runs out: index figures here are estimates of distinct values.
The Explain button runs your query, the agent plan read does not
Two EXPLAIN forms with different consequences: the editor emits the executing one, and the agent path emits the planning one only.
The tool goes to the data
Why a database IDE belongs in the network beside the database, and what that constraint forces the architecture to look like.
CQL has no EXPLAIN, so the tab is hidden
The keyword is not in the grammar at all, and the only alternative profiles a statement that has already run, which is not a plan and is not offered as one.
What Redis monitoring reads and what returns nothing
Health, performance, slow log and clients all derive from Redis introspection commands, while the table and index panels come back empty because Redis has neither.
Writing SQL++ that starts with the document key
Selecting everything nests the document and drops the key, so generated statements project it explicitly, and that alias is why cell editing is switched off.
The MongoDB editor takes a JSON command, not shell syntax
A statement beginning db. cannot run here at all, and the two operations that look alike have very different default bounds on the result set.
Paging Trino, and the session settings that do not stick
The clause order is transposed for you and a trailing semicolon is a syntax error, while a session setting succeeds and then affects nothing.
Read-only is Druid here, not the integration
Update and delete are not in this SQL anywhere, create is not in the grammar, and the refusals are surfaced word for word instead of rewritten.
Hiding an edit control that could only ever fail
A bare update statement answers not implemented on this engine, so no editable cell is offered, and the documented route reports zero rows changed.
One DuckDB file admits one process, readers included
A second read-only process is refused with the same lock error as a second writer, which makes two Studio replicas on one file a broken configuration.
A SQLite plan tree with no numbers on it
The query plan returns step descriptions and nothing else, so the rendering shows structure and answers index questions rather than cost questions.
The widest DMV surface here, and the grant it depends on
Real blocked-session detection and real index seek and scan counts are things most engines cannot give, and a restricted login still sees none of them.
Connecting to Oracle without installing the Instant Client
Thin mode is the default and needs no native client, and the field people get wrong is the one Oracle actually connects to: a service, not a database name.
A MySQL ER diagram is bounded by one database
Every introspection query binds to the connected database, so a reference that crosses schemas simply does not appear as an edge on the diagram.
Foreign-key diagrams on a schema with a hundred tables
The schema tree renders before relationships arrive, and every introspection CTE is materialized on purpose: a 122-table read measured about 295 seconds before the change and about 2.6 seconds after.
The quoting mistake that returns zero rows and no error
A double-quoted identifier is a string literal here, so a filter on one compares two literals and answers nothing with a perfectly successful response.
This editor sends Elasticsearch SQL, not the query DSL
There are no writes in this grammar at all, no second page, and a trailing semicolon is a syntax error, so the list of edges is the useful part.
Three Cassandra panels refuse rather than report a zero
Table, index and storage statistics send no statement at all and carry the measurement behind the refusal, because no honest count or size exists to publish.
Three ways a panel can say nothing, and why they differ
Two panels refuse with their reason, one stays empty in the engine's own words, a third reads not measured, and each of those is a different claim about the database.
A user star row in the Redis tree is not an object
Prefix groups come from a bounded cursor scan, so several per-row actions are hidden rather than offered against something no command can address.
Couchbase plan trees are estimates, and minus one means none
This dialect has no analyze form, so the direct action and the background pre-warm show the same estimate, and a negative cost renders as no estimate.
The MongoDB field list is inferred from a hundred documents
There is no catalog to read, so the sidebar samples each collection and states its own reach - three levels deep, arrays closed, two hundred fields.
Why a Trino diagram draws boxes and never edges
The catalog views a connector could declare a key through do not exist here, so the empty edge set is the engine answer rather than an empty schema.
Druid has no query sessions, so the panel shows tasks
Rows come from the task table and every column is relabelled to say so, because there is no session catalog and no query log anywhere to read.
ClickHouse diagrams show structure without relations
An empty edge list here is the engine answer, not an unfinished read: no engine, no table setting and no DDL declares a foreign key anywhere.
Querying Parquet and CSV from the DuckDB editor
File-reaching SQL works on the writable editor connection and is refused under the read-only agent handle, so the capability has to be stated with that split.
Connecting to a hosted libSQL database with a token
The credential is an auth token rather than a password and the database is the host, so the dialog renders no user name and no database input at all.
On a shared instance a SQLite path is an access decision
Path validation rejects a null byte and nothing else, so any logged-in user can open any SQLite file the Studio process is able to read.
Three quiet fidelity limits in a T-SQL result grid
Wide integers and high-scale decimals arrive as JavaScript numbers, only the first result set of a batch is read, and one paged statement is not recognised.
Two Oracle types that lose information on the way to a grid
A wide NUMBER arrives as a double and drops digits, and a timestamp with a zone folds its offset into UTC, so both are recorded rather than smoothed over.
A MySQL connection URI skips your SSL and timezone settings
Supplying a connection string takes a different branch entirely, so the SSL panel, the timezone and cloud detection stop applying and must live in the URI.
How the editor bounds a PostgreSQL result set
Automatic LIMIT injection applies to unbounded SELECT and CTE-SELECT statements only, and there is one statement shape it deliberately leaves alone.
Connecting to OpenSearch when the security plugin is on
A default distribution serves HTTPS with a self-signed certificate on the same port, and no custom CA can be supplied on this transport.
The mapping is the schema, and selecting everything is not
An index that maps container fields answers a select-everything statement with no columns at all, so the schema tree is built from the mapping instead.
The Cassandra field no other connection asks for
The driver refuses to build a load-balancing policy without a local data centre, which is why that field sits in the open rather than under Advanced.
Five verbs over an ordered keyspace, with a catalog on top
The whole grammar is get, put, delete, prefix and range, and yet the tree still shows declared columns for the namespaces that have them.
Four other servers behind one Redis connection
There is no separate connection type and no per-server branch, so the version panel shows the compatibility level a server publishes, not its product release.
The Couchbase role your monitoring panels depend on
Without the query system catalog role, slow queries and sessions are empty and denied metrics are omitted rather than reported as zero.
The MongoDB login failure that is not a wrong password
authSource names the database the credentials live in, not the one you are opening, and getting it wrong fails exactly like a bad password.
Monitoring a query engine that stores nothing
Nodes, sessions, slow queries and per-catalog connectors all report, while database size is N/A rather than zero, because there is no storage to measure.
Connecting to Apache Druid on the Router or the Broker
Both ports serve the identical SQL endpoint and nothing in the connection knows which it reached, and there is no database field because there is one catalog.
Monitoring ClickHouse from its own system tables
Every ClickHouse monitoring panel is a read of a catalog the server already maintains, with two boundaries: a setting that empties one panel, and a counter nobody publishes.
DuckDB plans are estimates here, permanently
The timing form of EXPLAIN executes the statement it was asked to explain, so it is never emitted and no measured node timings are published.
Connecting to a self-hosted libSQL server
A server started without authentication takes no token at all, and sending an empty one is rejected rather than treated as an anonymous connection.
Why the SQLite editor has no transaction controls
The provider holds no session across two requests, so the begin, commit and rollback controls are withheld rather than offered and then failed.
A plan that needs a session, and a path that has none
The showplan setting is session-level state and the explain path sends one statement, so the capability is declared false and the action is hidden.
Why there is no Explain action on an Oracle connection
Oracle has EXPLAIN PLAN and DBMS_XPLAN; what is missing is a two-statement wrapper, so the capability is declared false and the action is hidden.
Connecting to MySQL in a container, and what the pool honours
Port 3306 with the fixture credentials, the container-network case, and the pool settings that are quietly ignored because the driver model differs.
Connecting Studio to PostgreSQL running in Docker
The container-to-container case is the one that breaks: when Studio is itself a container, localhost is its own loopback and the service name is the fix.
One closed index and the storage figure becomes N/A
A failed cluster read produces no storage row at all rather than one claiming zero bytes, and a partial sum is refused for exactly the same reason.
When the index says two documents and the query says one
Nested elements are stored as documents of their own, so the panel and the editor legitimately disagree, and one panel asks the cluster nothing at all.
Paging CQL, and the running statement you cannot stop
A second page is refused with its reason rather than silently re-serving the first, and there is no cancel path at all on this engine to fall back on.
Opening a LibreDB file takes an exclusive lock
There is no host, no port and no server, and the lock sidecar means command-line tooling cannot hold the same file while a connection is open.
Telling a plan-mode model what its Redis inventory really is
Because the rows are groupings from a bounded scan, the plan rules carry a sentence saying so, what a command may name instead, and how far the list reaches.
Connecting to Couchbase Capella and the bucket you type in
A managed endpoint carries neither a port nor a bucket path, so the scheme supplies the port and the TLS mode while the bucket is typed by hand and nothing is invented for it.
Connecting to MongoDB Atlas and what the URI decides for you
An SRV URI implies TLS in the driver and maps the form to a verifying mode, but two of the five SSL choices build the same options object.
Trino plans are planned, never analyzed
Only the planning form is ever emitted, because the analyze form executes the statement and a plan view reaching object storage twice is a real invoice.
A Druid plan tree with no cost anywhere on it
The plan returns the native query the cluster will run, rendered in its own operator vocabulary, and the planner publishes no cost and no row estimate.
Connecting to ClickHouse over the HTTP interface
Port 8123 is the whole transport, the native port is never used, and a permission denial arrives as a 500, so failures are read by exception code.
DuckDB diagrams are scoped to the catalog you opened
Foreign keys come from a single bulk read of the constraint catalog, and every catalog statement the DuckDB provider issues is scoped to the current database.
On libSQL: read-only is a credential you create
The server refuses the pragma a database-native read-only profile depends on, so the boundary moves from the session to the token the database issues.
There is no SQLite server to monitor
Health is an integrity check, a journal mode and file sizes, and one per-table figure depends on which built-in driver the deployment is running.
SQL Server connects encrypted but unauthenticated by default
Encryption is on out of the box while certificate validation is off for any host that is not the recognised managed one, and two named modes do not pin a CA.
Oracle monitoring depth is a privilege question
A least-privilege application user gets a dashboard that renders with gaps, because each dynamic-view read is guarded on its own rather than as one block.
Stopping a runaway MySQL query is cancellation, not a timeout
No server-side statement timeout is wired into the pool, so nothing kills a long query on its own and cancellation is an explicit act with a caveat.
Where the read-only boundary lives on a PostgreSQL agent run
Containment is the database itself - a read-only transaction, exactly one statement on the extended protocol, then ROLLBACK and DISCARD ALL.
Steering a plan-mode draft away from the query DSL
A plan run once answered with a native aggregation body, correct for the cluster and unrunnable in the editor, so the contract now names the dialect outright.
Connecting to Elasticsearch with four fields and no database
An index has no namespace above it, so a database selector would be a control with no effect, and a self-signed cluster certificate has nowhere to go here.
No constraints to discover, and a column order to rebuild
The catalog reports no position for regular columns and sorts by name, so the tree rebuilds the order a where clause actually needs.
What a plan-mode model is told about a LibreDB file
The grounding read is bounded by the provider itself, and the plan rules say outright that the rows are groupings derived from one scan.
Connecting to Redis with an ACL user that cannot run INFO
A Redis ACL user without the INFO grant connects and browses keys, while health, overview and performance raise a permission error and the connection test reports degraded.
You configure the management port, the query port is discovered
Only the management port is stored, and the query endpoint comes from the cluster's own node services, preferring the external address it advertises.
Plan mode on MongoDB, where the safety checks decline
The read-only guard and the identifier reader are SQL readers, so on a MongoDB draft they record that they do not apply instead of passing it.
On a Trino connection the database field is a catalog
Pinning a catalog scopes the whole tree two levels deep, and a connection that pins none still connects and runs fully qualified statements with no tree.
A missing Druid datasource is an availability question first
Marking segments unused removes a datasource from the catalog entirely, and a stopped node makes an existing one answer with the same error as a typo.
Reading ClickHouse plans as JSON trees
The estimated plan is the only plan there is, because this engine never executes the statement to produce one, so nothing in the view was measured.
Read-only mode is not the DuckDB boundary, external access is
Under read-only access alone, file copies, exports, extension installs and filesystem reads all succeeded while an insert was refused in the same session.
Stateless requests mean there is no session to count
Active connections are absent rather than zero and no connection ceiling is published, while table and index bytes are real because the storage view answers.
Two controls, because one was not enough on SQLite
A read-only open reads the query-only pragma back as off, so the profile sets it too and re-verifies it before every statement it sends.
What silently degrades on a managed SQL Server database
The one managed host the code recognises by name switches certificate validation on, and the same move narrows the monitoring and maintenance surface.
Oracle diagrams are scoped to the connecting user
Five bulk dictionary reads build the tree regardless of table count, and every one of them is filtered by owner, so other schemas are simply not drawn.
Agent plan mode on MySQL drafts; it does not execute
The tool-using run ends engine-unsupported here, so the useful post is what plan mode does instead: read the real schema and hand a statement to a person.
Creating the PostgreSQL role agent mode will accept
Agent AUTO mode refuses a superuser connection outright, so the deployment task is a login holding CONNECT, USAGE and SELECT and nothing else.