DEV Community: Roman Shevel

Postrges: Stop Fighting schema.sql — Export PostgreSQL into a Clean, Git-Friendly Project Structure

Roman Shevel — Wed, 29 Jul 2026 14:08:59 +0000

PgSchemaExporter v2.1.0

PgSchemaExporter is an open-source tool that transforms a PostgreSQL database into a clean, Git-friendly project structure.

Instead of working with one huge schema.sql, every database object is exported into its own SQL file, making schema changes easy to review, compare, and maintain.

What it does

Export a live PostgreSQL database
Import an existing pg_dump --schema-only
Generate a complete project structure
Create a dependency-aware deploy.sql
Produce clean Git diffs
Make database schemas easy to navigate and review

Unlike migration tools (Flyway, Liquibase, Sqitch, Atlas), PgSchemaExporter focuses on keeping the current PostgreSQL schema clean, structured, and Git-friendly.

GitHub: https://github.com/RomanShevel1977/PgSchemaExporter

CLI features

Include / exclude schemas
Include / exclude object types
Include / exclude individual objects
Schema comparison (diff)
Cross-platform CLI
CI/CD friendly

Perfect for

Version controlling PostgreSQL schemas
Code reviews
Database documentation
Large development teams
Legacy database refactoring
AI / LLM context generation

Supported PostgreSQL objects

Core objects

Schemas
Tables
Sequences
Views
Materialized Views

Constraints & indexes

Primary Keys
Foreign Keys
Unique Constraints
Check Constraints
Exclusion Constraints
Indexes

Programmability

Functions
Procedures
Triggers
Event Triggers
Rules

Security

Policies (Row Level Security)

Types

Domains
Enum Types
Composite Types
Range Types
Base Types

Advanced PostgreSQL features

Aggregates
Operators
Operator Classes
Operator Families
Casts
Extensions
Collations
Conversions

Full Text Search

Configurations
Dictionaries
Parsers
Templates

Foreign Data Wrappers

Foreign Data Wrappers
Foreign Servers
User Mappings
Foreign Tables

Logical Replication

Publications
Subscriptions

I'd really appreciate any feedback, feature requests, or ideas from the PostgreSQL community.

GitHub: https://github.com/RomanShevel1977/PgSchemaExporter

Still storing your PostgreSQL schema as a single 50,000-line SQL file? I built an open-source tool that exports databases into a Git-friendly structure with readable diffs and stable commits.

Roman Shevel — Thu, 02 Jul 2026 10:45:49 +0000

Roman Shevel

Jun 30

A Better Way to Store PostgreSQL Schemas in Git

#postgres #git #database #sql

2 min read

A Better Way to Store PostgreSQL Schemas in Git

Roman Shevel — Tue, 30 Jun 2026 12:29:43 +0000

Stop Committing 50,000-Line PostgreSQL Schema Files to Git

If you've ever version-controlled a PostgreSQL database, you've probably run into the same problem.

You make a small schema change—a new column, an updated function, or a new index—and suddenly Git shows thousands of changed lines.

Reviewing those changes becomes frustrating, merge conflicts become more common, and understanding what actually changed takes far longer than it should.

The problem isn't PostgreSQL.

It's that pg_dump wasn't designed to produce Git-friendly output.

The Problem

A typical schema dump looks like this:

schema.sql
└── 58,000+ lines

Everything is stored in a single file.

Even small changes can generate huge diffs because objects move around or dependencies affect the output.

Code reviews become difficult because reviewers have to search through thousands of lines just to find the actual change.

What I Wanted Instead

I wanted a schema that behaved more like source code.

Instead of one massive SQL file, every database object should have its own file.

Something like this:

db-schema/
├── tables/
│   ├── public.users.sql
│   ├── public.orders.sql
│   └── ...
├── views/
├── functions/
├── triggers/
├── indexes/
├── constraints/
├── policies/
├── types/
├── domains/
└── deploy.sql

Now a Git diff only shows the objects that actually changed.

If you modify one function, only one file changes.

If you add a table, Git shows one new file.

Exactly like reviewing application code.

Introducing PgSchemaExporter

So I built PgSchemaExporter.

It's an open-source tool that exports PostgreSQL schemas into a structured, Git-friendly directory layout.

Features

One SQL file per database object
Clean Git diffs
Automatic dependency ordering
Export directly from a live PostgreSQL database
Split an existing pg_dump into individual object files
Generate a deploy.sql script
Compare two schema versions with a built-in diff command

Currently supported objects include:

Tables
Views
Functions
Procedures
Sequences
Indexes
Constraints
Triggers
Policies
Types
Domains
Extensions
Schemas
Comments
Grants
and more.

Why I Built It

Many teams already use migration tools such as Flyway, Liquibase, or Entity Framework migrations.

Those tools are excellent for deploying changes.

PgSchemaExporter solves a different problem.

It helps when you want to:

understand an existing database
audit a production schema
review database changes in Git
document legacy databases
compare two schema versions
keep the actual deployed schema under version control

In other words, it's focused on the current state of the database rather than its migration history.

Example

Instead of reviewing this:

schema.sql
58,421 lines changed

you review something like this:

functions/
    calculate_order_total.sql

tables/
    public.orders.sql

The change is immediately obvious.

Open Source

PgSchemaExporter is written in C#, runs on Windows, Linux, and macOS, and is released under the MIT license.

The project is available on GitHub:

https://github.com/RomanShevel1977/PgSchemaExporter

I'd really appreciate any feedback, ideas, feature requests, or contributions.

If you've ever struggled with reviewing PostgreSQL schema changes in Git, I'd love to hear how your team solves this problem.