Salve, sto attualmente lavorando alla soluzione di un problema simile, lo sto risolvendo dividendo le mie tabelle in due, una tabella di controllo e una tabella di dati. La tabella di controllo conterrà una chiave primaria e un riferimento nella tabella di dati, la tabella di dati conterrà la chiave di revisione con incremento automatico e la chiave primaria della tabella di controllo come chiave esterna.
prendendo come esempio la tabella delle voci
Entries Table
+----+-------+------+--------+--------+
| id | title | text | index1 | index2 |
+----+-------+------+--------+--------+
diventa
entries entries_data
+----+----------+ +----------+----+--------+------+--------+--------+
| id | revision | | revision | id | title | text | index1 | index2 |
+----+----------+ +----------+----+--------+------+--------+--------+
interrogare
select * from entries join entries_data on entries.revision = entries_data.revision;
invece di aggiornare la tabella entry_data si utilizza un'istruzione insert e quindi si aggiorna la revisione della tabella delle voci con la nuova revisione della tabella delle voci.
Il vantaggio di questo sistema è che puoi passare a diverse revisioni semplicemente modificando la proprietà di revisione all'interno della tabella delle voci. Lo svantaggio è che devi aggiornare le tue query. Attualmente lo sto integrando in un livello ORM, quindi gli sviluppatori non devono comunque preoccuparsi di scrivere SQL. Un'altra idea su cui sto giocando è che ci sia una tabella di revisione centralizzata utilizzata da tutte le tabelle di dati. Ciò ti consentirebbe di descrivere lo stato del database con un unico numero di revisione, in modo simile a come funzionano i numeri di revisione della sovversione.
