dolt
1.43.16
Dolt es una base de datos SQL que puedes bifurcar, clonar, bifurcar, fusionar, insertar y extraer como un repositorio Git.
Conéctese a Dolt como cualquier base de datos MySQL para leer o modificar esquemas y datos. La funcionalidad de control de versiones se expone en SQL a través de tablas, funciones y procedimientos del sistema.
O utilice la interfaz de línea de comandos similar a Git para importar archivos CSV, confirmar sus cambios, enviarlos a un control remoto o fusionar los cambios de su compañero de equipo. Todos los comandos que conoces para Git funcionan exactamente igual para Dolt.
Archivos de versiones de Git. Tablas de versiones Dolt. Es como si Git y MySQL tuvieran un bebé.
También creamos DoltHub, un lugar para compartir bases de datos de Dolt. Alojamos datos públicos de forma gratuita. Si desea alojar su propia versión de DoltHub, tenemos DoltLab. Si desea que ejecutemos un servidor Dolt para usted, tenemos Dolt alojado. Si está buscando una versión Postgres de Dolt, creamos DoltgreSQL. Advertencia, es Alpha temprano. Dolt está listo para la producción.
Únase a nosotros en Discord para saludar y hacer preguntas, o consulte nuestra hoja de ruta para ver qué estamos construyendo a continuación.
¡Muchas cosas! Dolt es una herramienta generalmente útil con innumerables aplicaciones. Pero si quieres algunas ideas, aquí te explicamos cómo la gente lo está usando hasta ahora.
Dolt se puede configurar como una réplica de su base de datos MySQL o MariaDB existente utilizando la replicación binlog estándar de MySQL. Cada escritura se convierte en una confirmación de Dolt. Esta es una excelente manera de obtener los beneficios del control de versiones de Dolt y mantener una base de datos MySQL o MariaDB existente.
La CLI dolt tiene los mismos comandos que git , con algunos 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 es un único programa de ~103 megabytes.
dolt $ du -h /Users/timsehn/go/bin/dolt 103M /Usuarios/timsehn/go/bin/dolt
Es realmente fácil de instalar. Descárgalo y ponlo en tu PATH . Tenemos varias formas de hacer esto aún más fácil para la mayoría de las plataformas.
Para instalar en sistemas basados en Linux o Mac, ejecute este comando en su terminal:
sudo bash -c 'curl -L https://github.com/dolthub/dolt/releases/latest/download/install.sh | bash'
Esto descargará la última versión dolt y la colocará en /usr/local/bin/ , que probablemente esté en su $PATH .
El script de instalación necesita sudo para poder colocar dolt en /usr/local/bin . Si no tiene privilegios de root o no se siente cómodo ejecutando un script con ellos, puede descargar el binario dolt para su plataforma desde la última versión, descomprimirlo y colocar el binario en algún lugar de su $PATH .
Dolt está empaquetado en los repositorios oficiales de Arch Linux.
pacman -S dolt
Dolt está en Homebrew y se actualiza en cada lanzamiento.
brew install dolt
En macOS, Dolt también se puede instalar a través de un puerto administrado por la comunidad mediante MacPorts:
instalación del puerto sudo dolt
Descargue el último instalador de Microsoft (archivo .msi ) en las versiones y ejecútelo.
Para obtener información sobre la ejecución en Windows, consulte aquí.
Puedes instalar dolt usando Chocolatey:
choco instalar idiota
Existen las siguientes imágenes oficiales de Docker para Dolt:
dolthub/dolt para ejecutar Dolt como herramienta CLI.
dolthub/dolt-sql-server para ejecutar Dolt en modo servidor.
Asegúrate de tener Go instalado y go esté en tu camino. Dolt depende de cgo, por lo que también necesitará un compilador de C que funcione y una cadena de herramientas.
Clona este repositorio y cd en el directorio go . Luego ejecuta:
go install ./cmd/dolt
La salida estará en $GOPATH/bin , que por defecto es ~/go/bin . Para probar su compilación, intente:
~/go/bin/dolt version
Verifique que su instalación haya sido exitosa ejecutando dolt en su terminal.
$ dolt Valid commands for dolt are [...]
Configure dolt con su nombre de usuario y correo electrónico, que necesitará para crear confirmaciones. Los comandos funcionan exactamente igual que git.
$ dolt config --global --add user.email [email protected] $ dolt config --global --add user.name "YOUR NAME"
Dolt necesita un lugar para almacenar sus bases de datos. Voy a poner mis bases de datos en ~/dolt .
% cd ~% mkdir punto % cd tonto
Cualquier base de datos que cree se almacenará en este directorio. Entonces, para este ejemplo, se creará aquí un directorio llamado getting_started una vez que ejecute create database getting_started . Navegar a ~/dolt/getting_started le permitirá acceder a esta base de datos utilizando la línea de comando de Dolt.
NOTA: Para este ejemplo, el directorio getting_started se creará después de ejecutar create database getting_started; en un shell SQL en la sección Crear un esquema. No hagas nada excepto crear el directorio y navegar hasta él todavía.
Dolt se envía con un servidor de base de datos compatible con MySQL integrado. Para iniciarlo, utilice el comando dolt sql-server . La ejecución de este comando inicia el servidor en el puerto 3306.
servidor sql dolt Iniciando el servidor con Config HP="localhost:3306"|T="28800000"|R="false"|L="info"
Su terminal simplemente se quedará colgado allí. Esto significa que el servidor se está ejecutando. Cualquier error se imprimirá en esta terminal. Simplemente déjalo ahí y abre una nueva terminal.
En la nueva terminal, ahora nos conectaremos al servidor de base de datos en ejecución mediante un cliente. Dolt también viene con un cliente compatible con MySQL.
% dolt -u root -p "" sql# Bienvenido al cliente Dolt MySQL.# Las declaraciones deben terminar con ';'.# "exit" o "quit" (o Ctrl-D) para salir.mysql>
En la otra terminal donde ejecutó dolt sql-server , verá la siguiente línea de registro.
2022-06-06T13:14:32-07:00 INFO [conn 1] NewConnection {DisableClientMultiStatements=false}¡Estás conectado!
Mientras estamos aquí, tomemos una copia de MySQL para poder conectarnos con ese cliente. Dirígete a la documentación de introducción a MySQL e instala MySQL en tu máquina. Usé Homebrew para instalar MySQL en mi Mac.
MySQL viene con un servidor MySQL llamado mysqld y un cliente MySQL llamado mysql . Sólo te interesa el cliente. Después de seguir las instrucciones de la documentación de MySQL, asegúrese de tener una copia del cliente mysql en su ruta:
% mysql --versión mysql Ver 8.0.29 para macos12.2 en x86_64 (Homebrew)
Ahora, para conectar el cliente mysql a Dolt, forzará al cliente MySQL a través de la interfaz TCP pasando un host y un puerto. El valor predeterminado es la interfaz de socket que admite Dolt, pero solo está disponible en localhost . Entonces, es mejor mostrar la interfaz TCP. El cliente MySQL también requiere que especifiques un usuario, en este caso root .
% mysql --host 127.0.0.1 --puerto 3306 -uroot Bienvenido al monitor MySQL. Los comandos terminan con ; o g. Su ID de conexión MySQL es 2 Versión del servidor: 5.7.9-Vitess Copyright (c) 2000, 2022, Oracle y/o sus afiliados. Oracle es una marca registrada de Oracle Corporation y/o sus afiliados. Otros nombres pueden ser marcas comerciales de sus respectivos propietarios. Escriba 'ayuda'; o 'h' para obtener ayuda. Escriba 'c' para borrar la declaración de entrada actual. mysql>
Nuevamente, para garantizar que el cliente realmente esté conectado, debería ver lo siguiente en la terminal dolt sql-server
2022-06-06T13:26:55-07:00 INFO [conn 2] NewConnection {DisableClientMultiStatements=false}Como puede ver, Dolt admite cualquier cliente compatible con MySQL. Dolt viene con un cliente pero puedes usar cualquier cliente MySQL, como el que viene con MySQL.
Ahora estamos realmente listos para hacer algo interesante. Permaneceré en el cliente mysql y ejecutaré las siguientes declaraciones SQL para crear una base de datos llamada getting_started . La base de datos getting_started tendrá tres tablas: employees , teams y 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 admite claves externas, índices secundarios, activadores, restricciones de verificación y procedimientos almacenados. Es una base de datos SQL moderna y rica en funciones.
Es hora de utilizar su primera función Dolt. Vamos a hacer un compromiso con Dolt. Un compromiso de Dolt te permite viajar en el tiempo y ver el linaje. Realice una confirmación de Dolt siempre que desee restaurar o comparar con este momento.
Dolt expone la funcionalidad de control de versiones a través de una interfaz estilo Git. En la línea de comando, los comandos de Dolt se asignan exactamente a su equivalente de Git y los objetivos son tablas en lugar de archivos. En SQL, Dolt expone las operaciones de lectura de control de versiones como tablas del sistema y las operaciones de escritura de control de versiones como procedimientos almacenados.
La denominación de las tablas del sistema y los procedimientos almacenados sigue el patrón dolt_ . Entonces dolt add en la CLI se convierte en dolt_add como procedimiento almacenado. Pasar opciones también sigue el modelo de línea de comando. Por ejemplo, para especificar tablas para agregar, envíe los nombres de las tablas como opciones al procedimiento dolt_add . Para argumentos con nombre, como enviar un mensaje al comando dolt_commit use dos argumentos en secuencia como ('-m', 'This is a message') . Si conoce Git, los procedimientos de control de versiones y las tablas del sistema le resultarán familiares.
Entonces, agregamos y confirmamos nuestro nuevo esquema así.
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) Ahí lo tienes. Se crea su esquema y tiene un compromiso Dolt que rastrea la creación, como se ve en la tabla del sistema dolt_log .
Tenga en cuenta que una confirmación de Dolt es diferente a una transacción SQL estándar COMMIT . En este caso, estoy ejecutando la base de datos con AUTOCOMMIT activado, por lo que cada declaración SQL genera automáticamente una transacción COMMIT . Si desea que el sistema genere una confirmación Dolt para cada transacción, utilice la variable del sistema, @@dolt_transaction_commit .
Ahora, voy a completar la base de datos con algunos empleados aquí en DoltHub. Luego, asignaré a los empleados a dos equipos: ingeniería y ventas. El director ejecutivo desempeña muchas funciones en una empresa emergente, por lo que será asignado a varios equipos.
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]`
Vaya, violé una restricción. Parece que creé la tabla con los equipos antes que con los empleados. Siempre debe especificar sus columnas cuando las inserta, no confiar en el orden natural. ¡Me lo merezco! Dolt viene con todo el poder de una base de datos relacional SQL moderna para garantizar la integridad de los datos.
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 todo está insertado y es correcto. Pude enumerar los miembros del equipo de ingeniería usando esa tabla de tres JOIN . Dolt admite hasta doce JOIN de mesa. Nuevamente, Dolt es una base de datos relacional SQL moderna combinada con control de versiones estilo Git.
Ahora, ¿qué sucede si desea ver qué cambió en su conjunto de trabajo antes de realizar una confirmación? Utilice las tablas del sistema dolt_status y 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 puede ver en la diferencia, agregué los valores correctos a la tabla employees . Los valores anteriormente eran NULL y ahora están completos.
Terminemos con otra confirmación de Dolt, esta vez agregando todas las tablas afectadas usando -am .
mysql> call dolt_commit('-am', 'Populated tables with data');
+----------------------------------+
| hash |
+----------------------------------+
| 13qfqa5rojq18j84d1n2htjkm6fletg4 |
+----------------------------------+
1 row in set (0.02 sec) Puede inspeccionar el registro usando dolt_log y ver qué tablas cambiaron en cada confirmación usando un dolt_diff sin alcance. dolt_diff sin alcance le indica si el esquema, los datos o ambos cambiaron en esa confirmación particular para la tabla.
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 admite deshacer cambios mediante call dolt_reset() . Imaginemos que accidentalmente dejo caer una 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)
En una base de datos tradicional, esto podría resultar desastroso. En Dolt, estás a un comando de recuperar tu 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 hace que las bases de datos operativas sean menos propensas a errores. Siempre puedes retroceder los cambios que tienes en progreso o rebobinar a un buen estado conocido. También tienes la posibilidad de deshacer confirmaciones específicas usando dolt_revert() . Incluso si accidentalmente ejecuta drop database en la base de datos incorrecta, Dolt le permite deshacerlo llamando al procedimiento almacenado dolt_undrop() .
¿Odias la línea de comando? Usemos Tableplus para hacer algunas modificaciones. Tableplus es un banco de trabajo SQL gratuito. Siga las instrucciones de instalación de su sitio web.
Ahora, para conectarte debes seleccionar MySQL como tipo de conexión. Luego ingrese un nombre para su conexión, getting_started como su base de datos y root como su usuario.
Haga clic en Conectar y se le presentará una GUI familiar de banco de trabajo de base de datos.
Para realizar cambios en una rama, utilizo el procedimiento almacenado dolt_checkout() . Usar la opción -b crea una rama, como en Git.
Tableplus me brinda la posibilidad de ingresar un script SQL de varias líneas en la pestaña SQL. Ingresé el siguiente SQL para verificar una rama, actualizar, insertar, eliminar y, finalmente, confirmar mis cambios.
llamar a dolt_checkout('-b','modificaciones');actualizar empleados SET first_name='Timothy' donde first_name='Tim';insertar INTO empleados (id, first_name, last_name) valores (4,'Daylon', 'Wilkins') ;insertar en empleados_equipos(team_id, empleado_id) valores (0,4);eliminar de empleados_equipos donde empleado_id=0 y team_id=1;
call dolt_commit('-am', 'Modificaciones en una rama');Aquí está el resultado en Tableplus.
De vuelta en mi terminal, no puedo ver las modificaciones de la tabla realizadas en Tableplus porque ocurrieron en una rama diferente a la que revisé en mi sesión.
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)
Puedo consultar la rama sin importar lo que haya verificado usando SQL as of la sintaxis.
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 quiero ver la diferencia entre las dos ramas, puedo usar la función de tabla dolt_diff() . Toma dos ramas y el nombre de la tabla 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 puede ver, tiene todo el poder de las ramas y diferencias estilo Git en una base de datos SQL con Dolt.
También puedo realizar cambios de esquema en ramas para realizar pruebas aisladas de un nuevo esquema. Voy a agregar una columna start_date en una nueva rama y completarla.
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)Cambiar el esquema en una rama le brinda un nuevo método para realizar pruebas de integración aisladas de nuevos cambios de esquema.
Supongamos que todas las pruebas del nuevo esquema en la rama schema_changes y los datos en la rama modifications se completaron sin problemas. Es hora de fusionar todas nuestras ediciones en main . Esto se hace utilizando el procedimiento almacenado 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)Cambio de esquema exitoso. Ya tenemos fechas de inicio. Los cambios de datos son los siguientes.
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)Los cambios de datos también tuvieron éxito. Como puede ver, ahora soy "Timothy" en lugar de "Tim", se agregó Daylon y todos tenemos fechas de inicio, excepto Daylon, que se agregó en una rama 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)
También me he ido del equipo de ventas. La ingeniería es vida.
Tengo que confirmar todos mis cambios porque la última combinación no fue una combinación de avance 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)Ahora tenemos una base de datos con todos los cambios de esquema y datos combinados y listos para usar.
¿Qué confirmación cambió mi nombre? Con Dolt tienes linaje para cada celda de tu base de datos. Usemos dolt_history_ y dolt_diff_ para explorar las características del linaje en Dolt.
dolt_history_ muestra el estado de la fila en cada confirmación.
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_ le permite filtrar el historial para confirmar solo cuando la celda en cuestión cambió. En este caso, me interesan las confirmaciones que cambian mi nombre. Tenga en cuenta que hay dos confirmaciones que cambiaron mi nombre porque una es el cambio original y la segunda es la confirmación de fusión.
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 proporciona potentes capacidades de auditoría de datos hasta celdas individuales. ¿Cuándo, cómo y por qué ha cambiado cada celda de su base de datos con el tiempo?
Dirígete a nuestra documentación ahora que conoces Dolt. También puedes leer sobre en qué hemos estado trabajando en nuestro blog.
