dolt
1.43.16
Dolt é um banco de dados SQL que você pode bifurcar, clonar, ramificar, mesclar, enviar e receber como um repositório Git.
Conecte-se ao Dolt como qualquer banco de dados MySQL para ler ou modificar esquemas e dados. A funcionalidade de controle de versão é exposta no SQL por meio de tabelas, funções e procedimentos do sistema.
Ou use a interface de linha de comando semelhante ao Git para importar arquivos CSV, confirmar suas alterações, enviá-las para um controle remoto ou mesclar as alterações de seus colegas de equipe. Todos os comandos que você conhece para Git funcionam exatamente da mesma forma para Dolt.
Arquivos de versões do Git. Tabelas de versões Dolt. É como se o Git e o MySQL tivessem um filho.
Também construímos o DoltHub, um lugar para compartilhar bancos de dados Dolt. Hospedamos dados públicos gratuitamente. Se você deseja hospedar sua própria versão do DoltHub, temos o DoltLab. Se você deseja que executemos um servidor Dolt para você, temos o Hosted Dolt. Se você está procurando uma versão Postgres do Dolt, nós construímos o DoltgreSQL. Aviso, é Alpha precoce. Dolt está pronto para produção.
Junte-se a nós no Discord para dizer oi e fazer perguntas ou confira nosso roteiro para ver o que estamos construindo a seguir.
Muitas coisas! Dolt é uma ferramenta geralmente útil com inúmeras aplicações. Mas se você quiser algumas ideias, veja como as pessoas estão usando isso até agora.
O Dolt pode ser configurado como uma réplica do seu banco de dados MySQL ou MariaDB existente usando a replicação binlog padrão do MySQL. Cada gravação se torna um commit Dolt. Esta é uma ótima maneira de obter os benefícios do controle de versão do Dolt e manter um banco de dados MySQL ou MariaDB existente.
A CLI dolt possui os mesmos comandos do git , com alguns 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 é um único programa de aproximadamente 103 megabytes.
dolt $ du -h /Users/timsehn/go/bin/dolt 103M /Usuários/timsehn/go/bin/dolt
É muito fácil de instalar. Baixe-o e coloque-o no seu PATH . Temos várias maneiras de tornar isso ainda mais fácil para a maioria das plataformas.
Para instalar em sistemas baseados em Linux ou Mac, execute este comando em seu terminal:
sudo bash -c 'curl -L https://github.com/dolthub/dolt/releases/latest/download/install.sh | bash'
Isso fará o download da versão mais recente dolt e a colocará em /usr/local/bin/ , que provavelmente está no seu $PATH .
O script de instalação precisa do sudo para colocar dolt em /usr/local/bin . Se você não tem privilégios de root ou não se sente confortável em executar um script com eles, você pode baixar o binário dolt para sua plataforma na versão mais recente, descompactá-lo e colocar o binário em algum lugar no seu $PATH .
Dolt está empacotado nos repositórios oficiais do Arch Linux.
pacman -S dolt
Dolt está no Homebrew, atualizado a cada versão.
brew install dolt
No macOS, o Dolt também pode ser instalado por meio de uma porta gerenciada pela comunidade via MacPorts:
porta sudo instalar dolt
Baixe o Microsoft Installer mais recente (arquivo .msi ) nas versões e execute-o.
Para obter informações sobre execução no Windows, veja aqui.
Você pode instalar dolt usando Chocolatey:
choco instalar dolt
Existem as seguintes imagens oficiais do Docker para Dolt:
dolthub/dolt para executar Dolt como ferramenta CLI.
dolthub/dolt-sql-server para executar o Dolt no modo servidor.
Certifique-se de ter o Go instalado e que o go esteja no seu caminho. Dolt depende do cgo, então você também precisará de um compilador C funcional e um conjunto de ferramentas.
Clone este repositório e faça cd no diretório go . Então execute:
go install ./cmd/dolt
A saída estará em $GOPATH/bin , cujo padrão é ~/go/bin . Para testar sua compilação, tente:
~/go/bin/dolt version
Verifique se sua instalação foi bem-sucedida executando dolt em seu terminal.
$ dolt Valid commands for dolt are [...]
Configure dolt com seu nome de usuário e e-mail, que você precisará para criar commits. Os comandos funcionam exatamente da mesma forma que o git.
$ dolt config --global --add user.email [email protected] $ dolt config --global --add user.name "YOUR NAME"
Dolt precisa de um local para armazenar seus bancos de dados. Vou colocar meus bancos de dados em ~/dolt .
% cd ~% mkdir dolt % cd idiota
Todos os bancos de dados que você criar serão armazenados neste diretório. Portanto, para este exemplo, um diretório chamado getting_started será criado aqui assim que você executar create database getting_started . Navegar para ~/dolt/getting_started permitirá que você acesse este banco de dados usando a linha de comando Dolt.
NOTA: Para este exemplo, o diretório getting_started será criado após você executar create database getting_started; em um shell SQL na seção Criar um esquema. Não faça nada, exceto criar o diretório e navegar até ele ainda.
O Dolt vem com um servidor de banco de dados compatível com MySQL integrado. Para iniciá-lo você usa o comando dolt sql-server . A execução deste comando inicia o servidor na porta 3306.
dolt servidor sql Iniciando servidor com Config HP="localhost:3306"|T="28800000"|R="false"|L="info"
Seu terminal ficará pendurado ali. Isso significa que o servidor está em execução. Quaisquer erros serão impressos neste terminal. Basta deixá-lo aí e abrir um novo terminal.
No novo terminal, agora nos conectaremos ao servidor de banco de dados em execução usando um cliente. Dolt também vem com um cliente compatível com MySQL.
% dolt -u root -p "" sql# Bem-vindo ao cliente Dolt MySQL.# As instruções devem ser finalizadas com ';'.# "exit" ou "quit" (ou Ctrl-D) para exit.mysql>
No outro terminal onde você executou dolt sql-server , você verá a seguinte linha de log.
2022-06-06T13:14:32-07:00 INFO [conn 1] NewConnection {DisableClientMultiStatements=false}Você está conectado!
Enquanto estamos aqui, vamos pegar uma cópia do MySQL para que possamos nos conectar com esse cliente. Acesse a documentação de primeiros passos do MySQL e instale o MySQL em sua máquina. Usei o Homebrew para instalar o MySQL no meu Mac.
MySQL vem com um servidor MySQL chamado mysqld e um cliente MySQL chamado mysql . Você está interessado apenas no cliente. Após seguir as instruções da documentação do MySQL, certifique-se de ter uma cópia do cliente mysql em seu caminho:
% mysql --versão mysql Ver 8.0.29 para macos12.2 em x86_64 (Homebrew)
Agora, para conectar o cliente mysql ao Dolt, você forçará o cliente MySQL através da interface TCP, passando um host e uma porta. O padrão é a interface de soquete suportada pelo Dolt, mas está disponível apenas em localhost . Então, é melhor mostrar a interface TCP. O cliente MySQL também exige que você especifique um usuário, neste caso root .
% mysql --host 127.0.0.1 --port 3306 -uroot Bem-vindo ao monitor MySQL. Os comandos terminam com; ou g. Seu ID de conexão MySQL é 2 Versão do servidor: 5.7.9-Vitess Copyright (c) 2000, 2022, Oracle e/ou suas afiliadas. Oracle é uma marca registrada da Oracle Corporation e/ou de seus afiliados. Outros nomes podem ser marcas registradas de seus respectivos proprietários. Digite 'ajuda;' ou 'h' para obter ajuda. Digite 'c' para limpar a instrução de entrada atual. mysql>
Novamente, para garantir que o cliente realmente esteja conectado, você deverá ver o seguinte no terminal dolt sql-server
2022-06-06T13:26:55-07:00 INFO [conn 2] NewConnection {DisableClientMultiStatements=false}Como você pode ver, Dolt oferece suporte a qualquer cliente compatível com MySQL. O Dolt vem com um cliente, mas você pode usar qualquer cliente MySQL, como aquele que vem com o MySQL.
Agora estamos realmente prontos para fazer algo interessante. Ficarei no cliente mysql e executarei as seguintes instruções SQL para criar um banco de dados chamado getting_started . O banco de dados getting_started terá três tabelas: employees , teams e 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 oferece suporte a chaves estrangeiras, índices secundários, gatilhos, restrições de verificação e procedimentos armazenados. É um banco de dados SQL moderno e rico em recursos.
É hora de usar seu primeiro recurso Dolt. Vamos fazer um commit Dolt. Um commit Dolt permite viajar no tempo e ver a linhagem. Faça um commit Dolt sempre que quiser restaurar ou comparar com este momento.
Dolt expõe a funcionalidade de controle de versão por meio de uma interface estilo Git. Na linha de comando, os comandos Dolt são mapeados exatamente para seu equivalente Git, com os destinos sendo tabelas em vez de arquivos. No SQL, Dolt expõe operações de leitura de controle de versão como tabelas de sistema e operações de gravação de controle de versão como procedimentos armazenados.
A nomenclatura das tabelas do sistema e dos procedimentos armazenados segue o padrão dolt_ . Portanto, dolt add na CLI torna-se dolt_add como um procedimento armazenado. As opções de passagem também seguem o modelo de linha de comando. Por exemplo, para especificar tabelas a serem adicionadas, envie os nomes das tabelas como opções para o procedimento dolt_add . Para argumentos nomeados, como enviar uma mensagem para o comando dolt_commit , use dois argumentos em sequência, como ('-m', 'This is a message') . Se você conhece Git, os procedimentos de controle de versão e as tabelas do sistema devem parecer familiares.
Então, adicionamos e confirmamos nosso novo esquema assim.
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) Aí está. Seu esquema é criado e você tem um commit Dolt rastreando a criação, conforme visto na tabela do sistema dolt_log .
Observe que um commit Dolt é diferente de uma transação SQL padrão COMMIT . Neste caso, estou executando o banco de dados com AUTOCOMMIT ativado, portanto cada instrução SQL gera automaticamente uma transação COMMIT . Se você deseja que o sistema gere um commit Dolt para cada transação, use a variável do sistema, @@dolt_transaction_commit .
Agora, vou preencher o banco de dados com alguns funcionários aqui do DoltHub. Depois, atribuirei os funcionários a duas equipes: engenharia e vendas. O CEO desempenha muitas funções em uma start-up, por isso será designado para várias equipes.
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]`
Ops, violei uma restrição. Parece que criei a tabela com equipes antes de funcionários. Você deve sempre especificar suas colunas ao inserir, e não confiar na ordem natural. Me serve bem! Dolt vem com todo o poder de um banco de dados relacional SQL moderno para garantir a integridade dos dados.
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)
Parece que tudo está inserido e correto. Consegui listar os membros da equipe de engenharia usando aquelas três tabelas JOIN . Dolt suporta até doze JOIN s de tabela. Novamente, Dolt é um banco de dados relacional SQL moderno combinado com controle de versão no estilo Git.
Agora, e se você quiser ver o que mudou em seu conjunto de trabalho antes de fazer um commit? Você usa as tabelas de sistema dolt_status e 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)
Como você pode ver na comparação, adicionei os valores corretos à tabela employees . Os valores eram anteriormente NULL e agora estão preenchidos.
Vamos terminar com outro commit Dolt desta vez adicionando todas as tabelas afetadas usando -am .
mysql> call dolt_commit('-am', 'Populated tables with data');
+----------------------------------+
| hash |
+----------------------------------+
| 13qfqa5rojq18j84d1n2htjkm6fletg4 |
+----------------------------------+
1 row in set (0.02 sec) Você pode inspecionar o log usando dolt_log e ver quais tabelas foram alteradas em cada commit usando um dolt_diff sem escopo. dolt_diff sem escopo informa se o esquema, os dados ou ambos foram alterados naquele commit específico da tabela.
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 suporta desfazer alterações por meio call dolt_reset() . Vamos imaginar que eu acidentalmente derrubei uma mesa.
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)
Em um banco de dados tradicional, isso poderia ser desastroso. Em Dolt, você está a um comando de recuperar sua mesa.
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 torna os bancos de dados operacionais menos propensos a erros. Você sempre pode reverter as alterações em andamento ou retroceder para um estado bom conhecido. Você também pode desfazer commits específicos usando dolt_revert() . Mesmo se você acidentalmente executar drop database no banco de dados errado, Dolt permite desfazer isso chamando o procedimento armazenado dolt_undrop() .
Odeio a linha de comando? Vamos usar o Tableplus para fazer algumas modificações. Tableplus é um SQL Workbench gratuito. Siga as instruções de instalação do site deles.
Agora, para conectar você deve selecionar MySQL como tipo de conexão. Em seguida, insira um nome para sua conexão, getting_started como seu banco de dados e root como seu usuário.
Clique em conectar e você verá uma GUI familiar do ambiente de trabalho de banco de dados.
Para fazer alterações em uma ramificação, eu uso o procedimento armazenado dolt_checkout() . Usar a opção -b cria um branch, assim como no Git.
O Tableplus me permite inserir um script SQL de várias linhas na guia SQL. Digitei o seguinte SQL para verificar uma ramificação, atualizar, inserir, excluir e, finalmente, confirmar minhas alterações.
chamar dolt_checkout('-b','modificações');atualizar funcionários SET first_name='Timothy' where first_name='Tim';inserir INTO funcionários (id, first_name, last_name) valores (4,'Daylon', 'Wilkins') ;inserir em Employees_teams(team_id, Employee_id) valores (0,4);excluir de Employees_teams onde Employee_id=0 e id_equipe=1;
chame dolt_commit('-am', 'Modificações em uma ramificação');Aqui está o resultado no Tableplus.
De volta ao meu terminal, não consigo ver as modificações de tabela feitas no Tableplus porque elas aconteceram em um branch diferente daquele que verifiquei em minha sessão.
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)
Posso consultar o branch independentemente do que verifiquei usando SQL as of sintaxe.
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)
Se eu quiser ver a diferença entre os dois ramos, posso usar a função de tabela dolt_diff() . São necessários dois ramos e o nome da tabela como argumentos.
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)Como você pode ver, você tem todo o poder das ramificações e diferenças no estilo Git em um banco de dados SQL com Dolt.
Também posso fazer alterações de esquema em ramificações para testes isolados de novos esquemas. Vou adicionar uma coluna start_date em uma nova ramificação e preenchê-la.
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)A alteração do esquema em uma ramificação oferece um novo método para realizar testes de integração isolados de novas alterações de esquema.
Vamos supor que todos os testes do novo esquema na ramificação schema_changes e os dados na ramificação modifications foram concluídos perfeitamente. É hora de mesclar todas as nossas edições em main . Isso é feito usando o procedimento armazenado 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)Alteração de esquema bem-sucedida. Agora temos datas de início. As alterações de dados são as próximas.
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)As alterações de dados também foram bem-sucedidas. Como você pode ver, agora sou "Timothy" em vez de "Tim", Daylon foi adicionado e todos nós temos datas de início, exceto Daylon, que foi adicionado em um branch diferente.
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)
Também saí da Equipe de Vendas. Engenharia é vida.
Tenho que confirmar todas as minhas alterações porque a última mesclagem não foi uma mesclagem de avanço rápido.
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)Agora temos um banco de dados com todas as alterações de esquema e dados mescladas e prontas para uso.
Qual commit mudou meu primeiro nome? Com Dolt você tem linhagem para cada célula do seu banco de dados. Vamos usar dolt_history_ e dolt_diff_ para explorar os recursos de linhagem em Dolt.
dolt_history_ mostra o estado da linha em cada 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_ permite filtrar o histórico para confirmar apenas quando a célula em questão for alterada. Neste caso, estou interessado nos commits que estão mudando meu primeiro nome. Observe que há dois commits que mudaram meu nome porque um é a alteração original e o segundo é o commit de mesclagem.
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 fornece recursos poderosos de auditoria de dados em células individuais. Quando, como e por que cada célula do seu banco de dados mudou ao longo do tempo?
Acesse nossa documentação agora que você conhece o Dolt. Você também pode ler sobre o que estamos trabalhando em nosso blog.
