# SQL File Dependency Analyzer

> Find out which SQL file must run before which, from the tables each file creates and reads. Get a run order, circular dependencies and tables nothing uses.

Page: https://datautility.in/sql-file-dependency-analyzer
This is the Markdown copy of the page. The tool itself runs in the browser: your files are processed on your own device and are not uploaded.

**Quick answer:** Free dbt project visualizer and SQL file lineage tool.

## How to use the SQL File Dependency Analyzer

The SQL Project Lineage Analyzer is a free SQL file lineage tool and SQL query visualizer. It reads a whole folder of SQL files, a dbt project or a ZIP, and draws how the tables connect. For every CREATE TABLE, CREATE VIEW, CREATE TABLE AS, INSERT … SELECT, MERGE, UPDATE … FROM and SELECT INTO it finds the tables read and the table written, follows CTEs, subqueries, joins and UNIONs, and traces each output column back to the source columns it was built from, across files. dbt ref() and source() calls are followed too, so a models folder works without running dbt. You get a graph in the same style as the Data Lineage tool, a table list with how many tables each one feeds, column lineage you can trace upstream and downstream, a suggested run order for the files, and a list of problems such as circular dependencies. Save the graph as PNG or JPG, copy it, or share a link. Everything happens in your browser; your SQL is not uploaded.

1. Drop a folder, a ZIP or a GitHub link
2. Click a table to see what feeds it and what it affects
3. Open Columns to trace one column

## Tips

- Select the top folder of your project. Files are joined by table name, so schema.table in one file matches the same table in another.
- Use Downstream on a table before you change it: everything that depends on it, directly or through other tables, stays visible.
- Source tables (dashed) are read but never created in your files. They are your raw tables.
- Add a CREATE TABLE with columns for a raw table and SELECT * from it is expanded into real column links.
- Not sure where to start? Pick a sample project above to see how a finished graph looks.

## Example

Input:

```
a folder of .sql files with CREATE TABLE and INSERT statements
```

Output:

```
Run order: 1. schema.sql, 2. stg_orders.sql, 3. fct_sales.sql …
```

## Frequently asked questions

### Can it find circular dependencies?
Yes. Tables that depend on each other in a loop are listed under Issues and marked red in the graph.

### Does it find unused tables?
It lists tables that are created but never read by any file. They are either final outputs or unused.

### How do I use this SQL lineage tool?
Drop a folder of SQL files, a ZIP or a dbt project onto the page, or paste a query. The graph appears at once. Click any table to see what it is built from and what depends on it, then open Columns to follow a single column.

### Can I visualize my dbt project with it?
Yes. Drop your dbt models folder (or a ZIP of the project). ref() and source() are followed, so sources, staging models and marts appear as a graph without running dbt or connecting a warehouse. It reads .sql files for the lineage, and your .yml schema files for descriptions and tests, which then show on each table and column. Macro files and project settings are skipped.

### Does it read my dbt YAML files?
Yes. Drop the whole dbt project folder or ZIP. The .yml schema files (models, sources, seeds, snapshots) are read for descriptions and tests. They show when you click a table, in the Columns tab and in the Tables tab. dbt_project.yml, packages.yml and macro files are not documentation and are skipped. A schema file that cannot be parsed is listed under the stats.

### Can I edit my SQL and see what the change would break?
Yes. Under the graph, open Project files, click a file and press Edit. The graph updates as you type, and a card called What your edits would affect lists what would break downstream: removed or renamed columns that something still reads, changed data types and calculations, removed tests, and personal data reaching new columns. Copy summary gives you Markdown for a pull request. Undo all edits restores the originals, and your own files are never changed.

### Can I follow personal data (PII) through my SQL?
Yes. Columns with names like email, phone or address are tagged automatically, and you can tag your own with Tag as PII in the Columns tab. The PII tab then lists every table that holds data built from them, and marks columns that are hashed, masked or only counted as protected. It is a guess from column names, so check the tags.

### Can I load a project straight from GitHub?
Yes, for public repositories. Paste the repository link (or a link to a branch, tag or folder, such as github.com/owner/repo/tree/main/models) and click Load from GitHub. Your browser lists the files and downloads the .sql and .yml files directly from GitHub, then builds the lineage. Private repositories are not available because no sign-in is used, and GitHub limits anonymous requests, so after many imports in an hour you may need to wait or drop a ZIP instead.

