Navigate, analyze, and document your SQL Server databases — directly inside VS Code.
Early Access — Core features are stable and actively developed. Feedback and bug reports are welcome via GitHub Issues.
SQL Wayfarer is a VS Code extension that turns your editor into a full SQL Server workspace. Connect to any SQL Server or Azure SQL database, browse your schema, inspect object code and structure, run queries, trace dependencies down to the column level, generate scripts, and manage documentation — without leaving VS Code.
- Save and switch between multiple SQL Server connections
- Secure credential storage integrated with VS Code
- Connection testing with live feedback
- Auto-connect: the last connection used is reconnected automatically when the panel opens (toggleable, and the last connection stays pre-selected either way)
- Browse databases, schemas, tables, views, stored procedures, and functions
- Filterable object list organized by schema and type, with live match counts per schema
- Search in code: find every view, procedure, function, or trigger whose definition mentions a given text ("where is this column used?")
- Table statistics at a glance: each table shows a badge with its row count and reserved size (e.g.
1.2M · 340 MB), loaded from allocation metadata in a single query — instant even on very large databases - ▶ Top 10 button on tables and views to peek at data instantly
- Native
Ctrl+Fsearch across object lists, code, and query results
| Tab | What you see |
|---|---|
| Structure | Columns (with per-column usage — see Column Lineage), data types, primary keys, foreign keys, indexes, plus row count and disk usage breakdown (data / indexes / reserved) |
| Tree | Dependency tree for the selected object, expandable to a configurable depth |
| Graph | Rendered dependency graph showing what depends on the object and what it depends on |
| Code | Syntax-highlighted T-SQL with line metrics and one-click copy |
| Comments | Editable extended properties and inline documentation |
- Run free-form T-SQL against the selected database, with multiple result sets, a configurable row cap, and cancellation of long-running queries
- Schema-aware autocompletion: object names, schema-prefixed lookups, and alias-resolved column suggestions (
FROM Employee e→e.lists Employee's columns) - Go to definition:
Ctrl+Click(Cmd+Clickon macOS) an object name — aliases included — to jump to it in the Explorer - Destructive statement guardrails:
UPDATE/DELETEwithout aWHEREclause (detected by a real T-SQL parser, so batches and subqueries are analyzed correctly),TRUNCATE TABLE, andDROPrequire explicit confirmation before running - Copy / CSV export on every result set: tab-separated copy that pastes straight into Excel, and CSV export with RFC 4180 escaping and a UTF-8 BOM so accents survive Excel
- Persistent query history with deduplication
A 📜 button on every object in the Explorer generates ready-to-edit scripts straight into the Query tab (without running them):
- Tables:
SELECTwith all columns,INSERT/UPDATEtemplates with typed placeholders and a primary-keyWHERE, and fullCREATE TABLEDDL (identity, computed columns, defaults, primary key, secondary indexes, foreign keys with cascade rules) - Procedures:
EXECtemplate with typed parameters, declaredOUTPUTvariables, and a resultSELECT - Functions: call template for scalar and table-valued functions
- Views / procedures / functions: the full
CREATEdefinition
- Visualize which objects depend on a given object and which objects it depends on, as a tree or as a graph
- See the actual operation performed on each dependency (SELECT, INSERT, UPDATE, DELETE, MERGE), extracted by parsing the object's T-SQL definition — aliased targets (
UPDATE t … FROM Task t) are resolved to the real table - Understand the full impact of a change before making it
"What breaks if I rename this column?"
- Every view, procedure, function, and trigger definition is parsed (Babelfish T-SQL grammar) during indexing to record which columns of which tables it reads or writes
- The Structure tab shows a Used by badge per column: how many objects reference it, which ones write to it (✍), and which matches are ambiguous (
~) - Click the badge to list the referencing objects and jump to any of them in the Explorer
- Alias resolution, CTE exclusion, MERGE targets, and trigger
inserted/deletedpseudo-tables are handled
"Which tables does this procedure really touch — including through triggers?"
- A Table Footprint button on any procedure, function, or view opens an interactive graph of every table it reads and writes
- Follows nested procedure/function/view calls and the DML trigger cascades that fire when a table is written — surfacing tables a procedure touches indirectly that you would never see by reading its code
- Tables are colour-coded by access: written, read, reached only via a trigger, or a low-confidence possible match found by scanning dynamic-SQL text for known object names
- Three tabs: Graph (the object-centric footprint with a "Show reads" toggle), Schema (a pure relational ER of the tables with their PK/FK columns), and Tables (lean per-table columns, keys, and descriptions — analyze in place without exporting the dictionary)
- Read and write MS_Description extended properties directly from the panel
- Data dictionary export: generate a complete Markdown data dictionary of the database — every table, view, procedure, and function with columns, keys, parameters, cross-linked dependencies, and your extended-property descriptions
- Full mode (a checkbox next to the Dictionary button): additionally documents, per table, indexes, incoming foreign-key relations, CHECK/UNIQUE constraints, and triggers, plus a compact per-table Mermaid ER diagram, a whole-database model summary, User Defined Types, and row counts and size
- Schema, dependency, and column-lineage metadata are indexed locally per connection, so browsing, dependency, and lineage lookups stay fast after the first scan
- Incremental refresh: when the schema changes, only added or modified objects are re-analyzed; a full rebuild only happens on first indexing or Force Reindex
- Real per-object progress reporting, cancellable at any time
- Install SQL Wayfarer from the VS Code Marketplace.
- Click the compass icon in the Activity Bar to open the panel.
- Add a connection using your SQL Server credentials.
- Select a database and start exploring.
You can also open the panel via Ctrl+Shift+P → Open SQL Wayfarer.
| Requirement | Minimum version |
|---|---|
| VS Code | 1.100+ |
| SQL Server | 2017+ (table details rely on STRING_AGG) |
| Azure SQL | Any tier |
| Permissions | db_datareader for browsing and dependency analysis; VIEW DATABASE STATE for table size/row-count badges (optional — the Explorer simply shows no badges without it); ALTER on the target objects to read/write extended properties (Comments) |
- Encrypted object definitions cannot be retrieved by design (SQL Server restriction).
- Very large databases may experience slower initial indexing (each code object is parsed once for dependencies and column lineage; subsequent refreshes are incremental).
- T-SQL syntax highlighting covers standard cases; complex dialect features may not be fully highlighted.
- Dependency operations and column lineage are detected via static analysis of T-SQL: dynamic SQL (
EXECof a string), calls through another procedure, or references used only as a parameter type are shown without a specific operation. The Table Footprint additionally scans module text for qualified names of known objects to catch tables referenced only inside dynamic SQL, but marks them as low-confidence "possible" (read/write direction unknown). - Column lineage favors recall over precision: an unqualified column in a multi-table statement is attributed to every table in scope and flagged as ambiguous (
~) rather than dropped.
Bug reports and feature requests are tracked on GitHub Issues. Pull requests are welcome.
SQL Wayfarer — built for developers who spend their days navigating complex databases. "# sqlwayfarer"