sql - Mi az ERP legjobb alapértelmezett tranzakciós elszigetelési szintje, ha van ilyen?

Translate

Rövid háttér: Éppen most kezdünk át egy ERP rendszert migrálni / újratelepíteni a Java-ra hibernált állapotban, egyidejűleg a rendszert használó 50-100 felhasználót számlálva. MS SQL Server-t használunk adatbázis-kiszolgálóként, ami elég jó ehhez a betöltéshez.

Most a régi rendszer egyáltalán nem használ tranzakciókat, és a kritikus részekre (pl. Készletváltozásokra) támaszkodik a kézi zárak beállításában (zászlók használatával) és felszabadításukban. Ez olyasmi, mint a kézi tranzakciókezelés. De néha problémák merülnek fel az adatok inkonzisztenciájával kapcsolatban. Az új rendszerben tranzakciókkal szeretnénk ezeket a problémákat eltüntetni.

Most a kérdés: Mi lenne a jó / ésszerűalapértelmezetttranzakció-elkülönítési szintet használni egy ERP rendszerhez, ha kb. 85% OLTP és 15% OLAP használunk? Vagy mindig feladatonként kell döntenem, melyik tranzakciós szintet használjam?

Emlékeztetőül a négy tranzakciós elszigeteltségi szint: OLVASSA EL KÖTELEZETLEN, OLVASSA EL KÖTELEZETT, ISMÉTELHETŐ OLVASZ, SZERIALIZÁLHATÓ

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

Minden válasz

Translate

100-ból 99 alkalommal az elkötelezett olvasás a helyes válasz. Ez biztosítja, hogy csak azokat a változásokat látja, amelyeket a másik munkamenet hajtott végre (és ezáltal következetes eredményeket, feltéve, hogy a tranzakcióit helyesen tervezte). De nem írja elő azt a zárási költséget (különösen az Oracle-n kívüli adatbázisokban), amelyet megismételhető olvasás vagy sorosíthatóság ír elő.

Nagyon alkalmanként érdemes futtatnia egy jelentést, ahol hajlandó feláldozni a pontosságot a sebesség érdekében, és beállítani az olvasás nem kötelező elkülönítési szintjét. Ez ritkán jó ötlet, de alkalmanként ésszerűen elfogadható megoldás a vitás kérdések lezárásához.

A szerializálható és megismételhető olvasást alkalmanként használják, ha olyan folyamat van, amelynek következetes adatsort kell látnia a teljes futtatás során, függetlenül attól, hogy más tranzakciókat végeztek-e abban az időben. Helyénvaló lehet egy hónap végi egyeztetési folyamatot sorosíthatóra állítani, például ha sok eljárási kód van, akkor lehetőség van arra, hogy a felhasználók változtatni fognak a folyamat futása alatt, és követelmény, hogy a folyamatot győződjön meg arról, hogy mindig úgy látja az adatokat, mint amilyenek voltak az egyeztetés megkezdésekor.

Forrás
Translate

Ne feledkezzünk meg a SNAPSHOT-ról, amely közvetlenül a SERIALIZABLE alatt van.

Attól függ, mennyire fontos az adatok pontossága a jelentésekben. Tényleg feladatról feladatra.

Forrás
Translate

Ez nagyon sok múlik az alkalmazás megtervezésén, az egyszerű válasz a READ_COMMITTED webhelyen fut.

Fogalmazhat azzal, hogy ha a rendszerét ennek figyelembevételével tervezi meg, akkor a READ_UNCOMMITTED-et használhatja alapértelmezettként, és csak akkor növelheti az elkülönítési szintet, amikor szüksége van rá. A tranzakciók túlnyomó része egyébként is sikeres lesz, így a lekötetlen adatok elolvasása nem lesz nagy baj.

Az, hogy az izolációs szintek hogyan befolyásolják a lekérdezéseket, a céladattól függ. Például az olyan adatbázisoknak, mint a Sybase és az MSSQL, több erőforrást kell lezárniuk a READ_COMMITTED futtatásakor, mint az Oracle adatbázisokhoz.

Forrás
Translate

Az SQL Server (és valószínűleg a legtöbb jelentős RDBMS) esetében maradnék az alapértelmezettnél. Az SQL Server esetében ez READ COMMITTED. Bármi más, és elkezded túladózni a DB-t, bármi kevesebbet, és következetességi problémák merülnek fel.

Forrás
Translate

Az Uncommitted olvasása egyértelműen a hátrányos helyzetű a legtöbb fórumban. Vannak azonban okai annak használatára, amelyek túlmutatnak a gyakran felvetett "sebesség és pontosság" kérdésen.

Tegyük fel, hogy van:

  • T1 tranzakció: B-t ír, A-t olvas (még néhány munka), Vállalás.
  • T2 tranzakció: A-t ír, B-t olvas (még néhány munka), Vállalás.

Olvasás elkötelezettségével a fenti tranzakciók csak akkor szabadulnak fel, ha elkövetik. Ezután olyan helyzetbe kerülhet, amikor T1 arra vár, hogy a T2 felszabadítsa A-t, T2 pedig arra várja, hogy a T1 felszabadítsa B-t. Itt a két tranzakció egy ütközésben ütközik.

A forgatókönyv elkerülése érdekében újraírhatja ezeket az eljárásokat (példa: erőforrások beszerzése mindig ábécé sorrendben!). Ennek ellenére túl sok egyidejű felhasználó és több tízezer sornyi kóddal ez a probléma nagyon valószínűsé válhat, és nagyon nehéz diagnosztizálni és megoldani.

Az alternatíva a Read Uncommitted használata. Ezután megtervezi a tranzakciókat, feltételezve, hogy piszkos olvasmányok lehetnek. Én személy szerint ezt a problémát sokkal lokalizáltabbnak és kezelhetőbbnek tartom, mint az egymásba kapcsolt vonatroncsokat.

A piszkos olvasmányokból adódó kérdéseket megelőzheti

  • (1) Visszatérés: ne. Csak hardverhiba, hálózati hiba vagy programösszeomlás esetén ez legyen az utolsó védelmi vonal.

  • (2) Az alkalmazászárak segítségével hozzon létre egy olyan zárszerkezetet, amely magasabb absztrakciós szinten működik, ahol minden zár közelebb áll egy valós erőforráshoz vagy művelethez.

Forrás
Leave a Reply
You must be logged in to post a answer.
A szerzőről