Modi per avere una cronologia delle modifiche alle voci del database

Ci sono fondamentalmente due approcci: una tabella di controllo, con tutti i valori precedenti memorizzati in essa, o include una data di inizio / fine come parte della tabella, e tutti gli aggiornamenti creano un nuovo record mentre chiude quello vecchio.

L'idea alla base è di usare Insert Only Databases . L'idea di base è che tu never update or update data on a row. Ogni tabella richiesta per tracciare avrà 2 colonne datetime da e verso.

Iniziano con il valore null in ciascuno (dall'inizio del tempo alla fine del tempo)

Quando devi change della riga aggiungi una nuova riga, contemporaneamente aggiorni la a nella riga precedente a Ora e la da nella riga che stai aggiungendo a Now.

Per informazioni più dettagliate guarda il post - Qual è il miglior design di database per la gestione delle informazioni storiche .

Penso che tu possa usare i trigger per ogni tabella e mantenere i dati in _history (o puoi dare qualsiasi nome) e su ogni insert, update, delete sulla tabella principale attiverà il trigger e puoi salvare i dettagli in questa tabella Il meccanismo di rotazione è disponibile anche con il database SQLite se ne stai usando uno.

Questo meccanismo è utile anche per progetti di grandi dimensioni. In questa tabella è possibile registrare le informazioni dell'utente che ha apportato le modifiche insieme al timestamp delle modifiche. puoi quindi ripristinare la tabella in base a una qualsiasi corrispondenza temporale corrispondente ai tuoi requisiti.

Ogni database ha il proprio modo di scrivere e trigger di codice. Se stai usando SQLite, visita SQLite.org per la sintassi. Per altri database puoi visitare i loro siti ufficiali.

Probabilmente sei a conoscenza del Sqlite motore db. L'intero db viene salvato in un singolo file. L'API supporta anche i file system virtuali, quindi in pratica è possibile organizzare lo storage ovunque e con qualsiasi formato, basta rispondere alle operazioni di lettura e scrittura su determinati offset di file. Possibili applicazioni per questo potrebbero essere crittografia, compressione e così via. La parte migliore di ciò che il livello del contenitore non deve sapere nulla sui database, il formato di file sql o sqlite, basta obbedire ai callback xRead e xWrite.

Una delle idee era implementare la funzionalità Time Machine. Quindi qualsiasi operazione xWrite salva ogni segmento che sovrascriverebbe nella cronologia "annulla" e l'utente può scegliere una data nel passato per vedere cosa conteneva il db (probabilmente modalità di sola lettura). Non ho ancora un esempio funzionante (c'era una discussione a riguardo sqlite mail list), ma probabilmente altri motori forniscono API VFS, quindi è possibile qualcosa di simile. E una volta implementato, dovrebbe essere compatibile con strutture di database di qualsiasi complessità.

Il metodo che usiamo per le voci del database delle versioni è usare una tabella di controllo. La tabella ha uno schema lungo le linee di:

Seq      - Int      ' Unique identifier for this table
Event    - Char     ' Insert / Update / Delete
TblName  - Char     ' Table that had field value changed
FldName  - Char     ' Field that was changed
KeyValue - Char     ' delimited list of values for fields that make up the PK of table changed
UsrId    - Char     ' User who made the change
OldValue - Char     ' Old value (converted to character)
NewValue - Char     ' New value (converted to character)
AddTs    - DateTime ' When the change was made

Abbiamo quindi trigger su Insert / Update / Delete delle tabelle che vogliamo monitorare.

Pro:

• Tutti i dati si trovano in una tabella
• Può essere configurato per tenere traccia di tutti i campi o campi specifici in una tabella
• Facile mostrare il controllo delle versioni su ogni campo per una tabella

Contro:

• La presenza di tutte le informazioni di controllo in una tabella determina un numero estremamente elevato di record
• Sono necessari molti trigger

Sto facendo una versione di questo ora. per ogni record ho una data di inserimento, una data modificata e un flag booleano attivo. Per l'inserimento iniziale, le date Inserito e Modificato sono entrambe impostate su Ora () (Questo esempio è in Accesso) e il flag del record Attivo è impostato su true . quindi, se modifico il record, copio il tutto su un nuovo record, cambiando il campo (i) che l'utente sta cambiando, lascio la data Insert uguale all'originale e cambi la data modificata in Now (). Quindi ribalta il flag Active Record del record originale a false e il nuovo record a true . Ho anche un campo per ModifiedRecordsParentID dove salvo l'identità del record originale.

Quindi se ho bisogno di interrogare posso solo restituire i record dove ActiveRecord = true e otterrò solo le informazioni più aggiornate.

Inoltre, se si desidera memorizzare TUTTE le modifiche nel DB nel tempo, è possibile controllare la registrazione ( link )