A partire da 10.3.4, MariaDB viene fornito con tabelle temporali. È ancora una caratteristica piuttosto rara e vorremmo discutere un po' cosa sono queste tabelle e a cosa possono essere utili.
Prima di tutto, nel caso qualcuno abbia letto male il titolo di questo blog, stiamo parlando di tabelle temporali, non di tabelle temporanee, che esistono anche in MariaDB. Hanno qualcosa in comune, però. Tempo. Le tabelle temporanee sono di breve durata, le tabelle temporali invece sono progettate per consentire l'accesso ai dati nel tempo. In breve, puoi vedere le tabelle temporali come una tabella con versione che può essere utilizzata per accedere e modificare i dati passati, trovare quali modifiche sono state apportate e quando. Può anche essere utilizzato per ripristinare i dati in un determinato momento.
Come utilizzare le tabelle temporali in MariaDB
Per creare una tabella temporale dobbiamo solo aggiungere “CON VERSIONE DI SISTEMA” al comando CREATE TABLE. Se vuoi convertire una tabella normale in una temporale, puoi eseguire:
ALTER TABLE mytable ADD SYSTEM VERSIONING;Questo è praticamente tutto. Verrà creata una tabella temporale e potrai iniziare a interrogare i suoi dati. Ci sono un paio di modi per farlo.
In primo luogo, possiamo usare SELECT per interrogare i dati in un momento particolare:
SELECT * FROM mytable FOR SYSTEM_TIME AS OF TIMESTAMP ‘2020-06-26 10:00:00’;Puoi anche eseguire una query per un intervallo:
SELECT * FROM mytable FOR SYSTEM_TIME FROM ‘2020-06-26 08:00:00’ TO ‘2020-06-26 10:00:00’;È anche possibile mostrare tutti i dati:
SELECT * FROM mytable FOR SYSTEM_TIME ALL;Se necessario, puoi creare viste da tabelle temporali, seguendo lo stesso schema mostrato sopra.
Dato che le stesse righe potrebbero non essere aggiornate su tutti i nodi contemporaneamente (ad esempio, ritardi causati dalla replica), se si desidera visualizzare esattamente lo stesso stato dei dati su più slave, puoi definire il momento utilizzando l'ID transazione InnoDB:
SELECT * FROM mytable FOR SYSTEM_TIME AS OF TRANSACTION 123;Per impostazione predefinita, tutti i dati sono archiviati nella stessa tabella, sia la versione corrente che quella precedente delle righe. Ciò potrebbe aggiungere un sovraccarico quando si interrogano solo i dati recenti. È possibile utilizzare le partizioni per ridurre questo sovraccarico creando una o più partizioni per archiviare i dati storici e una per archiviare le versioni recenti delle righe. Quindi, utilizzando lo sfoltimento delle partizioni, MariaDB sarà in grado di ridurre la quantità di dati che deve interrogare per ottenere il risultato della query:
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
);Puoi anche usare altri mezzi per partizionarlo come, ad esempio, definire il numero di righe da memorizzare per partizione.
Quando si utilizza il partizionamento, ora possiamo applicare le normali pratiche di partizionamento come la rotazione dei dati rimuovendo le vecchie partizioni. Se non hai creato partizioni, puoi comunque farlo tramite comandi come:
DELETE HISTORY FROM mytable;
DELETE HISTORY FROM mytable BEFORE SYSTEM_TIME '2020-06-01 00:00:00';Se necessario, puoi escludere alcune colonne dal controllo delle versioni:
CREATE TABLE mytable (
a INT,
b INT WITHOUT SYSTEM VERSIONING
) WITH SYSTEM VERSIONING;In MariaDB 10.4 è stata aggiunta una nuova opzione, i periodi di tempo dell'applicazione. Ciò significa, in pratica, che al posto dell'ora di sistema è possibile creare il versionamento in base a due colonne (a tempo) nella tabella:
CREATE TABLE mytable (
a INT,
date1 DATE,
date2 DATE,
PERIOD FOR date_period(date1, date2));È anche possibile aggiornare o eliminare righe in base all'ora (UPDATE FOR PORTION e DELETE FOR PORTION). È anche possibile combinare il tempo di applicazione e il tempo di sistema in un'unica tabella.
Esempi di tabelle temporali in MariaDB
Ok, abbiamo discusso delle possibilità, diamo un'occhiata ad alcune delle cose che possiamo fare con le tabelle temporali.
Per prima cosa, creiamo una tabella e la popolamo con alcuni dati:
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)Ora aggiorniamo un paio di righe:
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: 0Ora, vediamo tutte le righe che sono memorizzate nella tabella:
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)Come puoi vedere, la tabella contiene non solo le versioni correnti delle righe ma anche i valori originali, da prima che li aggiornassimo.
Ora controlliamo che ora è e poi aggiungiamo altre righe. Vedremo se riusciamo a vedere la versione attuale e quella passata.
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;Ora controlliamo il contenuto della tabella. Solo le versioni correnti delle righe:
MariaDB [versioned]> SELECT * FROM mytable;
+------+------+
| a | b |
+------+------+
| 1 | 3 |
| 2 | 2 |
| 3 | 1 |
| 4 | 1 |
| 5 | 1 |
+------+------+
5 rows in set (0.000 sec)Allora, accediamo allo stato della tabella prima di effettuare gli inserti e gli aggiornamenti:
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)Funziona come previsto, vediamo solo tre righe nella tabella.
Questo breve esempio non è affatto esteso. Volevamo darti un'idea di come puoi far funzionare le tabelle temporali. Le applicazioni di questo sono numerose. Migliore tracciabilità dello stato dell'ordine nell'e-commerce, versionamento dei contenuti (file di configurazione, documenti), approfondimento dei dati passati a fini analitici.
Per chiarire, questa funzionalità può essere implementata utilizzando tabelle "tradizionali", purché si continui a inserire righe senza aggiornarle, ma la gestione è molto più semplice quando si utilizzano tabelle temporali.
