sql - Qual è il miglior livello di isolamento delle transazioni predefinito per un ERP, se esiste?

Translate

Breve background: stiamo appena iniziando a migrare / reimplementare un sistema ERP a Java con Hibernate, mirando a un conteggio di utenti simultanei di 50-100 utenti che utilizzano il sistema. Usiamo MS SQL Server come server di database, che è abbastanza buono per questi carichi.

Ora, il vecchio sistema non usa affatto alcuna transazione e fa affidamento per le parti critiche (es. Cambi di magazzino) sull'impostazione di blocchi manuali (usando flag) e sul loro rilascio. È qualcosa come la gestione manuale delle transazioni. Ma a volte ci sono problemi con l'incoerenza dei dati. Nel nuovo sistema vorremmo utilizzare le transazioni per eliminare questi problemi.

Ora la domanda: quale sarebbe un buono / ragionevolepredefinitolivello di isolamento delle transazioni da utilizzare per un sistema ERP, dato un utilizzo di circa l'85% di OLTP e il 15% di OLAP? O devo sempre decidere in base alle attività, quale livello di transazione utilizzare?

E come promemoria i quattro livelli di isolamento delle transazioni: READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, SERIALIZABLE

This question and all comments follow the "Attribution Required."

Tutte le risposte

Translate

99 volte su 100, leggere commesso è la risposta giusta. Ciò garantisce di vedere solo le modifiche che sono state salvate dall'altra sessione (e, quindi, risultati coerenti, supponendo che tu abbia progettato correttamente le tue transazioni). Ma non impone l'overhead di blocco (in particolare nei database non Oracle) imposto da letture ripetibili o serializzabili.

Molto occasionalmente, potresti voler eseguire un rapporto in cui sei disposto a sacrificare la precisione per la velocità e impostare un livello di isolamento di lettura senza impegno. Raramente è una buona idea, ma a volte è una soluzione alternativa ragionevolmente accettabile per bloccare i problemi di contesa.

Le letture serializzabili e ripetibili vengono occasionalmente utilizzate quando un processo deve visualizzare un insieme coerente di dati durante l'intera esecuzione, indipendentemente da ciò che stanno facendo le altre transazioni in quel momento. Potrebbe essere appropriato impostare un processo di riconciliazione di fine mese su serializzabile, ad esempio, se c'è molto codice procedurale, una possibilità che gli utenti apporteranno modifiche mentre il processo è in esecuzione e un requisito che il processo deve assicurarsi che visualizzi sempre i dati così come erano al momento in cui è iniziata la riconciliazione.

fonte
Translate

Non dimenticare SNAPSHOT, che è proprio sotto SERIALIZZABILE.

Dipende da quanto sia importante che i dati siano accurati nei rapporti. È davvero una cosa da attività a compito.

fonte
Translate

Dipende davvero molto da come si progetta la propria applicazione, la risposta facile è semplicemente eseguita su READ_COMMITTED.

Puoi argomentare che se progetti il tuo sistema tenendo presente che potresti usare READ_UNCOMMITTED come impostazione predefinita e aumentare il livello di isolamento solo quando ne hai bisogno. La stragrande maggioranza delle tue transazioni riuscirà comunque, quindi leggere i dati non salvati non sarà un grosso problema.

Il modo in cui i livelli di isolamento influiscono sulle query dipende dal database di destinazione. Ad esempio, database come Sybase e MSSQL devono bloccare più risorse quando esegui READ_COMMITTED rispetto a database come Oracle.

fonte
Translate

Per SQL Server (e probabilmente la maggior parte dei principali RDBMS), mi atterrei al valore predefinito. Per SQL Server, questo è READ COMMITTED. Qualcosa di più e inizi a sovraccaricare il DB, qualcosa di meno e hai problemi di coerenza.

fonte
Translate

Read Uncommitted è sicuramente il perdente nella maggior parte dei forum. Tuttavia, ci sono ragioni per usarlo che vanno oltre la questione di "velocità contro precisione" che viene spesso sottolineata.

Diciamo che hai:

  • Transazione T1: scrive B, legge A, (ancora un po 'di lavoro), commit.
  • Transazione T2: scrive A, legge B, (altro lavoro), commit.

Con il read commit, le transazioni di cui sopra non verranno rilasciate fino al commit. Quindi puoi imbatterti in una situazione in cui T1 sta aspettando che T2 rilasci A e T2 sta aspettando che T1 rilasci B. Qui le due transazioni si scontrano in un blocco.

Potresti riscrivere quelle procedure per evitare questo scenario (esempio: acquisire le risorse sempre in ordine alfabetico!). Tuttavia, con troppi utenti simultanei e decine di migliaia di righe di codice, questo problema può diventare molto probabile e molto difficile da diagnosticare e risolvere.

L'alternativa è usare Read Uncommitted. Quindi si progettano le transazioni partendo dal presupposto che potrebbero esserci letture sporche. Personalmente trovo questo problema molto più localizzato e curabile dei relitti dei treni.

I problemi delle letture sporche possono essere prevenuti da

  • (1) Rollback: non farlo. Questa dovrebbe essere l'ultima linea di difesa solo in caso di guasto hardware, guasto di rete o crash del programma.

  • (2) Utilizzare i blocchi dell'applicazione per creare un meccanismo di blocco che opera a un livello di astrazione più elevato, in cui ogni blocco è più vicino a una risorsa o azione del mondo reale.

fonte
Leave a Reply
You must be logged in to post a answer.
Circa l'autore