### Is my SQL uploaded?
No. The files you drop are read and analysed in your browser and are not sent anywhere. If you load a public GitHub repository, your browser downloads the files from GitHub itself; they still do not pass through our servers.

### Can I visualize a single SQL query?
Yes. Paste the query into the box. You see the tables it reads and the table it writes, and for a CREATE VIEW or INSERT … SELECT the column links too.

### How accurate is the column lineage?
It is read from the SQL, following aliases, casts, CASE, functions and subqueries. It is best effort. Dynamic SQL built from strings, vendor-only syntax and macros that generate table names cannot be followed.

### Which SQL dialects work?
The common ANSI core used by Postgres, Snowflake, BigQuery, Redshift, Databricks, MySQL and SQL Server, including quoted names in "double quotes", backticks and [brackets]. Unreadable statements are listed instead of being skipped silently.

### How do I save or share the graph?
Open the Export tab. Save a PNG or JPG, copy the picture to paste into a document, or copy a share link that opens the same lineage for anyone you send it to.

### How can I see lineage for a folder of SQL files for free?
Open SQL Project Lineage and drop the folder, a ZIP or a dbt models folder. The table and column lineage is drawn in your browser, with a run order and an impact view. It is free, needs no sign-up and nothing is uploaded.

### Is there a free dbt project visualizer?
Yes. Drop your dbt models folder into SQL Project Lineage. It follows ref() and source() and draws sources, staging models and marts as a clickable graph with column lineage. You do not need to run dbt, and nothing is uploaded.

### Is there a free SQL query visualizer?
Yes. Paste a query or drop SQL files into SQL Project Lineage and it draws the tables, joins and column links as a diagram. You can save it as PNG or JPG, copy it, or share a link.

## Related pages

- [SQL Lineage Analyzer for a Folder of SQL Files](https://datautility.in/sql-lineage-analyzer): Upload a folder of SQL files or a dbt project and get table and column lineage across every file, a run order and impact analysis. Free, runs in your browser.
- [dbt Lineage Viewer for Your SQL Models](https://datautility.in/dbt-lineage-viewer): Drop your dbt models folder and see the lineage graph from sources through staging to marts, with column links. No dbt run, no warehouse. Free, private.
- [SQL Column Lineage Tool](https://datautility.in/sql-column-lineage-tool): See which source columns build every column of a view or table across many SQL files. Trace to the raw table or forward to dependants. Free, in your browser.
- [SQL Impact Analysis: What Breaks If a Table Changes](https://datautility.in/sql-impact-analysis): Pick a table and see everything downstream that depends on it, and every upstream source it is built from. Works across a whole folder of SQL files, free.
- [SQL File Lineage Tool](https://datautility.in/sql-file-lineage): Free SQL file lineage tool: drop a folder of .sql files and see which file feeds which table, column by column. Nothing is uploaded.
- [SQL Query Visualizer](https://datautility.in/sql-query-visualizer): Free SQL query visualizer: paste a query or drop SQL files and see tables, joins and columns as a clear diagram. Runs in your browser, no upload.
- [Visualize a SQL Query as a Diagram](https://datautility.in/visualize-sql-query-as-diagram): Turn a SQL query into a diagram of tables and columns. Paste the SQL, see where every column comes from and save the picture as PNG. Free, private.
- [SQL Dependency Graph Generator](https://datautility.in/sql-dependency-graph-generator): Generate a dependency graph from your SQL scripts: see which tables and views depend on which, the run order and tables that are never used.

## Topic guides

- [Test Data Guides and Free Generators](https://datautility.in/guides/test-data)

## Guides

- [How to Find SQL Dependencies Across Multiple Files](https://datautility.in/blog/find-sql-dependencies-across-multiple-files)
- [How to Determine the Execution Order of SQL Scripts (Which File Runs First?)](https://datautility.in/blog/how-to-determine-sql-execution-order)
- [SQL Dependency Mapping for Large Data Projects: A Practical Playbook](https://datautility.in/blog/sql-dependency-mapping-for-large-data-projects)
- [Free SQL Query Visualizer: See Tables, Joins and Columns Online](https://datautility.in/blog/free-sql-query-visualizer-see-tables-and-columns)

Open the tool: https://datautility.in/sql-file-dependency-analyzer
