Come faccio a mantenere facilmente i record in un database collegati insieme?

Question

Ho un requisito che, credo, deve verificarsi molto spesso in giro per il mondo.Ho due record che sono collegati insieme e ogni volta che viene apportata una modifica a un nuovo paio di record è di creare e mantenere lo stesso link.

Il requisito di cui sto lavorando ha a che fare con il settore assicurativo, che mi richiede di disattivare la corrente di polizze di assicurazione e ri-attivare in una nuova riga per visualizzare la cronologia delle modifiche apportate alle polizze assicurative.Quando sono ri-creato hanno ancora bisogno di essere collegati tra di loro.

Un esempio di come questo processo è destinato a funzionare dal punto di vista di righe in un database:

Assicurazione Id, Tipo Di Assicurazione, Master Di Assicurazione Id, Stato

1, Assicurazione Auto, null, Attivo

2, Schermo Di Vento Di Assicurazione, 1, Active

Nota in precedenza come il legame tra queste politiche è segnato da un Maestro di Assicurazione Id della seconda riga che punta l'Assicurazione Id della prima riga.

Nel codice che sto scrivendo io sono l'elaborazione di ciascuno dei criteri, uno alla volta, quindi dopo il primo passo che ho i seguenti:

1, Assicurazione Auto, null, Inattivo

2, Schermo Di Vento Di Assicurazione, 1, Active

3, Assicurazione Auto, null, Attivo

Quando inserisco il secondo criterio ottengo il seguente:

1, Assicurazione Auto, null, Inattivo

2, Schermo Di Vento Di Assicurazione, 1, Inattivo

3, Assicurazione Auto, null, Attivo

4, Schermo Di Vento Di Assicurazione, 1, Attivo //deve essere di 3, non 1

Si noterà che quando si crea una nuova Finestra di Assicurazione che, dato che la copia vecchia di riga si finisce con il Maestro Id assicurazione indicando gli inattivi riga.

Per ottenere intorno a questo, io sono per tenere traccia del master di assicurazione id della politica precedente che è stato elaborato che ha portato alla seguente codice:

int masterInsuranceId = -1;
foreach(Policy policy in policyList)
{
    //copy the old policy so the new policy has 
    //the same details as the old one
    Policy newPolicy = policyManager.Copy(policy);

    //if the new policy is not the master insurance store 
    //the master its new master insuance
    if(newPolicy.MasterInsuranceId.HasValue)
    {
       newPolicy.MasterInsuranceId = masterInsuranceId; 
    }

    //save the details of the new policy
    policyManager.SavePolicy(newPolicy);

    //record the master id so we can update the master id 
    //reference on the next policy
    if(newPolicy.MasterInsuranceId == null)
    {
        masterInsuranceId = newPolicy.Id;
    }
    else
    {
        masterInsuranceId = -1;
    }

    //inactivate the current policy
    policy.Status = Inactive;
    policyManager.UpdatePolicy(policy);

}

Qualcuno sa come questo può essere semplificato?Qual è il modo migliore per garantire che due record di rimanere collegati tra loro, anche come storia delle modifiche viene registrato per ogni modifica apportata al record?

Answer 1

Grazie a tutti che ha fornito risposte.Purtroppo, a causa di condizioni di lavoro non sono in grado di implementare le modifiche del database e sono bloccati cercando di rendere il dovuto con una soluzione di codifica.

Dopo aver trascorso qualche tempo durante il fine settimana su questo problema che ho venire con una soluzione che credo che semplifica il codice un po ' anche se è ancora in nessun posto vicino a perfetto.

Ho estratto la funzionalità in un nuovo metodo e passare il maestro di politica che voglio la nuova politica collegato.

Policy Convert(Policy policy, Policy masterPolicy)
{
    Policy newPolicy = policyManager.Copy(policy);

    //link the policy to it's master policy
    if(masterPolicy != null)
    {
        newPolicy.MasterPolicyId = masterPolicy.Id;
    }

    SavePolicy(newPolicy);

    //inactivate the current policy
    policy.Status = Inactive;
    policyManager.UpdatePolicy(policy);

    return newPolicy;
}

Questo mi permette di loop attraverso tutte le politiche e passare il criterio che deve essere collegato come lungo come politiche sono disposti nell'ordine corretto...che nel mio caso è da data di inizio e poi dal maestro politica di id.

Policy newPolicy = null;
foreach(Policy policy in policyList)
{
    Policy masterPolicy = policy.MasterPolicyId.HasValue ? newPolicy : null;
    newPolicy = Convert(policy, masterPolicy);   

}

Quando tutto è detto e fatto, non è molto meno codice, ma credo che è molto più comprensibile e permette ai singoli criteri di conversione.

Answer 2

Che tipo di schema di database stai usando?Di solito, questo è dove il rapporto dovrebbe essere immagazzinato e credo che questo dovrebbe essere hanlded al trattamento dei dati, piuttosto che di codice.

Ecco un molto semplificato raccomandazione

assicurazione (< insurance_id >, nome, descrizione)

insurance_item(< item_id >, < insurance_id >, nome, descrizione)

insurance_item_details(< item_id >, < policy_id >, when_changed)

assicurazione__, per una politica 1 relazione con insurance_item.Una polizza di assicurazione__oggetto ha una relazione uno a molti con insurance_item_details.Ogni riga di assicurazione__voce__dettagli rappresenta un cambiamento nella politica.

In questo modo, un SQL può rapidamente recuperare le ultime due voci

SELECT FROM insurance_item_details, insurance_item, insurance where
             insurance_item_details.item_id = insurance_item.item_id
             AND insurance_item.insurance_id = insurance.insurance_id
             ORDER BY when_changed
             LIMIT 1

O si può anche recuperare la storia.

(SQL non ha ancora provato)

Quindi l'idea è di non duplicare insurance_item -- si dispone di un'altra tabella per memorizzare gli elementi che sarebbe cambiato, e uno schiaffo un timestamp con non rappresentano che il cambiamento di una relazione.

Io non sono un SQL guru (unfortnately ha), ma tutto quello che dovete fare è inserire la insurance_item_details tabella, invece di fare copie.Dal modo in cui appare, fare copie, come nel tuo esempio originale sembra violare 2NF, penso.

Answer 3

SE hai avuto una brutta codice di design e di necessità di cambiamento è il refactoring?Allora perché non si considera il refactoring di una cattiva progettazione del database?Questo è qualcosa che è più ealisy gestiti nel database attraverso una buona progettazione.

Se si lavora nel settore assicurativo, quali sono i dati per la cpu e non sono forte in progettazione di database e query competenze, vorrei suggerire di farne una priorità per diventare così.