Voglio un vostro parere

[Edde]

Ciao

La mia applicazione legge un db e ne estrae l'equivalente schema ontologico, secondo alcune regole base che non sto qui a dire, perchè esulano dal discorso che voglio fare.

In due parole, dico che ad ogni tabella, ad ogni colonna, ad ogni foreign key del db, corrisponde una classe/attributo/relazione sull'ontologia. E l'ontologia può, in una fase successiva all'estrazione iniziale, essere arricchita con ulteriori relazioni.

Devo aggiungere una funzionalità fondamentale: la gestione dei cambiamenti.

Questo è lo stato attuale delle cose:

- Estraggo l'ontologia dal DB. Investo diverse ore per modellarla, eliminando classi, attributi e relazioni che non mi servono, aggiungendone degli altri, modificando nomi, label, campi da indicizzare per la ricerca testuale dei dati.
Ad un certo punto un tizio decide di modificare la struttura di una tabella del DB. Magari elimina una colonna, magari la rinomina. O magari aggiunge una nuova tabella.
Ecco, allo stato attuale delle cose io perdo tutto: a meno di non effettuare le relative modifiche "a mano" agendo sui file che mantengono il mapping ontologia/db, sono costretto a ripetere l'estrazione ed a manipolare nuovamente l'ontologia ottenuta. Insomma, non è una cosa pensabile.

Quello che dovrebbe essere:

- In seguito alla modifica del db, faccio partire una procedura che, in maniera totalmente automatica, confronta lo stato attuale dell'ontologia con la nuova struttura del db, ed opera le necessarie modifiche. E' stata eliminata una tabella sul db? Bene, la relativa classe dell'ontologia (e tutto quello che la riguarda) deve essere eliminata. E' stata aggiunta una colonna? Verrà generata in automatico la corrispondente proprietà. E così via...

Tutto funziona a meraviglia (nella mia mente... ancora devo andare sul pratico ) per eliminazione ed aggiunte. Ma non so bene come gestire il cambiamento dei nomi...
Immaginiamo di avere una tabella "Pippo" e di cambiarne il nome in "Pluto".
Da un confronto sui nomi, io mi accorgerei che Pippo non esiste più (e devo pensare che sia stata cancellata) e che c'è una nuova tabella chiamata Pluto. Ovviamente se mi limito a cancellare, sull'ontologia, tutto quello che riguardava Pippo e ad estrarre nuovamente Pluto, rischio di perdere una miriade di informazioni... perchè magari Pippo era stata elaborata sull'ontologia, dove avevo creato diverse nuove relazioni che la riguardavano.
Relazioni che estraendo ex-novo tutto quanto finisco inevitabilmente per perdere.
Quindi non è una strada percorribile.

L'ideale sarebbe riuscire a catturare l'identificatore univoco associato dal DB a tabelle e colonne (diverso dal nome, e non modificabile). In questo caso diventerebbe tutto semplicissimo... ma non sono sicuro che questa informazione esista, ed al momento non ho idea su come reperirla. Se qualcuno sa qualche cosa (uso Oracle e MySQL) si faccia avanti

Ma se questo non fosse possibile... voi come procedereste? Quale può essere a vostro avviso una possibile soluzione per il problema?

L'applicazione è scritta in java, ma non è un'informazione importante: si tratta più che altro di un problema di logica... una volta messa su un'idea sensata, la si può mettere in pratica senza grandi problemi.

Spero di aver stuzzicato la vostra fantasia...

Già se avete letto fino a qui, sento di dovervi ringraziare

[Edde]

Mentre cercavo info su google mi è venuta un'altra idea... in assenza di questo fantomatico id univoco (indipendente dal nome della tabella), che probabilmente esiste su oracle, ma non sono affatto convinto che esista su mySQL, potrei usare la data di creazione delle tabelle...

Immaginiamo che io abbia una tabella "Pippo" creata alle 15.30 e 12sec del 12/11/07... e all'improvviso tu le cambi nome in "Pluto".

Io non troverei più "Pippo" (e la cosa mi farebbe pensare che sia stata eliminata) e trovo una nuova tabella "Pluto" (e la cosa mi fa pensare che sia stata creata ex-novo.
Ad un certo punto mi rendo conto che "Pluto" ha come data di crezione proprio le 15.30 e 12sec del 12/11/07.... e quindi non può che essere la vecchia "Pippo" che è stata rinominata... che ne dite?

L'unico dubbio che ho, è che per DB creati via script SQL, in realtà molte tabelle diverse (non ho ben idea della rapidità con cui questo avvenga) potrebbero essere create proprio nello stesso secondo... ed in quel caso, se diverse di queste tabelle venissero cancellate e/o rinominate contemporaneamente, la semplice analisi dell'istante di creazione potrebbe non essere più sufficiente... ma magari accostandogli l'analisi della struttura (la tabella A ha 3 colonne Varchar. Varchar, int. La tabella B ne ha 5 int, Varchar, varchar, varchar, long) si potrebbero limitare i danni...

Non so, non ne sono convinto appieno, ma mi sembra una soluzione sensata... che in mancanza di meglio vale la pena approfondire.

[banryu79]

Ma a questo punto non basta fare il confronto tra i campi delle due tabelle (come hai detto sopra) e il numero di record presenti?
Se combaciano si tratta della stessa tabella (rinominata) e non di una nuova.


@EDIT: mi sembrava troppo semplice, ok ho detto una nubbiata

[Edde]

Originariamente inviato da banryu79

Ma a questo punto non basta fare il confronto tra i campi delle due tabelle (come hai detto sopra) e il numero di record presenti?
Se combaciano si tratta della stessa tabella (rinominata) e non di una nuova.

Non è così semplice.
Il confronto è fatto sulla base della struttura, non del numero di record (che tra le altre cose possono cambiare, senza che io ne abbia alcun controllo... l'applicazione funziona solo in lettura e tutto quello che succede sul db gli è invisibile). E la stessa struttura della tabella può cambiare.

Quindi se tu non ti limiti a rinominare "Pippo" in "Pluto", ma rinomini anche qualche colonna, ne aggiungi una, ne elimini due... ecco che la stessa struttura della tabella è cambiata. O magari elimini effettivamente una tabella, e ne crei una strutturalmente identica (ma diversa per utilizzo). Usando solo questo criterio potresti essere portato a pensare che siano la stessa rinominata.
Quindi credo che questo genere di confronto possa essere un supporto per capire se due tabelle, apparentemente diverse, sono invece la stessa con un diverso nome. Ma si tratta di un supporto... poi deve esserci qualche altra cosa (e la data di creazione potrebbe essere un fattore importante) che mi possa guidare.

[banryu79]

Ho chiesto a due programmatori con cui sto lavorando e mi hanno suggerito che il tuo applicativo potrebbe, ogni volta che si connette in lettura col database, andare a consultare il log del database... Sarebbe un file dove tutte le operazioni fatte sul db vengono registrate.

Quindi riusciresti a vedere se un tabella è stata distrutta oppure se è stata "solo" rinominata, un campo è stato eliminato e ne hanno aggiunti due nuovi ma è sempre lei, in fondo.

Probabilmente questo file di log va interpretato per estrarne i dati; esistono degli strumenti che riescono a leggere file di log e a convertirli/produrre equivalenti istruzioni SQL...

Di più non so, spero almeno sia un'idea