Viewstor

PostgreSQL + Redis + ClickHouse + SQLite in one extension.
Free. Open source. No paywalls.

Why Viewstor?

Database extensions for VS Code are either locked to one database, or freemium with crippled free tiers (limited connections, no export, closed source). Switching between DBeaver and VS Code breaks flow. DataGrip costs money.

Viewstor is a free, open-source extension that covers PostgreSQL, Redis, ClickHouse, and SQLite in a single tool — with features you won't find elsewhere:

Get Started

Install from the VS Code Marketplace:

ext install Siyet.viewstor

Or search Viewstor in the Extensions panel (Ctrl+Shift+X).

Migrating from another tool?

Ctrl+Shift+P → Viewstor: Import Connections → pick your format:

• DBeaver — data-sources.json
• DataGrip — dataSources.xml
• pgAdmin — servers.json

Passwords are excluded for security — you'll enter them on first connect. See the Wiki for detailed migration guides.

Features

Safe Mode

Production databases deserve guardrails. Safe mode runs EXPLAIN before every SELECT and catches full table scans:

Supports PostgreSQL (Seq Scan), SQLite (SCAN TABLE via EXPLAIN QUERY PLAN), and ClickHouse. Set globally in settings or per connection. Auto-adds LIMIT to SELECTs that don't have one.

Read-only Mode

Mark a connection or an entire folder as read-only. Child connections inherit the setting. Mutations are blocked in the query editor, result grid, and MCP commands.

Connections

• Nested folders with drag-and-drop for connections and folders
• Multi-database — list several databases in one connection, each as a separate tree node
• Color coding — theme-aware palette or hex picker, tints icons; folders pass color to children
• SSL and SSH tunnel / SOCKS5 proxy support
• Native VS Code form chrome — Connection / Folder forms built on @vscode-elements/elements with @vscode/codicons; render correctly in light, dark, and high-contrast themes. Power-user settings (Safe mode override, Store in, Hidden schemas) tucked under a collapsible Advanced section so the default form stays short

Schema Browser

• Tree: databases → schemas → tables, views, indexes, triggers, sequences
• Auto-collapse single-database and single-schema levels
• Hide schemas/databases from context menu
• Inaccessible objects (no permissions) rendered in error color

ER Diagram

Right-click a connected connection, database, or schema → Show ER Diagram:

• Tables and views share one continuous canvas and always render as complete cards with columns: PostgreSQL schemas and ClickHouse databases occupy separate tinted regions, while engines without namespaces keep a plain canvas; views use a dashed purple border
• Search matches table, view, and column names and mirrors matches in a dropdown with matching columns; table and view type labels reuse the legend's blue and purple colors. Multiple matching tables are highlighted on the full diagram, while a unique or explicitly selected result opens that table's direct-neighbour graph
• Right-click a table or view card for the same object actions as in the Connections tree; both surfaces share one action registry guarded by a synchronization test
• The toolbar stays task-focused and does not expose internal zoom, render-mode, or focused-node diagnostics
• Foreign-key lines include column mappings and ON DELETE / ON UPDATE details; lines are slightly muted below 3×, where arrowheads, relationship hover highlighting, and relationship tooltips appear
• Scroll anywhere on the canvas to zoom, including empty space beyond the graph; target-based easing stays responsive to trackpads
• Cards highlight and mark primary keys as PK, source foreign-key columns as FK, and indexed columns as IDX. Combined roles are preserved, such as FK, IDX
• Zoom enlarges each card as one graphics group, so its frame, text, row spacing, and padding inherit exactly the same camera transform and preserve their proportions at every level; role colors are intentionally muted to keep dense schemas readable
• Hover a column to see its database comment, foreign-key role, and index names when available
• Hover a table or relationship to keep its adjacent graph visible while unrelated objects fade smoothly over a fast 150 ms transition
• Double-click a table to isolate it in the centre with its directly related tables; double-click the centre or blank canvas, or press Esc, to return
• Use the relationship icon to toggle edges; it is crossed out while edges are hidden, and both toolbar icons explain their actions on hover or keyboard focus. The canvas legend explains namespace regions, tables, views, relationships, primary keys, foreign keys, indexes, and required columns
• Start a left-button drag even on empty canvas beyond the outermost tables, or hold the middle mouse button, to pan horizontally and vertically
• PostgreSQL and SQLite relationships are detected natively. ClickHouse still shows its tables and columns with a clear note that the driver has no FK metadata; Redis has no relational tables to diagram

