DBR

DBR is a VS Code extension for browsing and querying Databricks, ClickHouse, PostgreSQL, Hasura-backed PostgreSQL, and Redis from a single sidebar.

Features

Multiple saved connections (Databricks, ClickHouse, PostgreSQL, Hasura, Redis)
Secure credential persistence using VS Code SecretStorage
Sidebar tree: connection -> schema -> table
Drag-and-drop connection reordering with visible position indicators
Table browser with paging and SQL filter
Custom query panel with result grid
Table schema viewer
TypeScript VS Code shell with a Go bridge backend for ClickHouse, Databricks, PostgreSQL, Hasura, and Redis
Reusable add/edit connection panel — reopening the form reuses the same tab
Live two-way sync between connection string and individual fields (ClickHouse, Databricks, PostgreSQL)
Open table in the existing tab (row click) or a new tab (inline button)
Right-click a table to open an auto-run row count query in the SQL editor
Right-click table rows to delete an item from the current table context
Drag a table onto a target connection/schema/database to move it there; same-connection moves prefer server-side rename/copy instead of pulling rows locally
Stream a table to any connection, including the same connection, with explicit copy or move mode
Multi-select table actions now include stream-to-connection, and multi-table drag/drop reuses the same batch transfer flow
Right-click a schema or table to copy its fully qualified name (FQN)
Right-click a schema to stream all tables to a destination schema in one action
Right-click one or multiple selected schemas to drop them in one action (CASCADE)
ClickHouse performance dashboard from the connection context menu (live metrics/events plus query-log history for slow queries, top queries, top users, and tuning insights when system.query_log is available)
Right-click PostgreSQL connection nodes to create databases, and PostgreSQL database or Databricks catalog nodes to create schemas
Right-click PostgreSQL, Hasura, or ClickHouse connection nodes to manage users and ACL entries from a dedicated admin panel
The admin panel uses a selectable user list with quick actions (add user, change password, grant/revoke, drop), and ACL details are shown for the selected user with database filter defaults from the current database node

Quick Start

Open the DBR view in the VS Code activity bar.
Select Add Connection.
Choose your database type and enter connection details.
Expand the connection tree to browse objects or open a table/query view.

Go bridge runtime

DBR still requires a TypeScript entrypoint because VS Code extensions run inside the Node-based extension host. The data bridge is now ported to Go for all supported engines, while the VS Code shell remains in TypeScript.

The bridge runtime itself is now Go-only. The extension keeps one long-lived Go child process alive over stdio, tags requests with request IDs, and reuses Go-side PostgreSQL pools plus shared HTTP/token caches across requests. The local packaging flow builds and includes the host binary automatically.

If you want to build the helper manually:

npm run build:go-bridge

On local installs, npm run install:local packages the host-built binary under bin/, so the installed extension can call the Go bridge directly on that same machine.

Table/schema streaming no longer pages row batches through the TypeScript extension host. Target-table prep, dependency ordering, same-connection move/copy decisions, row reads, batch inserts, and row normalization now run inside the Go bridge, and only summary counts come back to the VS Code shell.

ClickHouse performance snapshots and engine-aware create database/schema actions are also executed inside the Go bridge now. The TypeScript layer only triggers those actions and renders the resulting UI.

Table import execution also runs inside the Go bridge now. The TypeScript shell still collects user-facing import options, but workbook sheet inspection, CSV/XLSX parsing, type inference, create-table, truncate, insert batching, and SQL generation are executed in Go.

The import workflow no longer loads the full file into memory before inserting. File inspection now scans rows in a streaming pass, and importTable streams rows from CSV/XLSX into batched inserts while keeping the existing progress UI.

SQL completion and suggestion behavior is now consolidated behind a single Go bridge action for both the VS Code SQL editor and the table-panel CodeMirror editor. The Go bridge now owns SQL token parsing, context detection, alias/table reference parsing, metadata lookups, ranking, SQL keywords, engine-specific functions, and snippet suggestions, while the TypeScript shell only forwards the SQL text before the cursor and renders the returned completion items.

