dolt
1.43.16
Dolt ist eine SQL-Datenbank, die Sie genau wie ein Git-Repository forken, klonen, verzweigen, zusammenführen, pushen und ziehen können.
Stellen Sie wie jede MySQL-Datenbank eine Verbindung zu Dolt her, um Schemata und Daten zu lesen oder zu ändern. Die Funktionalität der Versionskontrolle wird in SQL über Systemtabellen, Funktionen und Prozeduren bereitgestellt.
Oder verwenden Sie die Git-ähnliche Befehlszeilenschnittstelle, um CSV-Dateien zu importieren, Ihre Änderungen zu übernehmen, sie an eine Fernbedienung zu übertragen oder die Änderungen Ihres Teamkollegen zusammenzuführen. Alle Befehle, die Sie für Git kennen, funktionieren für Dolt genauso.
Git-Versionsdateien. Dolt-Versionstabellen. Es ist, als hätten Git und MySQL ein Baby bekommen.
Wir haben auch DoltHub entwickelt, einen Ort zum Teilen von Dolt-Datenbanken. Wir hosten öffentliche Daten kostenlos. Wenn Sie Ihre eigene Version von DoltHub hosten möchten, haben wir DoltLab. Wenn Sie möchten, dass wir einen Dolt-Server für Sie betreiben, haben wir Hosted Dolt. Wenn Sie nach einer Postgres-Version von Dolt suchen, haben wir DoltgreSQL erstellt. Achtung, es ist frühe Alpha. Dolt ist produktionsbereit.
Besuchen Sie uns auf Discord, um Hallo zu sagen und Fragen zu stellen, oder sehen Sie sich unsere Roadmap an, um zu sehen, was wir als Nächstes entwickeln.
Viele Dinge! Dolt ist ein allgemein nützliches Werkzeug mit unzähligen Anwendungsmöglichkeiten. Aber wenn Sie ein paar Ideen haben möchten, erfahren Sie hier, wie die Leute es bisher verwenden.
Dolt kann mithilfe der standardmäßigen MySQL-Binlog-Replikation als Replik Ihrer vorhandenen MySQL- oder MariaDB-Datenbank eingerichtet werden. Jeder Schreibvorgang wird zu einem Dolt-Commit. Dies ist eine großartige Möglichkeit, die Vorteile der Versionskontrolle von Dolt zu nutzen und eine vorhandene MySQL- oder MariaDB-Datenbank beizubehalten.
Die dolt -CLI verfügt über dieselben Befehle wie git , mit einigen Extras.
$ dolt Valid commands for dolt are init - Create an empty Dolt data repository. status - Show the working tree status. add - Add table changes to the list of staged table changes. diff - Diff a table. reset - Remove table changes from the list of staged table changes. clean - Remove untracked tables from working set. commit - Record changes to the repository. sql - Run a SQL query against tables in repository. sql-server - Start a MySQL-compatible server. log - Show commit logs. branch - Create, list, edit, delete branches. checkout - Checkout a branch or overwrite a table from HEAD. merge - Merge a branch. conflicts - Commands for viewing and resolving merge conflicts. cherry-pick - Apply the changes introduced by an existing commit. revert - Undo the changes introduced in a commit. clone - Clone from a remote data repository. fetch - Update the database from a remote data repository. pull - Fetch from a dolt remote data repository and merge. push - Push to a dolt remote. config - Dolt configuration. remote - Manage set of tracked repositories. backup - Manage a set of server backups. login - Login to a dolt remote host. creds - Commands for managing credentials. ls - List tables in the working set. schema - Commands for showing and importing table schemas. table - Commands for copying, renaming, deleting, and exporting tables. tag - Create, list, delete tags. blame - Show what revision and author last modified each row of a table. constraints - Commands for handling constraints. migrate - Executes a database migration to use the latest Dolt data format. read-tables - Fetch table(s) at a specific commit into a new dolt repo gc - Cleans up unreferenced data from the repository. filter-branch - Edits the commit history using the provided query. merge-base - Find the common ancestor of two commits. version - Displays the current Dolt cli version. dump - Export all tables in the working set into a file.
Dolt ist ein einzelnes ~103-Megabyte-Programm.
dolt $ du -h /Users/timsehn/go/bin/dolt 103M /Users/timsehn/go/bin/dolt
Es ist wirklich einfach zu installieren. Laden Sie es herunter und legen Sie es auf Ihrem PATH ab. Wir haben eine Reihe von Möglichkeiten, dies für die meisten Plattformen noch einfacher zu machen.
Um auf Linux- oder Mac-basierten Systemen zu installieren, führen Sie diesen Befehl in Ihrem Terminal aus:
sudo bash -c 'curl -L https://github.com/dolthub/dolt/releases/latest/download/install.sh | bash'
Dadurch wird die neueste dolt Version heruntergeladen und in /usr/local/bin/ abgelegt, was sich wahrscheinlich in Ihrem $PATH befindet.
Das Installationsskript benötigt sudo, um dolt in /usr/local/bin einzufügen. Wenn Sie keine Root-Rechte haben oder sich nicht damit auskennen, ein Skript damit auszuführen, können Sie die Dolt-Binärdatei für Ihre Plattform aus der neuesten Version herunterladen, sie entpacken und die Binärdatei irgendwo in Ihrem $PATH ablegen.
Dolt ist in den offiziellen Repositories für Arch Linux gepackt.
pacman -S dolt
Dolt ist auf Homebrew und wird bei jeder Veröffentlichung aktualisiert.
brew install dolt
Unter macOS kann Dolt auch über einen von der Community verwalteten Port über MacPorts installiert werden:
sudo port install dolt
Laden Sie den neuesten Microsoft Installer ( .msi -Datei) herunter und führen Sie ihn aus.
Informationen zur Ausführung unter Windows finden Sie hier.
Sie können dolt mit Chocolatey installieren:
choco install dolt
Es gibt folgende offizielle Docker-Images für Dolt:
dolthub/dolt zum Ausführen von Dolt als CLI-Tool.
dolthub/dolt-sql-server zum Ausführen von Dolt im Servermodus.
Stellen Sie sicher, dass Go installiert ist und dass go in Ihrem Pfad vorhanden ist. Da Dolt von cgo abhängig ist, benötigen Sie auch einen funktionierenden C-Compiler und eine funktionierende Toolchain.
Klonen Sie dieses Repository und kopieren Sie es in das go -Verzeichnis. Führen Sie dann Folgendes aus:
go install ./cmd/dolt
Die Ausgabe erfolgt in $GOPATH/bin , der Standardwert ist ~/go/bin . Um Ihren Build zu testen, versuchen Sie Folgendes:
~/go/bin/dolt version
Überprüfen Sie, ob Ihre Installation erfolgreich war, indem Sie dolt in Ihrem Terminal ausführen.
$ dolt Valid commands for dolt are [...]
Konfigurieren Sie dolt mit Ihrem Benutzernamen und Ihrer E-Mail-Adresse, die Sie zum Erstellen von Commits benötigen. Die Befehle funktionieren genauso wie git.
$ dolt config --global --add user.email [email protected] $ dolt config --global --add user.name "YOUR NAME"
Dolt benötigt einen Ort zum Speichern Ihrer Datenbanken. Ich werde meine Datenbanken in ~/dolt ablegen.
% cd ~% mkdir dolt % cd dolt
Alle von Ihnen erstellten Datenbanken werden in diesem Verzeichnis gespeichert. In diesem Beispiel wird also hier ein Verzeichnis mit dem Namen getting_started erstellt, sobald Sie create database getting_started ausführen. Wenn Sie zu ~/dolt/getting_started navigieren, können Sie über die Dolt-Befehlszeile auf diese Datenbank zugreifen.
HINWEIS: In diesem Beispiel wird das Verzeichnis getting_started erstellt, nachdem Sie create database getting_started; in einer SQL-Shell im Abschnitt „Schema erstellen“. Machen Sie nichts anderes, als das Verzeichnis zu erstellen und dorthin zu navigieren.
Dolt wird mit einem integrierten MySQL-kompatiblen Datenbankserver ausgeliefert. Um es zu starten, verwenden Sie den Befehl dolt sql-server . Durch Ausführen dieses Befehls wird der Server auf Port 3306 gestartet.
Dolt SQL-Server Server mit Config HP="localhost:3306"|T="28800000"|R="false"|L="info" starten
Ihr Terminal bleibt einfach dort hängen. Das bedeutet, dass der Server läuft. Eventuelle Fehler werden in diesem Terminal ausgedruckt. Lassen Sie es einfach dort und öffnen Sie ein neues Terminal.
Im neuen Terminal verbinden wir uns nun über einen Client mit dem laufenden Datenbankserver. Dolt wird außerdem mit einem MySQL-kompatiblen Client ausgeliefert.
% dolt -u root -p "" sql# Willkommen beim Dolt-MySQL-Client.# Anweisungen müssen mit ';' beendet werden.# "exit" oder "quit" (oder Strg-D) zu exit.mysql>
In dem anderen Terminal, in dem Sie dolt sql-server ausgeführt haben, sehen Sie die folgende Protokollzeile.
2022-06-06T13:14:32-07:00 INFO [conn 1] NewConnection {DisableClientMultiStatements=false}Sie sind verbunden!
Während wir hier sind, besorgen wir uns eine Kopie von MySQL, damit wir uns mit diesem Client verbinden können. Gehen Sie zur MySQL-Dokumentation „Erste Schritte“ und installieren Sie MySQL auf Ihrem Computer. Ich habe Homebrew verwendet, um MySQL auf meinem Mac zu installieren.
MySQL wird mit einem MySQL-Server namens mysqld und einem MySQL-Client namens mysql geliefert. Sie interessieren sich nur für den Kunden. Nachdem Sie die Anweisungen aus der MySQL-Dokumentation befolgt haben, stellen Sie sicher, dass sich eine Kopie des mysql Clients in Ihrem Pfad befindet:
% mysql --version MySQL Ver 8.0.29 für macOS12.2 auf x86_64 (Homebrew)
Um nun den mysql -Client mit Dolt zu verbinden, zwingen Sie den MySQL-Client durch die Übergabe eines Hosts und eines Ports über die TCP-Schnittstelle. Die Standardeinstellung ist die Socket-Schnittstelle, die Dolt unterstützt, aber nur auf localhost verfügbar ist. Daher ist es besser, die TCP-Schnittstelle zur Schau zu stellen. Für den MySQL-Client müssen Sie außerdem einen Benutzer angeben, in diesem Fall root .
% mysql --host 127.0.0.1 --port 3306 -uroot Willkommen beim MySQL-Monitor. Befehle enden mit ; oder g. Ihre MySQL-Verbindungs-ID ist 2 Serverversion: 5.7.9-Vitess Copyright (c) 2000, 2022, Oracle und/oder seine verbundenen Unternehmen. Oracle ist eine eingetragene Marke der Oracle Corporation und/oder ihrer Partner. Andere Namen können Marken der jeweiligen Hersteller sein Besitzer. Geben Sie „Hilfe“ ein. oder 'h' für Hilfe. Geben Sie „c“ ein, um die aktuelle Eingabeanweisung zu löschen. mysql>
Um sicherzustellen, dass der Client tatsächlich eine Verbindung hergestellt hat, sollten Sie erneut Folgendes im dolt sql-server -Terminal sehen
2022-06-06T13:26:55-07:00 INFO [conn 2] NewConnection {DisableClientMultiStatements=false}Wie Sie sehen, unterstützt Dolt jeden MySQL-kompatiblen Client. Dolt wird mit einem Client geliefert, Sie können jedoch jeden MySQL-Client verwenden, z. B. den, der mit MySQL geliefert wird.
Jetzt sind wir tatsächlich bereit, etwas Interessantes zu tun. Ich bleibe im mysql -Client und führe die folgenden SQL-Anweisungen aus, um eine Datenbank namens getting_started zu erstellen. Die getting_started Datenbank verfügt über drei Tabellen: employees , teams und employees_teams .
mysql> create database getting_started; Query OK, 1 row affected (0.04 sec) mysql> use getting_started; Database changed mysql> create table employees ( id int, last_name varchar(255), first_name varchar(255), primary key(id)); Query OK, 0 rows affected (0.01 sec) mysql> create table teams ( id int, team_name varchar(255), primary key(id)); Query OK, 0 rows affected (0.00 sec) mysql> create table employees_teams( team_id int, employee_id int, primary key(team_id, employee_id), foreign key (team_id) references teams(id), foreign key (employee_id) references employees(id)); Query OK, 0 rows affected (0.01 sec) mysql> show tables; +---------------------------+ | Tables_in_getting_started | +---------------------------+ | employees | | employees_teams | | teams | +---------------------------+ 3 rows in set (0.00 sec)
Dolt unterstützt Fremdschlüssel, Sekundärindizes, Trigger, Prüfeinschränkungen und gespeicherte Prozeduren. Es handelt sich um eine moderne, funktionsreiche SQL-Datenbank.
Es ist Zeit, Ihre erste Dolt-Funktion zu nutzen. Wir werden einen Dolt-Commit durchführen. Mit einem Dolt-Commit können Sie eine Zeitreise unternehmen und die Abstammung sehen. Machen Sie ein Dolt-Commit, wann immer Sie diesen Zeitpunkt wiederherstellen oder mit ihm vergleichen möchten.
Dolt stellt Versionskontrollfunktionen über eine Schnittstelle im Git-Stil bereit. Auf der Befehlszeile entsprechen Dolt-Befehle genau ihrem Git-Äquivalent, wobei die Ziele Tabellen statt Dateien sind. In SQL stellt Dolt Lesevorgänge der Versionskontrolle als Systemtabellen und Schreibvorgänge der Versionskontrolle als gespeicherte Prozeduren bereit.
Die Benennung der Systemtabellen und gespeicherten Prozeduren folgt dem Muster dolt_ . So wird dolt add auf der CLI zu dolt_add als gespeicherte Prozedur. Auch die Übergabe von Optionen erfolgt nach dem Befehlszeilenmodell. Um beispielsweise hinzuzufügende Tabellen anzugeben, senden Sie die Tabellennamen als Optionen an die Prozedur dolt_add . Für benannte Argumente wie das Senden einer Nachricht an den Befehl dolt_commit verwenden Sie zwei Argumente nacheinander wie ('-m', 'This is a message') . Wenn Sie Git kennen, sollten Ihnen die Versionskontrollverfahren und Systemtabellen bekannt vorkommen.
Also fügen wir unser neues Schema hinzu und übernehmen es auf diese Weise.
mysql> call dolt_add('teams', 'employees', 'employees_teams');
+--------+
| status |
+--------+
| 0 |
+--------+
1 row in set (0.03 sec)
mysql> call dolt_commit('-m', 'Created initial schema');
+----------------------------------+
| hash |
+----------------------------------+
| ne182jemgrlm8jnjmoubfqsstlfi1s98 |
+----------------------------------+
1 row in set (0.02 sec)
mysql> select * from dolt_log;
+----------------------------------+-----------+-----------------+-------------------------+----------------------------+
| commit_hash | committer | email | date | message |
+----------------------------------+-----------+-----------------+-------------------------+----------------------------+
| ne182jemgrlm8jnjmoubfqsstlfi1s98 | Tim Sehn | [email protected] | 2022-06-07 16:35:49.277 | Created initial schema |
| vluuhvd0bn59598utedt77ed9q5okbcb | Tim Sehn | [email protected] | 2022-06-07 16:33:59.531 | Initialize data repository |
+----------------------------------+-----------+-----------------+-------------------------+----------------------------+
2 rows in set (0.01 sec) Da haben Sie es. Ihr Schema wird erstellt und Sie verfügen über einen Dolt-Commit, der die Erstellung verfolgt, wie in der Systemtabelle dolt_log zu sehen ist.
Beachten Sie, dass sich ein Dolt-Commit von einer Standard-SQL-Transaktion COMMIT unterscheidet. In diesem Fall betreibe ich die Datenbank mit aktiviertem AUTOCOMMIT , sodass jede SQL-Anweisung automatisch eine Transaktion COMMIT generiert. Wenn Sie möchten, dass das System für jede Transaktion ein Dolt-Commit generiert, verwenden Sie die Systemvariable @@dolt_transaction_commit .
Jetzt werde ich die Datenbank mit ein paar Mitarbeitern hier bei DoltHub füllen. Dann teile ich die Mitarbeiter zwei Teams zu: Technik und Vertrieb. Der CEO trägt bei einem Start-up-Unternehmen viele Funktionen und wird daher mehreren Teams zugeteilt.
mysql> insert into employees values (0, 'Sehn', 'Tim'), (1, 'Hendriks', 'Brian'), (2, 'Son','Aaron'), (3, 'Fitzgerald', 'Brian'); Query OK, 4 rows affected (0.01 sec) mysql> select * from employees where first_name='Brian'; +------+------------+------------+ | id | last_name | first_name | +------+------------+------------+ | 1 | Hendriks | Brian | | 3 | Fitzgerald | Brian | +------+------------+------------+ 2 rows in set (0.00 sec) mysql> insert into teams values (0, 'Engineering'), (1, 'Sales'); Query OK, 2 rows affected (0.00 sec) mysql> insert into employees_teams values (0,0), (1,0), (2,0), (0,1), (3,1); ERROR 1452 (HY000): cannot add or update a child row - Foreign key violation on fk: `rv9ek7ft`, table: `employees_teams`, referenced table: `teams`, key: `[2]`
Hoppla, ich habe gegen eine Einschränkung verstoßen. Es sieht so aus, als hätte ich die Tabelle mit den Teams vor den Mitarbeitern erstellt. Sie sollten Ihre Spalten beim Einfügen immer angeben und sich nicht auf die natürliche Reihenfolge verlassen. Geschieht mir recht! Dolt verfügt über die volle Leistungsfähigkeit einer modernen relationalen SQL-Datenbank, um die Datenintegrität sicherzustellen.
mysql> insert into employees_teams(employee_id, team_id) values (0,0), (1,0), (2,0), (0,1), (3,1); Query OK, 5 rows affected (0.01 sec) mysql> select first_name, last_name, team_name from employees join employees_teams on (employees.id=employees_teams.employee_id) join teams on (teams.id=employees_teams.team_id) where team_name='Engineering'; +------------+-----------+-------------+ | first_name | last_name | team_name | +------------+-----------+-------------+ | Tim | Sehn | Engineering | | Brian | Hendriks | Engineering | | Aaron | Son | Engineering | +------------+-----------+-------------+ 3 rows in set (0.00 sec)
Sieht so aus, als ob alles eingefügt und korrekt ist. Ich konnte die Mitglieder des Ingenieurteams mithilfe dieser drei Tabellen JOIN auflisten. Dolt unterstützt bis zu zwölf Tabellen JOIN . Auch hier handelt es sich bei Dolt um eine moderne relationale SQL-Datenbank gepaart mit einer Versionskontrolle im Git-Stil.
Was ist nun, wenn Sie sehen möchten, was sich in Ihrem Arbeitssatz geändert hat, bevor Sie einen Commit durchführen? Sie verwenden die Systemtabellen dolt_status und dolt_diff_ .
mysql> select * from dolt_status; +-----------------+--------+----------+ | table_name | staged | status | +-----------------+--------+----------+ | teams | 0 | modified | | employees | 0 | modified | | employees_teams | 0 | modified | +-----------------+--------+----------+ 3 rows in set (0.01 sec) mysql> select * from dolt_diff_employees; +--------------+---------------+-------+-----------+----------------+----------------+-----------------+---------+----------------------------------+-------------------------+-----------+ | to_last_name | to_first_name | to_id | to_commit | to_commit_date | from_last_name | from_first_name | from_id | from_commit | from_commit_date | diff_type | +--------------+---------------+-------+-----------+----------------+----------------+-----------------+---------+----------------------------------+-------------------------+-----------+ | Sehn | Tim | 0 | WORKING | NULL | NULL | NULL | NULL | ne182jemgrlm8jnjmoubfqsstlfi1s98 | 2022-06-07 16:35:49.277 | added | | Hendriks | Brian | 1 | WORKING | NULL | NULL | NULL | NULL | ne182jemgrlm8jnjmoubfqsstlfi1s98 | 2022-06-07 16:35:49.277 | added | | Son | Aaron | 2 | WORKING | NULL | NULL | NULL | NULL | ne182jemgrlm8jnjmoubfqsstlfi1s98 | 2022-06-07 16:35:49.277 | added | | Fitzgerald | Brian | 3 | WORKING | NULL | NULL | NULL | NULL | ne182jemgrlm8jnjmoubfqsstlfi1s98 | 2022-06-07 16:35:49.277 | added | +--------------+---------------+-------+-----------+----------------+----------------+-----------------+---------+----------------------------------+-------------------------+-----------+ 4 rows in set (0.00 sec)
Wie Sie dem Diff entnehmen können, habe ich der employees die richtigen Werte hinzugefügt. Die Werte waren zuvor NULL und werden jetzt ausgefüllt.
Lassen Sie uns mit einem weiteren Dolt-Commit abschließen, diesmal indem wir alle betroffenen Tabellen mit -am hinzufügen.
mysql> call dolt_commit('-am', 'Populated tables with data');
+----------------------------------+
| hash |
+----------------------------------+
| 13qfqa5rojq18j84d1n2htjkm6fletg4 |
+----------------------------------+
1 row in set (0.02 sec) Sie können das Protokoll mit dolt_log überprüfen und sehen, welche Tabellen sich bei jedem Commit geändert haben, indem Sie einen dolt_diff ohne Gültigkeitsbereich verwenden. Unscoped dolt_diff sagt Ihnen, ob sich Schema, Daten oder beides in diesem bestimmten Commit für die Tabelle geändert haben.
mysql> select * from dolt_log; +----------------------------------+-----------+-----------------+-------------------------+----------------------------+ | commit_hash | committer | email | date | message | +----------------------------------+-----------+-----------------+-------------------------+----------------------------+ | 13qfqa5rojq18j84d1n2htjkm6fletg4 | Tim Sehn | [email protected] | 2022-06-07 16:39:32.066 | Populated tables with data | | ne182jemgrlm8jnjmoubfqsstlfi1s98 | Tim Sehn | [email protected] | 2022-06-07 16:35:49.277 | Created initial schema | | vluuhvd0bn59598utedt77ed9q5okbcb | Tim Sehn | [email protected] | 2022-06-07 16:33:59.531 | Initialize data repository | +----------------------------------+-----------+-----------------+-------------------------+----------------------------+ 3 rows in set (0.00 sec) mysql> select * from dolt_diff; +----------------------------------+-----------------+-----------+-----------------+-------------------------+----------------------------+-------------+---------------+ | commit_hash | table_name | committer | email | date | message | data_change | schema_change | +----------------------------------+-----------------+-----------+-----------------+-------------------------+----------------------------+-------------+---------------+ | 13qfqa5rojq18j84d1n2htjkm6fletg4 | teams | Tim Sehn | [email protected] | 2022-06-07 16:39:32.066 | Populated tables with data | 1 | 0 | | 13qfqa5rojq18j84d1n2htjkm6fletg4 | employees | Tim Sehn | [email protected] | 2022-06-07 16:39:32.066 | Populated tables with data | 1 | 0 | | 13qfqa5rojq18j84d1n2htjkm6fletg4 | employees_teams | Tim Sehn | [email protected] | 2022-06-07 16:39:32.066 | Populated tables with data | 1 | 0 | | ne182jemgrlm8jnjmoubfqsstlfi1s98 | employees | Tim Sehn | [email protected] | 2022-06-07 16:35:49.277 | Created initial schema | 0 | 1 | | ne182jemgrlm8jnjmoubfqsstlfi1s98 | employees_teams | Tim Sehn | [email protected] | 2022-06-07 16:35:49.277 | Created initial schema | 0 | 1 | | ne182jemgrlm8jnjmoubfqsstlfi1s98 | teams | Tim Sehn | [email protected] | 2022-06-07 16:35:49.277 | Created initial schema | 0 | 1 | +----------------------------------+-----------------+-----------+-----------------+-------------------------+----------------------------+-------------+---------------+ 6 rows in set (0.00 sec)
Dolt unterstützt das Rückgängigmachen von Änderungen über call dolt_reset() . Stellen wir uns vor, ich lasse versehentlich einen Tisch fallen.
mysql> drop table employees_teams; Query OK, 0 rows affected (0.01 sec) mysql> show tables; +---------------------------+ | Tables_in_getting_started | +---------------------------+ | employees | | teams | +---------------------------+ 2 rows in set (0.00 sec)
In einer herkömmlichen Datenbank könnte dies katastrophale Folgen haben. Bei Dolt sind Sie nur noch einen Befehl davon entfernt, Ihren Tisch zurückzubekommen.
mysql> call dolt_reset('--hard');
+--------+
| status |
+--------+
| 0 |
+--------+
1 row in set (0.01 sec)
mysql> show tables;
+---------------------------+
| Tables_in_getting_started |
+---------------------------+
| employees |
| employees_teams |
| teams |
+---------------------------+
3 rows in set (0.01 sec) Dolt macht den Betrieb von Datenbanken weniger fehleranfällig. Sie können laufende Änderungen jederzeit rückgängig machen oder zu einem bekanntermaßen guten Zustand zurückkehren. Sie haben auch die Möglichkeit, bestimmte Commits mit dolt_revert() rückgängig zu machen. Selbst wenn Sie drop database versehentlich auf der falschen Datenbank ausführen, können Sie dies mit Dolt rückgängig machen, indem Sie die gespeicherte Prozedur dolt_undrop() aufrufen.
Hassen Sie die Befehlszeile? Lassen Sie uns Tableplus verwenden, um einige Änderungen vorzunehmen. Tableplus ist eine kostenlose SQL Workbench. Befolgen Sie die Installationsanweisungen auf der Website.
Um nun eine Verbindung herzustellen, müssen Sie MySQL als Verbindungstyp auswählen. Geben Sie dann einen Namen für Ihre Verbindung ein, getting_started als Ihre Datenbank und root als Ihren Benutzer.
Klicken Sie auf „Verbinden“ und Sie erhalten eine vertraute Datenbank-Workbench-GUI.
Um Änderungen an einem Zweig vorzunehmen, verwende ich die gespeicherte Prozedur dolt_checkout() . Die Verwendung der Option -b erstellt einen Zweig, genau wie in Git.
Tableplus gibt mir die Möglichkeit, ein mehrzeiliges SQL-Skript auf der Registerkarte „SQL“ einzugeben. Ich habe das folgende SQL eingegeben, um einen Zweig auszuchecken, zu aktualisieren, einzufügen, zu löschen und schließlich meine Änderungen festzuschreiben.
call dolt_checkout('-b','modifications');Mitarbeiter aktualisieren SET first_name='Timothy' where first_name='Tim';insert INTO Mitarbeiter (ID, Vorname, Nachname) Werte (4,'Daylon', 'Wilkins') ;In Employees_Teams(Team_ID, Employee_ID)-Werte (0,4) einfügen;Aus Employee_Teams löschen, wobei Employee_ID=0 und Team_ID=1 sind;
call dolt_commit('-am', 'Modifications on a branch');Hier ist das Ergebnis in Tableplus.
Zurück in meinem Terminal kann ich die in Tableplus vorgenommenen Tabellenänderungen nicht sehen, da sie in einem anderen Zweig als dem erfolgt sind, den ich in meiner Sitzung ausgecheckt habe.
mysql> select * from dolt_branches; +---------------+----------------------------------+------------------+------------------------+-------------------------+----------------------------+ | name | hash | latest_committer | latest_committer_email | latest_commit_date | latest_commit_message | +---------------+----------------------------------+------------------+------------------------+-------------------------+----------------------------+ | main | 13qfqa5rojq18j84d1n2htjkm6fletg4 | Tim Sehn | [email protected] | 2022-06-07 16:39:32.066 | Populated tables with data | | modifications | uhkv57j4bp2v16vcnmev9lshgkqq8ppb | Tim Sehn | [email protected] | 2022-06-07 16:41:49.847 | Modifications on a branch | +---------------+----------------------------------+------------------+------------------------+-------------------------+----------------------------+ 2 rows in set (0.00 sec) mysql> select active_branch(); +-----------------+ | active_branch() | +-----------------+ | main | +-----------------+ 1 row in set (0.00 sec) mysql> select * from employees; +------+------------+------------+ | id | last_name | first_name | +------+------------+------------+ | 0 | Sehn | Tim | | 1 | Hendriks | Brian | | 2 | Son | Aaron | | 3 | Fitzgerald | Brian | +------+------------+------------+ 4 rows in set (0.00 sec)
Ich kann den Zweig abfragen, egal was ich ausgecheckt habe, indem ich SQL as of der Syntax verwende.
mysql> select * from employees as of 'modifications'; +------+------------+------------+ | id | last_name | first_name | +------+------------+------------+ | 0 | Sehn | Timothy | | 1 | Hendriks | Brian | | 2 | Son | Aaron | | 3 | Fitzgerald | Brian | | 4 | Wilkins | Daylon | +------+------------+------------+ 5 rows in set (0.01 sec)
Wenn ich den Unterschied zwischen den beiden Zweigen sehen möchte, kann ich die Tabellenfunktion dolt_diff() verwenden. Als Argumente werden zwei Zweige und der Tabellenname benötigt.
mysql> select * from dolt_diff('main', 'modifications', 'employees');
+--------------+---------------+-------+---------------+-------------------------+----------------+-----------------+---------+-------------+-------------------------+-----------+
| to_last_name | to_first_name | to_id | to_commit | to_commit_date | from_last_name | from_first_name | from_id | from_commit | from_commit_date | diff_type |
+--------------+---------------+-------+---------------+-------------------------+----------------+-----------------+---------+-------------+-------------------------+-----------+
| Sehn | Timothy | 0 | modifications | 2022-06-07 16:41:49.847 | Sehn | Tim | 0 | main | 2022-06-07 16:39:32.066 | modified |
| Wilkins | Daylon | 4 | modifications | 2022-06-07 16:41:49.847 | NULL | NULL | NULL | main | 2022-06-07 16:39:32.066 | added |
+--------------+---------------+-------+---------------+-------------------------+----------------+-----------------+---------+-------------+-------------------------+-----------+
2 rows in set (0.00 sec)Wie Sie sehen, steht Ihnen mit Dolt die volle Leistungsfähigkeit von Branches und Diffs im Git-Stil in einer SQL-Datenbank zur Verfügung.
Ich kann auch Schemaänderungen an Zweigen vornehmen, um neue Schemata isoliert zu testen. Ich werde eine start_date Spalte in einem neuen Zweig hinzufügen und sie füllen.
mysql> call dolt_checkout('-b', 'schema_changes');
+--------+
| status |
+--------+
| 0 |
+--------+
1 row in set (0.01 sec)
mysql> alter table employees add column start_date date;
Query OK, 0 rows affected (0.02 sec)
mysql> update employees set start_date='2018-09-08';
Query OK, 4 rows affected (0.01 sec)
Rows matched: 4 Changed: 4 Warnings: 0
mysql> update employees set start_date='2021-04-19' where last_name='Fitzgerald';
Query OK, 1 row affected (0.01 sec)
Rows matched: 1 Changed: 1 Warnings: 0
mysql> select * from employees;
+------+------------+------------+------------+
| id | last_name | first_name | start_date |
+------+------------+------------+------------+
| 0 | Sehn | Tim | 2018-09-08 |
| 1 | Hendriks | Brian | 2018-09-08 |
| 2 | Son | Aaron | 2018-09-08 |
| 3 | Fitzgerald | Brian | 2021-04-19 |
+------+------------+------------+------------+
4 rows in set (0.00 sec)
mysql> call dolt_commit('-am', 'Added start_date column to employees');
+----------------------------------+
| hash |
+----------------------------------+
| pg3nfi0j1dpc5pf1rfgckpmlteaufdrt |
+----------------------------------+
1 row in set (0.01 sec)Durch das Ändern des Schemas in einem Zweig erhalten Sie eine neue Methode zum Durchführen isolierter Integrationstests neuer Schemaänderungen.
Gehen wir davon aus, dass alle Tests des neuen Schemas im Zweig schema_changes und der Daten im Zweig modifications einwandfrei abgeschlossen wurden. Es ist Zeit, alle unsere Änderungen in main zusammenzuführen. Dies erfolgt mithilfe der gespeicherten Prozedur dolt_merge .
mysql> call dolt_checkout('main');
+--------+
| status |
+--------+
| 0 |
+--------+
1 row in set (0.01 sec)
mysql> select * from dolt_status;
Empty set (0.00 sec)
mysql> call dolt_merge('schema_changes');
+--------------+
| no_conflicts |
+--------------+
| 1 |
+--------------+
1 row in set (0.01 sec)
mysql> select * from employees;
+------+------------+------------+------------+
| id | last_name | first_name | start_date |
+------+------------+------------+------------+
| 0 | Sehn | Tim | 2018-09-08 |
| 1 | Hendriks | Brian | 2018-09-08 |
| 2 | Son | Aaron | 2018-09-08 |
| 3 | Fitzgerald | Brian | 2021-04-19 |
+------+------------+------------+------------+
4 rows in set (0.00 sec)Schemaänderung erfolgreich. Wir haben jetzt Starttermine. Als nächstes folgen Datenänderungen.
mysql> call dolt_merge('modifications');
+--------------+
| no_conflicts |
+--------------+
| 1 |
+--------------+
1 row in set (0.02 sec)
mysql> select * from employees;
+------+------------+------------+------------+
| id | last_name | first_name | start_date |
+------+------------+------------+------------+
| 0 | Sehn | Timothy | 2018-09-08 |
| 1 | Hendriks | Brian | 2018-09-08 |
| 2 | Son | Aaron | 2018-09-08 |
| 3 | Fitzgerald | Brian | 2021-04-19 |
| 4 | Wilkins | Daylon | NULL |
+------+------------+------------+------------+
5 rows in set (0.00 sec)Auch Datenänderungen erfolgreich. Wie Sie sehen können, bin ich jetzt „Timothy“ statt „Tim“, Daylon wurde hinzugefügt und wir haben alle Startdaten, außer Daylon, der in einem anderen Zweig hinzugefügt wurde.
mysql> select first_name, last_name, team_name from employees join employees_teams on (employees.id=employees_teams.employee_id) join teams on (teams.id=employees_teams.team_id) where team_name='Sales'; +------------+------------+-----------+ | first_name | last_name | team_name | +------------+------------+-----------+ | Brian | Fitzgerald | Sales | +------------+------------+-----------+ 1 row in set (0.01 sec)
Ich bin auch aus dem Vertriebsteam gegangen. Technik ist Leben.
Ich muss alle meine Änderungen festschreiben, da die letzte Zusammenführung keine Schnellvorlauf-Zusammenführung war.
mysql> call dolt_commit('-m', 'Merged all branches');
+----------------------------------+
| hash |
+----------------------------------+
| vn9b0qcematsj2f6ka0hfoflhr5s6p0b |
+----------------------------------+
1 row in set (0.01 sec)
mysql> select * from dolt_log;
+----------------------------------+-----------+-----------------+-------------------------+--------------------------------------+
| commit_hash | committer | email | date | message |
+----------------------------------+-----------+-----------------+-------------------------+--------------------------------------+
| vn9b0qcematsj2f6ka0hfoflhr5s6p0b | Tim Sehn | [email protected] | 2022-06-07 17:10:02.07 | Merged all branches |
| pg3nfi0j1dpc5pf1rfgckpmlteaufdrt | Tim Sehn | [email protected] | 2022-06-07 16:44:37.513 | Added start_date column to employees |
| uhkv57j4bp2v16vcnmev9lshgkqq8ppb | Tim Sehn | [email protected] | 2022-06-07 16:41:49.847 | Modifications on a branch |
| 13qfqa5rojq18j84d1n2htjkm6fletg4 | Tim Sehn | [email protected] | 2022-06-07 16:39:32.066 | Populated tables with data |
| ne182jemgrlm8jnjmoubfqsstlfi1s98 | Tim Sehn | [email protected] | 2022-06-07 16:35:49.277 | Created initial schema |
| vluuhvd0bn59598utedt77ed9q5okbcb | Tim Sehn | [email protected] | 2022-06-07 16:33:59.531 | Initialize data repository |
+----------------------------------+-----------+-----------------+-------------------------+--------------------------------------+
6 rows in set (0.00 sec)Jetzt haben wir eine Datenbank, in der alle Schema- und Datenänderungen zusammengeführt und einsatzbereit sind.
Welcher Commit hat meinen Vornamen geändert? Mit Dolt haben Sie die Abstammung für jede Zelle in Ihrer Datenbank. Lassen Sie uns dolt_history_ und dolt_diff_ verwenden, um die Abstammungsmerkmale in Dolt zu erkunden.
dolt_history_ zeigt Ihnen den Status der Zeile bei jedem Commit.
mysql> select * from dolt_history_employees where id=0 order by commit_date; +------+-----------+------------+------------+----------------------------------+-----------+-------------------------+ | id | last_name | first_name | start_date | commit_hash | committer | commit_date | +------+-----------+------------+------------+----------------------------------+-----------+-------------------------+ | 0 | Sehn | Tim | NULL | 13qfqa5rojq18j84d1n2htjkm6fletg4 | Tim Sehn | 2022-06-07 16:39:32.066 | | 0 | Sehn | Timothy | NULL | uhkv57j4bp2v16vcnmev9lshgkqq8ppb | Tim Sehn | 2022-06-07 16:41:49.847 | | 0 | Sehn | Tim | 2018-09-08 | pg3nfi0j1dpc5pf1rfgckpmlteaufdrt | Tim Sehn | 2022-06-07 16:44:37.513 | | 0 | Sehn | Timothy | 2018-09-08 | vn9b0qcematsj2f6ka0hfoflhr5s6p0b | Tim Sehn | 2022-06-07 17:10:02.07 | +------+-----------+------------+------------+----------------------------------+-----------+-------------------------+ 4 rows in set (0.00 sec)
dolt_diff_ können Sie den Verlauf so filtern, dass nur Commits vorgenommen werden, wenn sich die betreffende Zelle geändert hat. In diesem Fall interessieren mich die Commits, die meinen Vornamen ändern. Beachten Sie, dass es zwei Commits gibt, die meinen Namen geändert haben, da einer die ursprüngliche Änderung und der zweite der Merge-Commit ist.
mysql> select to_commit,from_first_name,to_first_name from dolt_diff_employees where (from_id=0 or to_id=0) and (from_first_name <> to_first_name or from_first_name is NULL) order by to_commit_date; +----------------------------------+-----------------+---------------+ | to_commit | from_first_name | to_first_name | +----------------------------------+-----------------+---------------+ | 13qfqa5rojq18j84d1n2htjkm6fletg4 | NULL | Tim | | uhkv57j4bp2v16vcnmev9lshgkqq8ppb | Tim | Timothy | | vn9b0qcematsj2f6ka0hfoflhr5s6p0b | Tim | Timothy | +----------------------------------+-----------------+---------------+ 3 rows in set (0.01 sec)
Dolt bietet leistungsstarke Datenprüfungsfunktionen bis hin zu einzelnen Zellen. Wann, wie und warum hat sich jede Zelle in Ihrer Datenbank im Laufe der Zeit verändert?
Schauen Sie sich jetzt unsere Dokumentation an, da Sie ein Gefühl für Dolt haben. Sie können auch in unserem Blog nachlesen, woran wir gearbeitet haben.