Query Editor

• Per-connection SQL tabs (Ctrl+Enter to execute)
• SQL autocomplete — context-aware: tables after FROM/JOIN, columns from referenced tables, table.column dot trigger, alias resolution, enum value suggestions after =/IN
• SQL diagnostics — error underline for non-existent tables, warning for unknown columns
• Index hints — warning diagnostics on WHERE/ORDER BY columns without an index
• Cancel running queries (PG: pg_cancel_backend, CH: AbortController)

Result Grid

• Server-side pagination (50 / 100 / 500 / 1000 rows)
• Estimated row count from statistics, exact count via refresh
• Editable SQL bar above the table — edit the query in place, pagination stays live (host re-applies LIMIT N OFFSET p*N and fetches an exact COUNT(*) for the user's query); your explicit LIMIT acts as a ceiling across pages; only read-only SQL (SELECT / WITH / EXPLAIN / SHOW / VALUES) runs from the bar
• Inline editing with PK-based UPDATE, type-aware SQL (numeric PKs without quotes, ::jsonb cast)
• Add / delete rows — insert with DEFAULT values, delete from toolbar or right-click context menu
• Resizable columns — drag column header edge to adjust width
• Refresh button — re-run current query without page reload
• Column sorting (shift-click for multi-column); manual ORDER BY in the SQL bar syncs back to the header indicators
• Cell selection with drag, Shift+Click range, resize handle
• Search with Ctrl+F, Enter to cycle matches

Export & Copy

• Export all rows (not just current page) — CSV, TSV, JSON, Markdown
• Right-click cells → Copy as CSV / TSV / Markdown / JSON
• Ctrl+C copies selected cells as TSV

Chart Visualization

Visualize query results as interactive charts — powered by Apache ECharts:

• 12 chart types — line, bar, scatter, pie, heatmap, radar, funnel, gauge, boxplot, candlestick, treemap, sunburst
• Click the chart button in the Result Panel toolbar to open the chart panel
• Config sidebar — axis mapping, aggregation, group by, area fill, legend
• Auto-detection — suggests the best chart type based on column types (time → line, categorical → pie, etc.)

Multi-source charts — overlay data from multiple queries on one chart:

1. Execute and pin queries you want to combine (pin icon in Query History)
2. Open a chart from any result set
3. Click + Data Source in the chart toolbar, pick a pinned query
4. Choose merge mode:
   • Separate series — each source rendered as independent series (different X values are fine)
   • Join by column — rows matched by a key column (like SQL LEFT JOIN), additional Y columns merged into the primary dataset
5. Select which numeric columns to include, set a label — done

Example: pin SELECT ts, cpu FROM metrics and SELECT ts, mem FROM metrics, open chart from CPU, add Memory as data source with join on ts — both metrics on the same time axis.

Data Diff

Compare data between tables — even across different connections (dev vs staging):

• Right-click a table → Compare With... → pick another table from any connected database
• Row diff — matches rows by a compatible primary key from either side, or by user-selected columns shared by both sources; highlights added/removed/changed cells side-by-side with zebra-striped rows. ClickHouse MergeTree keys are resolved from system.columns
• Schema diff — compare column names, types, nullability, PK status, plus indexes, constraints, triggers, and sequences
• Statistics diff — same-type comparisons show each driver's complete metric set. All drivers normalize the presence of row_count, total_size, and last_modified where meaningful, using null when an engine cannot provide a value. Cross-type comparisons show only metrics with explicitly compatible semantics (currently row count), disclose that PostgreSQL counts may be estimated, and hide incompatible storage metrics instead of presenting misleading deltas
• Custom SQL — editable queries per side under the collapsible "SQL" block, with Synced toggle + lock indicator for mirrored edits
• Tab headers show colored count badges (e.g. Schema Diff •6); filter chips per tab (click to solo, Shift+click to toggle)
• Export diff as CSV or JSON
• Configure max rows in settings (viewstor.diffRowLimit, default 10,000)

Also available via Command Palette: Viewstor: Compare Data.

Map View

Plot geographic data on an interactive map — powered by Leaflet with CARTO basemap tiles (© OpenStreetMap contributors, © CARTO), light/dark variant picked to match your VS Code theme:

• Click the 🗺 map button in the Result Panel toolbar to open the map for the current result set
• Auto-detects coordinate columns:
  • GeoJSON Point ({"type":"Point","coordinates":[lng,lat]})
  • WKT (POINT(lng lat))
  • {lat, lng} / {latitude, longitude} objects
  • [lng, lat] arrays or PG array strings ({lng,lat})
  • Separate lat / lng columns
• Manual column picker — toolbar has a Mode toggle (Single column / Lat + Lng) and selects for picking the coordinate and label columns by hand when auto-detection doesn't match; hover a field label for a tooltip with format hints
• Circle markers tinted with the VS Code accent color, with a popup (click) that shows the full row
• Labels — when the result contains ≤50 points the chosen label column is rendered permanently on each marker; otherwise it shows on hover
• Auto-zoom to fit all points; up to 10,000 points rendered per view

Copilot Chat (@viewstor)

Ask questions about your database in natural language:

• @viewstor describe the users table
• @viewstor write a query to find orders without payments
• @viewstor what indexes are missing for this query?
• @viewstor /chart show request latency over the last hour grouped by endpoint

Schema context is injected automatically from the active connection. Slash commands: /schema, /query, /describe, /chart. Requires GitHub Copilot.

AI Agent Integration (MCP)

Two MCP interfaces — pick the one that fits your workflow:

VS Code MCP commands (for Copilot, Cursor — agents running inside VS Code):

Standalone MCP server (for Claude Code, Cline — CLI agents running outside VS Code):

The extension installs a launcher at ~/.viewstor/mcp-server.js that auto-updates on each activation — no manual path changes needed when the extension updates.

Quick setup: Ctrl+Shift+P → Viewstor: Setup MCP → Copy Config → paste into your agent's MCP config.

Or add manually:

{
  "mcpServers": {
    "viewstor": {
      "command": "node",
      "args": ["~/.viewstor/mcp-server.js"]
    }
  }
}

9 tools: list_connections, get_schema, execute_query, get_table_data, get_table_info, add_connection, reload_connections, build_chart. Reads connections from ~/.viewstor/connections.json and .vscode/viewstor.json. Connections sync bidirectionally with the VS Code extension. See the MCP Server wiki page for setup instructions.

All MCP interfaces auto-connect and respect read-only mode.

Data-oriented tools (execute_query, get_schema, get_table_data, get_table_info, build_chart) accept an optional database parameter — query another database on the same server without creating a new connection or re-entering the password.

Other

• Query history with execution time and row count — click to re-execute
• DDL viewer for tables, views, indexes, triggers, sequences
• JSON/JSONB cell editor with syntax highlighting (double-click to open)
• PostgreSQL arrays displayed with {curly braces}
• Redis — inspect strings, lists, sets, sorted sets, hashes
• SQLite — open .sqlite/.db files directly, file-based connection (no server needed)

Keyboard Shortcuts

All shortcuts use physical key codes — work on any keyboard layout.

Supported Databases

Development

Prerequisites

• Node.js 18+
• VS Code 1.93+
• Docker (for e2e tests)

Commands

npm run dev          # development build
npm run watch        # rebuild on changes
npm run build        # production build
npm run lint         # ESLint check
npm run lint:fix     # auto-fix
npm test             # unit tests (vitest)
npm run test:e2e     # e2e tests (Docker required)
npm run package      # .vsix package

Testing

700+ tests across three layers:

CI/CD

• CI (on PR, trunk push, tags): lint → unit tests → e2e tests → build → security audit → changeset size check
• Changeset size — warns when a PR changes 30+ files (historically the threshold for cascading regressions)
• Release (on v* tag): build → test → publish to Marketplace → GitHub Release with .vsix

Contributing

See CONTRIBUTING.md.

Changelog

See CHANGELOG.md for a full list of changes per version.

License

AGPL-3.0