A partir de 10.3.4, o MariaDB vem com tabelas temporais. Ainda é um recurso bastante incomum e gostaríamos de discutir um pouco o que são essas tabelas e para que elas podem ser úteis.
Em primeiro lugar, caso alguém tenha lido errado o título deste blog, estamos falando aqui de tabelas temporais, não tabelas temporárias, que também existem no MariaDB. Eles têm algo em comum, no entanto. Tempo. As tabelas temporárias são de curta duração, as tabelas temporais, por outro lado, são projetadas para fornecer acesso aos dados ao longo do tempo. Em resumo, você pode ver as tabelas temporais como uma tabela com versão que pode ser usada para acessar e modificar dados anteriores, descobrir quais alterações foram feitas e quando. Ele também pode ser usado para reverter dados para um determinado ponto no tempo.
Como usar tabelas temporais no MariaDB
Para criar uma tabela temporal basta adicionar “WITH SYSTEM VERSIONING” ao comando CREATE TABLE. Se você deseja converter uma tabela regular em uma temporal, você pode executar:
ALTER TABLE mytable ADD SYSTEM VERSIONING;Isso é praticamente tudo. Uma tabela temporal será criada e você poderá começar a consultar seus dados. Existem algumas maneiras de fazer isso.
Primeiro, podemos usar SELECT para consultar dados em um determinado momento:
SELECT * FROM mytable FOR SYSTEM_TIME AS OF TIMESTAMP ‘2020-06-26 10:00:00’;Você também pode fazer uma consulta para um intervalo:
SELECT * FROM mytable FOR SYSTEM_TIME FROM ‘2020-06-26 08:00:00’ TO ‘2020-06-26 10:00:00’;Também é possível mostrar todos os dados:
SELECT * FROM mytable FOR SYSTEM_TIME ALL;Se necessário, você pode criar visualizações a partir de tabelas temporais, seguindo o mesmo padrão que mostramos acima.
Dado que as mesmas linhas podem não ser atualizadas em todos os nós ao mesmo tempo (por exemplo, atrasos causados pela replicação), se você quiser ver exatamente o mesmo estado dos dados no vários escravos, você pode definir o ponto de tempo usando o ID de transação do InnoDB:
SELECT * FROM mytable FOR SYSTEM_TIME AS OF TRANSACTION 123;Por padrão, todos os dados são armazenados na mesma tabela, tanto as versões atuais quanto as antigas das linhas. Isso pode adicionar alguma sobrecarga quando você consulta apenas os dados recentes. É possível usar partições para reduzir essa sobrecarga criando uma ou mais partições para armazenar dados históricos e uma para armazenar versões recentes das linhas. Em seguida, usando a remoção de partição, o MariaDB poderá reduzir a quantidade de dados que precisa consultar para obter o resultado da consulta:
CREATE TABLE mytable (a INT) WITH SYSTEM VERSIONING
PARTITION BY SYSTEM_TIME INTERVAL 1 WEEK (
PARTITION p0 HISTORY,
PARTITION p1 HISTORY,
PARTITION p2 HISTORY,
PARTITION pcur CURRENT
);Você também pode usar outros meios de particionar como, por exemplo, definir o número de linhas a serem armazenadas por partição.
Ao usar particionamento, agora podemos aplicar as melhores práticas de particionamento regulares, como rotação de dados, removendo partições antigas. Se você não criou partições, ainda pode fazer isso através de comandos como:
DELETE HISTORY FROM mytable;
DELETE HISTORY FROM mytable BEFORE SYSTEM_TIME '2020-06-01 00:00:00';Se necessário, você pode excluir algumas das colunas do controle de versão:
CREATE TABLE mytable (
a INT,
b INT WITHOUT SYSTEM VERSIONING
) WITH SYSTEM VERSIONING;No MariaDB 10.4, uma nova opção foi adicionada, períodos de tempo de aplicação. O que significa, basicamente, é que ao invés de hora do sistema é possível criar versionamento baseado em duas colunas (baseadas em tempo) na tabela:
CREATE TABLE mytable (
a INT,
date1 DATE,
date2 DATE,
PERIOD FOR date_period(date1, date2));Também é possível atualizar ou excluir linhas com base no tempo (UPDATE FOR PORTION e DELETE FOR PORTION). Também é possível misturar versões de tempo de aplicação e tempo de sistema em uma tabela.
Exemplos de tabelas temporais no MariaDB
Ok, já discutimos as possibilidades, vamos dar uma olhada em algumas coisas que podemos fazer com tabelas temporais.
Primeiro, vamos criar uma tabela e preenchê-la com alguns dados:
MariaDB [(none)]> CREATE DATABASE versioned;
Query OK, 1 row affected (0.000 sec)
MariaDB [(none)]> use versioned
Database changed
MariaDB [versioned]> CREATE TABLE mytable (a INT, b INT) WITH SYSTEM VERSIONING;
Query OK, 0 rows affected (0.005 sec)
MariaDB [versioned]> INSERT INTO mytable VALUES (1,1);
Query OK, 1 row affected (0.001 sec)
MariaDB [versioned]> INSERT INTO mytable VALUES (2,1);
Query OK, 1 row affected (0.001 sec)
MariaDB [versioned]> INSERT INTO mytable VALUES (3,1);
Query OK, 1 row affected (0.000 sec)Agora, vamos atualizar algumas linhas:
MariaDB [versioned]> UPDATE mytable SET b = 2 WHERE a < 3;
Query OK, 2 rows affected (0.001 sec)
Rows matched: 2 Changed: 2 Inserted: 2 Warnings: 0Agora, vamos ver todas as linhas que estão armazenadas na tabela:
MariaDB [versioned]> SELECT * FROM mytable FOR SYSTEM_TIME ALL ;
+------+------+
| a | b |
+------+------+
| 1 | 2 |
| 2 | 2 |
| 3 | 1 |
| 1 | 1 |
| 2 | 1 |
+------+------+
5 rows in set (0.000 sec)Como você pode ver, a tabela contém não apenas as versões atuais das linhas, mas também os valores originais, anteriores à atualização.
Agora, vamos verificar qual é a hora e adicionar mais algumas linhas. Vamos ver se podemos ver as versões atuais e anteriores.
MariaDB [versioned]> SELECT NOW();
+---------------------+
| NOW() |
+---------------------+
| 2020-06-26 11:24:55 |
+---------------------+
1 row in set (0.000 sec)
MariaDB [versioned]> INSERT INTO mytable VALUES (4,1);
Query OK, 1 row affected (0.001 sec)
MariaDB [versioned]> INSERT INTO mytable VALUES (5,1);
Query OK, 1 row affected (0.000 sec)
MariaDB [versioned]> UPDATE mytable SET b = 3 WHERE a < 2;
Query OK, 1 row affected (0.001 sec)
Rows matched: 1 Changed: 1 Inserted: 1 Warnings: 0;Agora, vamos verificar o conteúdo da tabela. Apenas as versões atuais das linhas:
MariaDB [versioned]> SELECT * FROM mytable;
+------+------+
| a | b |
+------+------+
| 1 | 3 |
| 2 | 2 |
| 3 | 1 |
| 4 | 1 |
| 5 | 1 |
+------+------+
5 rows in set (0.000 sec)Então, vamos acessar o estado da tabela antes de fazermos as inserções e atualizações:
MariaDB [versioned]> SELECT * FROM mytable FOR SYSTEM_TIME AS OF TIMESTAMP '2020-06-26 11:24:55';
+------+------+
| a | b |
+------+------+
| 2 | 2 |
| 3 | 1 |
| 1 | 2 |
+------+------+
3 rows in set (0.000 sec)Funciona como esperado, vemos apenas três linhas na tabela.
Este pequeno exemplo não é extenso. Queríamos dar uma ideia de como você pode operar as tabelas temporais. As aplicações disso são inúmeras. Melhor acompanhamento do estado do pedido no e-commerce, versionamento do conteúdo (arquivos de configuração, documentos), visão dos dados anteriores para fins analíticos.
Para deixar claro, esse recurso pode ser implementado usando tabelas “tradicionais”, desde que você continue inserindo linhas, não as atualizando, mas o gerenciamento é bem mais fácil de fazer usando tabelas temporais.
