DoltgreSQL is Dolt for Postgres!
From the creators of Dolt, the world's first version controlled SQL database, DoltgreSQL (aka Doltgres) is a Postgres-flavored version of Dolt. Doltgres offers all the Git-style log, diff, branch, and merge functionality of Dolt on your Postgres database schema and data. Instead of connecting with a MySQL client and using MySQL SQL, you connect to Doltgres with a Postgres client and use Postgres SQL. Doltgres is like Git and Postgres had a baby.
Dolt was built MySQL-flavored. There is no MySQL code in Dolt. In 2019, when we were conceiving of Dolt, MySQL was the most popular SQL-flavor. Over the past 5 years, the tide has shifted more towards Postgres, especially among young companies, Dolt's target market. Potential customers have been clamoring for a Postgres version of Dolt.
Moreover, Dolt was conceived of and built as Git for Data. Dolt later became a version controlled database. DoltgreSQL gives us the opportunity to strip out some of the Git for Data pieces like the CLI and build directly for the version controlled database use case. With Doltgres, you start a server, connect a client, and do everything with SQL, a familiar experience for Postgres users.
Doltgres will diverge from Dolt over time to be a focused database version control solution. That said, we have a five year head start with Dolt. Dolt is a production-grade version controlled database today. Dolt is 1.0. If you are ok with using a MySQL-client, we recommend using Dolt for all use cases. Doltgres is experimental.
How You Can Help
Doltgres is experimental. We need your feedback to understand how much we should invest in it. If you are interested in using Doltgres now or in the future, please:
- Star this repo to tell us you are interested.
- Try Doltgres
- Create issues if you find bugs
- Create issues for missing functionality you want
- Contribute Code for features you want (see Building From Source)
Contribution Guide coming soon.
Download the latest release of
Navigate to a directory you want your database data stored (ie.
$ mkdir ~/doltgresql $ cd ~/doltgresql
doltgres. This will create a
doltgresuser and a
$ doltgres Successfully initialized dolt data repository. Starting server with Config HP="localhost:5432"|T="28800000"|R="false"|L="info"|S="/tmp/mysql.sock"
- Make sure you have Postgres version 15 or higher installed. I used Homebrew to install Postgres on my Mac.
This requires I manually add
/opt/homebrew/opt/postgresql@15/binto my path. On Postgres version 14 or lower,
\l) do not work with Doltgres.
- Open a new terminal. Connect with the following command:
psql -h localhost -U doltgres. This will connect to the
doltgresdatabase with the
$ psql -h 127.0.0.1 -U doltgres psql (15.4 (Homebrew), server 15.0) Type "help" for help. doltgres=>
- Create a
getting_starteddatabase. Create the
doltgres=> create database getting_started; -- (0 rows) doltgres=> \c getting_started; psql (15.4 (Homebrew), server 15.0) You are now connected to database "getting_started" as user "doltgres". getting_started=> create table employees ( id int8, last_name text, first_name text, primary key(id)); -- (0 rows) getting_started=> create table teams ( id int8, team_name text, primary key(id)); -- (0 rows) getting_started=> create table employees_teams( team_id int8, employee_id int8, primary key(team_id, employee_id), foreign key (team_id) references teams(id), foreign key (employee_id) references employees(id)); -- (0 rows) getting_started=> \d List of relations Schema | Name | Type | Owner --------+-----------------+-------+---------- public | employees | table | postgres public | employees_teams | table | postgres public | teams | table | postgres (3 rows)
- Make a Dolt Commit.
getting_started=> select * from dolt_status; table_name | staged | status -----------------+--------+----------- employees | 0 | new table employees_teams | 0 | new table teams | 0 | new table (3 rows) getting_started=> call dolt_add('teams', 'employees', 'employees_teams'); status -------- 0 (1 row) getting_started=> select * from dolt_status; table_name | staged | status -----------------+--------+----------- employees | 1 | new table employees_teams | 1 | new table teams | 1 | new table (3 rows) getting_started=> call dolt_commit('-m', 'Created initial schema'); hash ---------------------------------- peqq98e2dl5gscvfvic71e7j6ne34533 (1 row)
- View the Dolt log.
getting_started=> select * from dolt_log; commit_hash | committer | email | date | message ----------------------------------+-----------+--------------------+---------------------+---------------------------- peqq98e2dl5gscvfvic71e7j6ne34533 | doltgres | email@example.com | 2023-11-01 22:08:04 | Created initial schema in7bk735qa6p6rv6i3s797jjem2pg4ru | timsehn | firstname.lastname@example.org | 2023-11-01 22:04:03 | Initialize data repository (2 rows)
- Continue with Dolt Getting Started to test out more Doltgres versioning functionality.
Building From Source
Due to the rapid pace of development at this early stage, building from source will guarantee that you're always working with the latest improvement and features.
- Clone the repository to your local drive
./postgres/parser/build.shto generate the parser
go build .in the root directory
- No Git-style CLI for version control like in Dolt, only a SQL interface.
- Can't push to DoltHub or DoltLab, only custom remotes.
- Limited support of Postgres-specific types and functions.
- No Postgres system tables.
- No authentication or users.
- Database and schema models are merged.
- Limited support for SSL connections (non-verified connections only).
- No GSSAPI support.
- No PostgreSQL functions have been implemented, therefore only MySQL functions may be used.
- No support for replication, clustering, etc.
Dolt is 1.7X slower than MySQL as measured by a standard suite of Sysbench tests.
Similar tests for Doltgres vs Postgres coming soon.
Dolt is 99.99% compatible with MySQL based on a
standard suite of correctness tests called
A similar comparison for Doltgres coming soon.
Doltgres emulates a Postgres server, including parsing Postgres SQL into an Abstract Syntax Tree (AST). This AST is converted to a form that can be interpreted by the Dolt engine. Doltgres uses the same SQL engine and storage format as Dolt.
Dolt has a unique architecure that allows for version control features at OLTP database performance. Doltgres uses the same architecture.