Schema Explorer & Data Visualization

The navigator is a lazy-loaded, engine-shaped introspection tree: it renders each engine's real object hierarchy and terminology rather than forcing a generic layout, and it fetches children on demand so a large catalog never blocks the initial expand. Below the tree, an inspector/definition pane surfaces object detail and DDL.

Engine-Shaped Hierarchy

The namespace level above your objects is labeled and structured to match the connected engine:

• PostgreSQL, SQL Server, Oracle, CockroachDB, TimescaleDB, Snowflake, Redshift, a Schemas level (Oracle schemas are users), then object groups (Tables, Views, Materialized Views, Functions, Procedures, Sequences, Indexes, Triggers).
• MySQL / MariaDB, a Databases level (here a schema is a database), then Tables / Views / Procedures / Functions.
• MongoDB, a Databases level, then Collections; field structure is inferred from sampled documents.
• SQLite, no server or namespace level (single file): object groups sit directly under the connection root.

A relational connection expands roughly as:

connection
  Server   (Server Info, Sessions, Locks, Users, Roles, Tablespaces...)
  Schemas
    public
      Tables
        table_name
          Columns   (name, type, nullable, default, PK/FK/UQ)
          Indexes / Constraints / Triggers / Partitions
      Views / Materialized Views / Functions / Procedures / Sequences / Indexes

Under a Databases-level engine, your own databases sit at the root and system databases are collapsed into a System folder (SQL Server master/model/msdb/tempdb; MySQL information_schema/mysql/performance_schema/sys; MongoDB admin/config/local) so operational objects stay uncluttered until needed.

Server-Level Introspection

Where the engine exposes them, the Server node surfaces live operational metadata alongside static schema, server/version info, active sessions, current locks, users/roles, and tablespaces, so you can inspect who is connected and what is blocked without leaving the navigator. Depth tracks engine capability: rich for the major relational engines, keyspace/label/index-level for the NoSQL families, key-pattern/type/TTL for Redis.

Object Detail & Definitions

Selecting a table opens the inspector with columns (type, nullability, default, constraints, comments), indexes (name, columns, method, uniqueness), constraints (PK, FK with referenced table/column, unique, check), and, where reported, statistics-based approximate row count and on-disk size, no full COUNT(*) scan. Column rows carry type, nullability, default expression (e.g. sequence nextval), and PK/FK/UQ role markers.

Context Actions

Right-clicking a table/view/collection offers:

• Preview top N, retargets the editor to that object's connection, emits a dialect-correct preview query, and runs it: LIMIT (PostgreSQL/MySQL/SQLite), SELECT TOP (SQL Server), FETCH FIRST n ROWS ONLY (Oracle), or .find().limit() (MongoDB).
• Script definition to editor, generates the object's CREATE DDL (table, view, materialized view, function, procedure, trigger, index, sequence). If the engine cannot script that object type, the editor reports why rather than emitting a placeholder.
• Insert name, appends the fully qualified identifier at the cursor without executing.
• Favorite, pins the object into a Favorites section for fast access across a large catalog.
• Copy name, fully qualified (e.g. public.users) to clipboard.

Connection roots expose Connect / Disconnect / Edit connection on hover and via context menu.

Introspection Sources

Depth comes from querying each engine's own catalog rather than a normalized abstraction: information_schema + pg_catalog (PostgreSQL/Cockroach/Timescale), information_schema (MySQL/MariaDB), INFORMATION_SCHEMA + sys views (SQL Server), the ALL_* dictionary views (Oracle), sqlite_master + PRAGMA table_info() (SQLite), listCollections + document sampling (MongoDB), and keyspace scans with per-key type/TTL (Redis). The filter box does case-insensitive partial matching across every object type; clearing it restores the full tree.

Result Visualization

Any result set of two or more columns can be charted inline from the results panel's Chart tab, choose Bar / Line / Pie / Area and map the axis columns; the chart re-renders on any change. Line/area over a time-bucketed dimension (a DATE_TRUNC aggregate, for instance) covers the common trend case; bar for categorical comparison; pie for proportion. Charting is a client-side rendering of the returned rows, not a re-query.

Export

Export operates on the current result set from the results-toolbar export control.