dolt
1.43.16
Dolt est une base de données SQL que vous pouvez créer, cloner, créer des branches, fusionner, pousser et extraire, tout comme un référentiel Git.
Connectez-vous à Dolt comme n'importe quelle base de données MySQL pour lire ou modifier le schéma et les données. La fonctionnalité de contrôle de version est exposée dans SQL via des tables système, des fonctions et des procédures.
Vous pouvez également utiliser l'interface de ligne de commande de type Git pour importer des fichiers CSV, valider vos modifications, les transférer vers une télécommande ou fusionner les modifications de votre coéquipier. Toutes les commandes que vous connaissez pour Git fonctionnent exactement de la même manière pour Dolt.
Fichiers des versions Git. Tableaux des versions Dolt. C'est comme si Git et MySQL avaient eu un bébé.
Nous avons également construit DoltHub, un endroit pour partager les bases de données Dolt. Nous hébergeons gratuitement des données publiques. Si vous souhaitez héberger votre propre version de DoltHub, nous avons DoltLab. Si vous souhaitez que nous gérions un serveur Dolt pour vous, nous avons Hosted Dolt. Si vous recherchez une version Postgres de Dolt, nous avons construit DoltgreSQL. Attention, c'est le début de l'Alpha. Dolt est prêt pour la production.
Rejoignez-nous sur Discord pour nous dire bonjour et poser des questions, ou consultez notre feuille de route pour voir ce que nous construisons ensuite.
Beaucoup de choses ! Dolt est un outil généralement utile avec d'innombrables applications. Mais si vous voulez des idées, voici comment les gens l'utilisent jusqu'à présent.
Dolt peut être configuré comme une réplique de votre base de données MySQL ou MariaDB existante à l'aide de la réplication standard des journaux binaires MySQL. Chaque écriture devient un commit Dolt. C'est un excellent moyen de bénéficier des avantages du contrôle de version de Dolt et de conserver une base de données MySQL ou MariaDB existante.
La CLI dolt a les mêmes commandes que git , avec quelques 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 est un seul programme d'environ 103 mégaoctets.
dolt $ du -h /Users/timsehn/go/bin/dolt 103 millions /Utilisateurs/timsehn/go/bin/dolt
C'est vraiment facile à installer. Téléchargez-le et mettez-le sur votre PATH . Nous proposons de nombreuses façons de rendre cela encore plus facile pour la plupart des plateformes.
Pour installer sur des systèmes Linux ou Mac, exécutez cette commande dans votre terminal :
sudo bash -c 'curl -L https://github.com/dolthub/dolt/releases/latest/download/install.sh | bash'
Cela téléchargera la dernière version dolt et la placera dans /usr/local/bin/ , qui se trouve probablement sur votre $PATH .
Le script d'installation a besoin de sudo pour mettre dolt dans /usr/local/bin . Si vous ne disposez pas des privilèges root ou n'êtes pas à l'aise pour exécuter un script avec eux, vous pouvez télécharger le binaire dolt pour votre plate-forme à partir de la dernière version, le décompresser et placer le binaire quelque part sur votre $PATH .
Dolt est fourni dans les référentiels officiels d'Arch Linux.
pacman -S dolt
Dolt est sur Homebrew, mis à jour à chaque version.
brew install dolt
Sur macOS, Dolt peut également être installé via un port géré par la communauté via MacPorts :
port sudo installer dolt
Téléchargez le dernier programme d'installation de Microsoft (fichier .msi ) dans les versions et exécutez-le.
Pour plus d’informations sur l’exécution sous Windows, voir ici.
Vous pouvez installer dolt en utilisant Chocolatey :
choco installer idiot
Il existe les images Docker officielles suivantes pour Dolt :
dolthub/dolt pour exécuter Dolt en tant qu'outil CLI.
dolthub/dolt-sql-server pour exécuter Dolt en mode serveur.
Assurez-vous que Go est installé et que go est sur votre chemin. Dolt a une dépendance à cgo, vous aurez donc également besoin d'un compilateur C et d'une chaîne d'outils fonctionnels.
Clonez ce référentiel et placez-le dans le répertoire go . Puis exécutez :
go install ./cmd/dolt
La sortie sera dans $GOPATH/bin , qui est par défaut ~/go/bin . Pour tester votre build, essayez :
~/go/bin/dolt version
Vérifiez que votre installation a réussi en exécutant dolt dans votre terminal.
$ dolt Valid commands for dolt are [...]
Configurez dolt avec votre nom d'utilisateur et votre adresse e-mail, dont vous aurez besoin pour créer des commits. Les commandes fonctionnent exactement de la même manière que git.
$ dolt config --global --add user.email [email protected] $ dolt config --global --add user.name "YOUR NAME"
Dolt a besoin d'un endroit pour stocker vos bases de données. Je vais mettre mes bases de données dans ~/dolt .
% cd ~% mkdir imbécile % cd idiot
Toutes les bases de données que vous créez seront stockées dans ce répertoire. Ainsi, pour cet exemple, un répertoire nommé getting_started sera créé ici une fois que vous aurez exécuté create database getting_started . Naviguer vers ~/dolt/getting_started vous permettra d'accéder à cette base de données à l'aide de la ligne de commande Dolt.
REMARQUE : Pour cet exemple, le répertoire getting_started sera créé après l'exécution create database getting_started; dans un shell SQL dans la section Créer un schéma. Ne faites rien d'autre que créer le répertoire et y accéder pour l'instant.
Dolt est livré avec un serveur de base de données compatible MySQL intégré. Pour le démarrer, vous utilisez la commande dolt sql-server . L'exécution de cette commande démarre le serveur sur le port 3306.
serveur SQL dolt Démarrage du serveur avec Config HP="localhost:3306"|T="28800000"|R="false"|L="info"
Votre terminal restera simplement là. Cela signifie que le serveur est en cours d'exécution. Toutes les erreurs seront imprimées dans ce terminal. Laissez-le là et ouvrez un nouveau terminal.
Dans le nouveau terminal, nous allons maintenant nous connecter au serveur de base de données en cours d'exécution à l'aide d'un client. Dolt est également livré avec un client compatible MySQL.
% dolt -u root -p "" sql# Bienvenue sur le client Dolt MySQL.# Les instructions doivent se terminer par ';'.# "exit" ou "quit" (ou Ctrl-D) pour quitter.mysql>
Dans l'autre terminal où vous avez exécuté dolt sql-server , vous verrez la ligne de journal suivante.
2022-06-06T13:14:32-07:00 INFO [conn 1] NewConnection {DisableClientMultiStatements=false}Vous êtes connecté !
Pendant que nous sommes ici, récupérons une copie de MySQL afin de pouvoir nous connecter à ce client. Rendez-vous sur la documentation MySQL Getting Started et installez MySQL sur votre machine. J'ai utilisé Homebrew pour installer MySQL sur mon Mac.
MySQL est livré avec un serveur MySQL appelé mysqld et un client MySQL appelé mysql . Seul le client vous intéresse. Après avoir suivi les instructions de la documentation MySQL, assurez-vous d'avoir une copie du client mysql sur votre chemin :
% mysql --version mysql Ver 8.0.29 pour macos12.2 sur x86_64 (Homebrew)
Maintenant, pour connecter le client mysql à Dolt, vous allez forcer le client MySQL via l'interface TCP en passant un hôte et un port. La valeur par défaut est l'interface socket prise en charge par Dolt, mais n'est disponible que sur localhost . Il est donc préférable de montrer l'interface TCP. Le client MySQL nécessite également que vous spécifiiez un utilisateur, dans ce cas root .
% mysql --hôte 127.0.0.1 --port 3306 -uroot Bienvenue sur le moniteur MySQL. Les commandes se terminent par ; ou g. Votre identifiant de connexion MySQL est 2 Version du serveur : 5.7.9-Vitess Copyright (c) 2000, 2022, Oracle et/ou ses sociétés affiliées. Oracle est une marque déposée d'Oracle Corporation et/ou de son affiliés. D'autres noms peuvent être des marques déposées de leurs propriétaires respectifs propriétaires. Tapez « aide ; » ou 'h' pour obtenir de l'aide. Tapez 'c' pour effacer l'instruction d'entrée actuelle. mysql>
Encore une fois, pour vous assurer que le client est réellement connecté, vous devriez voir ce qui suit dans le terminal dolt sql-server
2022-06-06T13:26:55-07:00 INFO [conn 2] NewConnection {DisableClientMultiStatements=false}Comme vous pouvez le constater, Dolt prend en charge n'importe quel client compatible MySQL. Dolt est livré avec un client mais vous pouvez utiliser n'importe quel client MySQL, comme celui fourni avec MySQL.
Maintenant, nous sommes prêts à faire quelque chose d'intéressant. Je vais rester dans le client mysql et exécuter les instructions SQL suivantes pour créer une base de données appelée getting_started . La base de données getting_started aura trois tables : employees , teams et 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 prend en charge les clés étrangères, les index secondaires, les déclencheurs, les contraintes de vérification et les procédures stockées. Il s'agit d'une base de données SQL moderne et riche en fonctionnalités.
Il est temps d'utiliser votre première fonctionnalité Dolt. Nous allons faire un commit Dolt. Un commit Dolt vous permet de voyager dans le temps et de voir la lignée. Effectuez un commit Dolt chaque fois que vous souhaitez restaurer ou comparer à ce moment précis.
Dolt expose la fonctionnalité de contrôle de version via une interface de style Git. Sur la ligne de commande, les commandes Dolt correspondent exactement à leur équivalent Git, les cibles étant des tables au lieu de fichiers. En SQL, Dolt expose les opérations de lecture du contrôle de version sous forme de tables système et les opérations d'écriture de contrôle de version sous forme de procédures stockées.
La dénomination des tables système et des procédures stockées suit le modèle dolt_ . Donc dolt add sur la CLI devient dolt_add en tant que procédure stockée. Le passage des options suit également le modèle de ligne de commande. Par exemple, pour spécifier les tables à ajouter, envoyez les noms des tables en tant qu'options à la procédure dolt_add . Pour les arguments nommés comme l'envoi d'un message dans la commande dolt_commit , utilisez deux arguments dans l'ordre comme ('-m', 'This is a message') . Si vous connaissez Git, les procédures de contrôle de version et les tables système devraient vous sembler familières.
Nous ajoutons donc et validons notre nouveau schéma comme ceci.
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) Et voilà. Votre schéma est créé et vous disposez d'un commit Dolt qui suit la création, comme le montre la table système dolt_log .
Notez qu'un commit Dolt est différent d'une transaction SQL standard COMMIT . Dans ce cas, j'exécute la base de données avec AUTOCOMMIT activé, donc chaque instruction SQL génère automatiquement une transaction COMMIT . Si vous souhaitez que le système génère un commit Dolt pour chaque transaction, utilisez la variable système @@dolt_transaction_commit .
Maintenant, je vais remplir la base de données avec quelques employés ici chez DoltHub. Ensuite, j'affecterai les employés à deux équipes : l'ingénierie et les ventes. Le PDG porte plusieurs casquettes dans une start-up et sera donc affecté à plusieurs équipes.
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]`
Oups, j'ai violé une contrainte. On dirait que j'ai créé le tableau avec des équipes avant les employés. Vous devez toujours spécifier vos colonnes lors de l'insertion, et ne pas vous fier à l'ordre naturel. Ça me sert bien ! Dolt est doté de toute la puissance d'une base de données relationnelle SQL moderne pour garantir l'intégrité des données.
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)
On dirait que tout est inséré et correct. J'ai pu lister les membres de l'équipe d'ingénierie en utilisant ces trois tables JOIN . Dolt prend en charge jusqu'à douze tables JOIN . Encore une fois, Dolt est une base de données relationnelle SQL moderne associée à un contrôle de version de style Git.
Maintenant, que se passe-t-il si vous souhaitez voir ce qui a changé dans votre ensemble de travail avant de procéder à une validation ? Vous utilisez les tables système dolt_status et 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)
Comme vous pouvez le voir sur la différence, j'ai ajouté les valeurs correctes à la table employees . Les valeurs étaient auparavant NULL et elles sont désormais renseignées.
Terminons avec un autre commit Dolt cette fois en ajoutant toutes les tables affectées en utilisant -am .
mysql> call dolt_commit('-am', 'Populated tables with data');
+----------------------------------+
| hash |
+----------------------------------+
| 13qfqa5rojq18j84d1n2htjkm6fletg4 |
+----------------------------------+
1 row in set (0.02 sec) Vous pouvez inspecter le journal à l'aide dolt_log et voir quelles tables ont été modifiées dans chaque validation à l'aide d'un dolt_diff sans portée. Unscoped dolt_diff vous indique si le schéma, les données ou les deux ont été modifiés dans cette validation particulière pour la table.
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 prend en charge l'annulation des modifications via call dolt_reset() . Imaginons que je laisse tomber une table accidentellement.
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)
Dans une base de données traditionnelle, cela pourrait être désastreux. Dans Dolt, vous n'êtes qu'à une commande de récupérer votre table.
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 rend les bases de données d'exploitation moins sujettes aux erreurs. Vous pouvez toujours annuler les modifications en cours ou revenir à un bon état connu. Vous avez également la possibilité d'annuler des commits spécifiques en utilisant dolt_revert() . Même si vous exécutez accidentellement drop database sur la mauvaise base de données, Dolt vous permet d'annuler cela en appelant la procédure stockée dolt_undrop() .
Vous détestez la ligne de commande ? Utilisons Tableplus pour apporter quelques modifications. Tableplus est un Workbench SQL gratuit. Suivez les instructions d'installation de leur site Web.
Maintenant, pour vous connecter, vous devez sélectionner MySQL comme type de connexion. Entrez ensuite un nom pour votre connexion, getting_started comme base de données et root comme utilisateur.
Cliquez sur Connecter et une interface graphique familière d'atelier de base de données vous sera présentée.
Pour apporter des modifications sur une branche, j'utilise la procédure stockée dolt_checkout() . L'utilisation de l'option -b crée une branche, comme dans Git.
Tableplus me donne la possibilité de saisir un script SQL sur plusieurs lignes dans l'onglet SQL. J'ai entré le SQL suivant pour extraire une branche, mettre à jour, insérer, supprimer et enfin Dolt valider mes modifications.
appeler dolt_checkout('-b','modifications');mettre à jour les employés SET first_name='Timothy' où first_name='Tim';insérer INTO employés (id, prénom, nom) valeurs (4,'Daylon', 'Wilkins') ;insérer dans les valeurs employés_équipes (team_id, employé_id) (0,4) ;supprimer de employés_équipes où employé_id=0 et team_id=1 ;
call dolt_commit('-am', 'Modifications sur une branche');Voici le résultat dans Tableplus.
De retour dans mon terminal, je ne vois pas les modifications de table effectuées dans Tableplus car elles se sont produites sur une branche différente de celle que j'ai extraite lors de ma session.
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)
Je peux interroger la branche, peu importe ce que j'ai extrait en utilisant SQL as of syntaxe.
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)
Si je souhaite voir la différence entre les deux branches, je peux utiliser la fonction de table dolt_diff() . Il prend deux branches et le nom de la table comme arguments.
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)Comme vous pouvez le constater, vous disposez de toute la puissance des branches et des différences de style Git dans une base de données SQL avec Dolt.
Je peux également apporter des modifications au schéma sur les branches pour des tests isolés d'un nouveau schéma. Je vais ajouter une colonne start_date sur une nouvelle branche et la remplir.
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)Changer de schéma sur une branche vous offre une nouvelle méthode pour effectuer des tests d'intégration isolés de nouvelles modifications de schéma.
Supposons que tous les tests du nouveau schéma sur la branche schema_changes et des données sur la branche modifications se soient déroulés sans problème. Il est temps de fusionner toutes nos modifications sur main . Cela se fait à l'aide de la procédure stockée 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)Changement de schéma réussi. Nous avons maintenant des dates de début. Les changements de données viennent ensuite.
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)Les modifications de données ont également réussi. Comme vous pouvez le voir, je m'appelle désormais "Timothy" au lieu de "Tim", Daylon est ajouté, et nous avons tous des dates de début sauf Daylon qui a été ajouté sur une branche différente.
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)
Je quitte également l'équipe commerciale. L'ingénierie, c'est la vie.
Je dois valider toutes mes modifications car la dernière fusion n'était pas une fusion rapide.
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)Nous disposons désormais d'une base de données avec toutes les modifications de schéma et de données fusionnées et prêtes à l'emploi.
Quel commit a changé mon prénom ? Avec Dolt, vous disposez d'une lignée pour chaque cellule de votre base de données. Utilisons dolt_history_ et dolt_diff_ pour explorer les fonctionnalités de lignage dans Dolt.
dolt_history_ vous montre l'état de la ligne à chaque validation.
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_ vous permet de filtrer l'historique pour ne valider que lorsque la cellule en question a changé. Dans ce cas, je m'intéresse aux commits qui changent mon prénom. Notez qu'il y a deux commits qui ont changé mon nom car l'un est le changement d'origine et le second est le commit de fusion.
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 fournit de puissantes capacités d'audit des données jusqu'aux cellules individuelles. Quand, comment et pourquoi chaque cellule de votre base de données a-t-elle changé au fil du temps ?
Rendez-vous sur notre documentation maintenant que vous avez une idée de Dolt. Vous pouvez également découvrir ce sur quoi nous travaillons sur notre blog.