The TypeScript shell now also keeps short-lived request caches for SQL completion requests and nested tree child loads. That keeps repeated hover/expand/type interactions from bouncing into Go on every identical request, while explicit refresh and connection-change flows still invalidate the cache immediately.

Sidebar tree child loading is now also normalized behind a single Go bridge action. The TypeScript tree provider keeps VS Code state, icons, drag/drop, and notifications, while Go builds catalog/database/schema/table children, Redis key groups, table stats, and table metadata nodes.

Export execution is also Go-owned now. Table export commands and webview CSV/XLSX export both call Go bridge actions, so the extension host no longer carries direct ClickHouse CSV streaming code or the exceljs dependency.

Long-running import, export, and stream operations can now be canceled from the VS Code progress notification. The TypeScript shell forwards cancellation to the long-lived Go bridge over the existing stdio request-ID protocol instead of restarting the whole worker.

Those operations also stream live progress updates back into the same notification now, so schema streams, table transfers, and import/export batches show ongoing status again instead of only a start/end message.

For ClickHouse table export to CSV, DBR now reports byte-level streaming progress from the Go bridge while the file is being written, so large exports show actual written bytes and percentage when the response length is known.

For PostgreSQL, Hasura, and Databricks table export, DBR now streams rows from the engine layer into the export writer instead of first building one full in-memory QueryResult for the whole export. CSV rows stream directly into the destination file, and XLSX export streams rows through excelize.StreamWriter before the workbook is serialized to disk.

Connection setup

ClickHouse HTTP

Provide either a full connection string or the individual fields — they stay in sync as you type.

Connection string format:

http://user:password@host:8123/?database=default

Required:

host (example: http://localhost:8123)
database
username
password

Databricks

Provide either a full connection string or the individual fields — they stay in sync as you type.

Connection string format:

<host>/<http-path>?token=<pat>
<host>/<http-path>?auth_type=oauth-m2m&client_id=<id>&client_secret=<secret>

Individual fields:

host (example: https://dbc-xxx.cloud.databricks.com)
HTTP path (example: /sql/1.0/warehouses/<warehouse-id>) — warehouse ID is derived from this
PAT token or client ID + client secret (M2M)
catalog (optional)
default schema (optional)

PostgreSQL

Provide either a full connection string or the individual fields — they stay in sync as you type.

Connection string format:

postgresql://user:password@host:5432/database?schema=public

Individual fields:

host (example: localhost)
port (default: 5432)
database
username
password
default schema (optional)

Hasura

Provide the Hasura HTTP endpoint directly.

Required:

host (example: http://localhost/hasura)
admin secret

Optional:

default schema (default: public)

DB Browser lists Hasura sources in the sidebar tree (as database nodes) and uses the selected node as the active source for run_sql.

Table Panel Behaviour

Action	Result
Click a table row in the sidebar	Opens (or reuses) a single table tab
Click the `$(open-preview)` inline button	Always opens a new independent tab
Switch to another VS Code tab and return	Keeps current SQL text, latest results, and in-progress query UI state

Commands

Data Browser: Add Connection
Data Browser: Refresh
Data Browser: Sort Connections — sorts saved connections by name
Data Browser: Remove Connection
Data Browser: Open Table — reuses existing tab
Data Browser: Open Table in New Tab — always opens a new tab
Data Browser: Get Row Count — opens editor with COUNT(*) and runs it
Data Browser: ClickHouse Performance — opens a ClickHouse metrics and historical query dashboard (shown only for ClickHouse connections)
Data Browser: Manage Users & ACLs — opens a connection-scoped admin panel for PostgreSQL, Hasura, and ClickHouse
- Available from supported connection nodes and supported database nodes; opening from a database node scopes users/ACLs to that selected database/source
Data Browser: Create Database — context action for ClickHouse/PostgreSQL connections
Data Browser: Create Schema — context action for PostgreSQL database and Databricks catalog scopes
Data Browser: View Table Schema

Security Notes

Password/token are stored in SecretStorage.
Non-sensitive connection metadata is stored in globalState.
Filters are injected directly into SQL; use trusted filter input.