Autonóm tranzakció be Oracle PL / SQL

Mik azok a TCL utasítások a PL/SQL-ben?

A TCL a Transaction Control Statements (Transaction Control Statements) rövidítése. Ezek az utasítások vagy mentik a függőben lévő tranzakciókat, vagy visszavonják a függőben lévő tranzakciókat. Létfontosságú szerepet játszanak, mert ha egy tranzakciót nem mentenek, a végrehajtott módosítások... DML utasítások nem kerül véglegesen tárolásra az adatbázisban. Az alábbiakban a különböző TCL utasítások láthatók a PL / SQL.

A tranzakció a következő esetekben fog lezárulni:

• Amikor a fenti utasítások bármelyike ​​kiadásra kerül (a SAVEPOINT kivételével).
• Amikor DDL utasításokat adnak ki (a DDL automatikus véglegesítési utasítások).
• Amikor DCL utasításokat adnak ki (a DCL-ek automatikus véglegesítési utasítások).

A SAVEPOINT és a ROLLBACK TO használata

A fenti táblázat bemutatja a SAVEPOINT és a ROLLBACK TO függvényeket, amelyek együttesen részleges kontrollt biztosítanak egy tranzakció felett. A SAVEPOINT egy elnevezett pontot jelöl az aktuális tranzakción belül. Egy későbbi ROLLBACK TO művelet ugyanarra a mentési pontra visszavon minden utána végrehajtott módosítást, míg a keeping az előtte végzett munka épségben.

Ez akkor hasznos, ha egy hosszú tranzakció több műveletet hajt végre. SQL lépések, és csak az utolsó lépés hiúsul meg. A teljes tranzakció elvetése helyett visszaléphet az utolsó jó mentési pontra, és folytathatja.

Syntax:

SAVEPOINT <savepoint_name>;
   -- one or more DML statements
ROLLBACK TO <savepoint_name>;

A mentési pontokkal kapcsolatos legfontosabb tudnivalók:

• Egy SAVEPOINT csak az aktuális tranzakción belül létezik; egy COMMIT vagy egy teljes ROLLBACK minden mentési pontot töröl.
• Amikor visszaállítasz egy mentési pontot, az utána létrehozott mentési pontok törlődnek, de a visszaállított mentési pont megmarad.
• A ROLLBACK TO parancs nem fejezi be a tranzakciót; a mentési pont előtt végrehajtott módosítások függőben maradnak, amíg a COMMIT vagy a ROLLBACK parancsot nem adod meg.
• Ha újrafelhasznál egy mentési pont nevét, az újabb SAVEPOINT a jelölőt a későbbi pozícióba helyezi át.

Mivel a ROLLBACK TO nyitva hagyja a tranzakciót, a végén továbbra is eldöntheted, hogy COMMIT-olod-e a fennmaradó módosításokat, vagy egy teljes ROLLBACK-kel elveted őket.

Mi az autonóm tranzakció

A PL/SQL-ben az adatokon végrehajtott összes módosítást tranzakciónak nevezzük. Egy tranzakció akkor tekinthető befejezettnek, ha mentést vagy elvetést alkalmazunk rá. Ha nem történik mentés vagy elvetés, akkor a tranzakció nem tekinthető befejezettnek, és az adatokon végrehajtott módosítások nem kerülnek véglegesítésre a szerveren.

Alapértelmezés szerint a PL/SQL egyetlen tranzakcióként kezeli a munkamenet során végrehajtott összes módosítást, és a tranzakció mentése vagy elvetése a munkamenet összes függőben lévő változására hatással van. Egy autonóm tranzakció lehetővé teszi a fejlesztő számára, hogy egy külön tranzakcióban módosításokat végezzen, és az adott tranzakciót mentse vagy elvesse anélkül, hogy az befolyásolná a fő munkamenet-tranzakciót.

• Egy autonóm tranzakció alprogram szinten adható meg.
• Bármelyik elkészítéséhez alprogram egy másik tranzakcióban működik, akkor a PRAGMA AUTONOMOUS_TRANSACTION kulcsszót meg kell adni az adott blokk deklaratív szakaszában.
• Arra utasítja a fordítót, hogy ezt külön tranzakcióként kezelje, és a blokkon belüli mentés vagy elvetés nem jelenik meg a fő tranzakcióban.
• A COMMIT vagy ROLLBACK parancs kiadása kötelező az autonóm tranzakció elhagyása és a fő tranzakcióhoz való visszatérés előtt, mivel egyszerre csak egy tranzakció lehet aktív.
• Tehát, ha egy autonóm tranzakció elindult, azt menteni és befejezni kell, mielőtt a vezérlés visszatérhetne a fő tranzakcióhoz.

Syntax:

DECLARE
PRAGMA AUTONOMOUS_TRANSACTION;
.
BEGIN
<execution_part>
[COMMIT|ROLLBACK]
END;
/

A fenti szintaxisban a blokkot autonóm tranzakcióvá tették.

Példa 1: Ebben a példában megértjük, hogyan működik egy autonóm tranzakció.

Az alábbi képernyőkép ezt az autonóm tranzakciós példát és annak kimenetét mutatja be Oracle.

DECLARE
   l_salary   NUMBER;
   PROCEDURE nested_block IS
   PRAGMA autonomous_transaction;
    BEGIN
     UPDATE emp
       SET salary = salary + 15000
       WHERE emp_no = 1002;
   COMMIT;
   END;
BEGIN
   SELECT salary INTO l_salary FROM emp WHERE emp_no = 1001;
   dbms_output.put_line('Before Salary of 1001 is'|| l_salary);
   SELECT salary INTO l_salary FROM emp WHERE emp_no = 1002;
   dbms_output.put_line('Before Salary of 1002 is'|| l_salary);    
   UPDATE emp 
   SET salary = salary + 5000 
   WHERE emp_no = 1001;

nested_block;
ROLLBACK;

 SELECT salary INTO  l_salary FROM emp WHERE emp_no = 1001;
 dbms_output.put_line('After Salary of 1001 is'|| l_salary);
 SELECT salary INTO l_salary FROM emp WHERE emp_no = 1002;
 dbms_output.put_line('After Salary of 1002 is '|| l_salary);
end;

teljesítmény

Before:Salary of 1001 is 15000 
Before:Salary of 1002 is 10000 
After:Salary of 1001 is 15000 
After:Salary of 1002 is 25000

Code Magyarázat:

• Code 2. sor: Az l_salary értékét SZÁM-ként deklarálja.
• Code 3. sor: A nested_block eljárás deklarálása.
• Code 4. sor: A nested_block eljárás AUTONOMOUS_TRANSACTION-né tétele.
• Code 7-9. sor: Az 1002-es alkalmazott fizetésének emelése 15000 fővel.
• Code 10. sor: Az autonóm tranzakció véglegesítése.
• Code 13-16. sor: A 1001-es és 1002-es alkalmazottak fizetési adatainak kinyomtatása a változások előtt.
• Code 17-19. sor: Az 1001-es alkalmazott fizetésének emelése 5000 fővel.
• Code 20. sor: A nested_block eljárás meghívása.
• Code 21. sor: A fő tranzakció elvetése.
• Code 22-25. sor: A 1001-es és 1002-es alkalmazottak fizetési adatainak nyomtatása a változások után.

A 1001-es számú alkalmazott fizetésemelése nem tükröződik, mivel a fő tranzakciót elvetették. A 1002-es számú alkalmazott fizetésemelése tükröződik, mivel ezt a blokkot külön tranzakcióként kezelték és a végén mentették.

Tehát függetlenül a fő tranzakcióban történő mentéstől vagy elvetéstől, az autonóm tranzakcióban végrehajtott módosítások a fő tranzakció befolyásolása nélkül mentésre kerülnek.

Mikor használjunk autonóm tranzakciókat?

Az autonóm tranzakciók hatékonyak, ezért hasznos tudni, hogy mikor illenek bele. Tartsa fenn őket olyan feladatokhoz, amelyeknek a fő tranzakciótól függetlenül kell sikeresnek vagy sikertelennek lenniük, ne pedig az alapvető üzleti logikához. Gyakori használati esetek:

• Audit naplózás: Jegyezze fel, hogy ki, mikor, valamint a régi és az új értékeket módosította-e az érzékeny adatokat, így a napló akkor is fennmarad, ha a fő tranzakció visszavonásra kerül.
• Hibanaplózás: Hibarekord írása egy kivétel kezelőt és COMMIT-olja azt, így a diagnosztikai részletek megmaradnak, miközben a sikertelen tranzakció elvetésre kerül.
• Számlálók és statisztikák: Hozz létre egy használatszámlálót vagy találatszámlálót, amelynek a hívó fél eredményétől függetlenül fenn kell maradnia.
• COMMIT egy triggeren belül: Egy trigger nem adhat ki közvetlenül COMMIT utasítást; egy autonóm tranzakció az egyetlen támogatott módja ennek.

Kerüld az autonóm tranzakciókat a szokásos frissítéseknél, amelyeknek osztozniuk kellene a fő tranzakció sorsán. Túlzott használatuk független commitok mögé rejtheti az adatokat, és megnehezítheti a hibakeresést. Általános szabály, hogy minden autonóm blokknak explicit COMMIT vagy ROLLBACK utasítással kell végződnie.

Autonóm vs. rendszeres tranzakciók

A hagyományos (fő) és az autonóm tranzakciók közötti különbség a hatókörben és a függetlenségben rejlik. Az alábbi táblázat összehasonlítja őket.

Ellentétben egy szokásos beágyazott blokk, amelynek változásai mindig megosztják a mellékelt tranzakció eredményét, egy autonóm blokk önmagában is megállja a helyét. Ennek a különbségnek a megértése segít eldönteni, hogy mikor kell egy blokknak függetlennek lennie, és mikor kell megosztania a fő tranzakció eredményét.

GYIK