Autonom transaktion in Oracle PL / SQL

Vad är TCL-uttalanden i PL/SQL?

TCL står för Transaction Control Statements (Transaction Control Statements). Dessa satser sparar antingen väntande transaktioner eller återställer dem. De spelar en viktig roll, eftersom om inte en transaktion sparas kommer de ändringar som gjorts genom... DML uttalanden kommer inte att lagras permanent i databasen. Nedan följer de olika TCL-satserna i PL / SQL.

Transaktionen kommer att slutföras under följande scenarier:

• När något av ovanstående uttalanden utfärdas (förutom SAVEPOINT).
• När DDL-satser utfärdas (DDL är auto-commit-satser).
• När DCL-uttryck utfärdas (DCL är auto-commit-uttryck).

Använda SAVEPOINT och ROLLBACK TO

Tabellen ovan introducerar SPARPUNKT och ÅTERGÅNG TILL, och tillsammans ger de dig delvis kontroll över en transaktion. En SPARPUNKT markerar en namngiven punkt inuti den aktuella transaktionen. En senare ÅTERGÅNG TILL den sparpunkten ångrar alla ändringar som gjorts efter den, medanping arbetet som utförts innan det intakt.

Detta är användbart när en lång transaktion utför flera SQL steg och endast det sista steget misslyckas. Istället för att ignorera hela transaktionen kan du återgå till den senaste fungerande sparpunkten och fortsätta.

Syntax:

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

Viktiga punkter att komma ihåg om sparpunkter:

• En SAVEPOINT finns bara inom den aktuella transaktionen; en COMMIT eller en fullständig ROLLBACK raderar alla savepoints.
• När du återgår till en sparpunkt raderas alla sparpunkter som skapats efter den, men sparpunkten du återgår till behålls.
• ROLLBACK TO avslutar inte transaktionen; ändringar som gjordes före sparpunkten förblir väntande tills du COMMIT eller ROLLBACK.
• Om du återanvänder ett namn på en sparpunkt flyttar den nyare SAVEPOINT-markören till den senare positionen.

Eftersom ROLLBACK TO lämnar transaktionen öppen bestämmer du fortfarande i slutet om du ska COMMIT de återstående ändringarna eller ignorera dem med en fullständig ROLLBACK.

Vad är autonom transaktion

I PL/SQL kallas alla modifieringar som görs på data för en transaktion. En transaktion anses vara slutförd när en "save" eller "discard" har angetts för den. Om ingen "save" eller "discard" har angetts anses transaktionen inte vara slutförd, och de modifieringar som gjorts på data kommer inte att göras permanenta på servern.

Som standard behandlar PL/SQL alla ändringar under en session som en enda transaktion, och att spara eller ignorera den transaktionen påverkar alla väntande ändringar i sessionen. En autonom transaktion ger utvecklaren möjlighet att göra ändringar i en separat transaktion och att spara eller ignorera den specifika transaktionen utan att påverka huvudsessionstransaktionen.

• En autonom transaktion kan specificeras på underprogramnivå.
• Att göra någon delprogram fungerar i en annan transaktion, bör nyckelordet PRAGMA AUTONOMOUS_TRANSACTION anges i den deklarativa delen av det blocket.
• Den instruerar kompilatorn att behandla detta som en separat transaktion, och att spara eller kassera inuti detta block kommer inte att återspeglas i huvudtransaktionen.
• Det är obligatoriskt att utfärda COMMIT eller ROLLBACK innan man lämnar denna autonoma transaktion och återgår till huvudtransaktionen, eftersom endast en transaktion kan vara aktiv åt gången.
• Så när en autonom transaktion har startats måste den sparas och slutföras innan kontrollen kan återgå till huvudtransaktionen.

Syntax:

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

I ovanstående syntax har blocket gjorts till en autonom transaktion.

Exempel 1: I det här exemplet ska vi förstå hur en autonom transaktion fungerar.

Skärmdumpen nedan visar detta exempel på autonoma transaktioner och dess utdata i 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;

Produktion

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 Förklaring:

• Code rad 2: Deklarerar l_salary som NUMBER.
• Code rad 3: Deklarerar proceduren nested_block.
• Code rad 4: Göra nested_block-proceduren till en AUTONOMOUS_TRANSACTION.
• Code rad 7-9: Öka lönen för anställd nummer 1002 med 15000.
• Code rad 10: Genomför den autonoma transaktionen.
• Code rad 13-16: Utskrift av löneuppgifter för anställda 1001 och 1002 före ändringarna.
• Code rad 17-19: Öka lönen för anställd nummer 1001 med 5000.
• Code rad 20: Anropar proceduren nested_block.
• Code rad 21: Kasta huvudtransaktionen.
• Code rad 22-25: Utskrift av löneuppgifter för anställda 1001 och 1002 efter ändringarna.

Löneökningen för anställd nummer 1001 återspeglas inte eftersom huvudtransaktionen har ignorerats. Löneökningen för anställd nummer 1002 återspeglas eftersom det blocket har gjorts till en separat transaktion och sparats i slutet.

Så oavsett om du sparar eller ignorerar vid huvudtransaktionen sparas ändringarna i den autonoma transaktionen utan att påverka huvudtransaktionen.

När man ska använda autonoma transaktioner

Autonoma transaktioner är kraftfulla, så det är bra att veta när de passar. Reservera dem för arbete som måste lyckas eller misslyckas oberoende av huvudtransaktionen, inte för kärnverksamhetens logik. Vanliga användningsområden inkluderar:

• Granskningsloggning: Registrera vem som ändrade känsliga data, när, och de gamla och nya värdena, så att loggen finns kvar även om huvudtransaktionen återställs.
• Felloggning: Skriv en felpost inuti en undantag hanteraren och COMMIT den, så att diagnosdetaljerna behålls medan den misslyckade transaktionen ignoreras.
• Räknare och statistik: Flytta fram en användningsräknare eller träffräknare som måste behållas oavsett uppringarens resultat.
• COMMIT inuti en trigger: En trigger kan inte utfärda COMMIT direkt; en autonom transaktion är det enda sättet som stöds att göra det.

Undvik autonoma transaktioner för vanliga uppdateringar som ska dela samma öde som huvudtransaktionen. Överanvändning av dem kan dölja data bakom oberoende commits och göra felsökning svårare. Som regel måste varje autonomt block avslutas med en explicit COMMIT eller ROLLBACK.

Autonoma kontra regelbundna transaktioner

Skillnaden mellan en vanlig (huvud)transaktion och en autonom transaktion handlar om omfattning och oberoende. Tabellen nedan jämför dem.

Till skillnad från en vanlig kapslade block, vars ändringar alltid delar resultatet av den omslutande transaktionen, står ett autonomt block på egen hand. Att förstå denna skillnad hjälper dig att avgöra när ett block ska vara oberoende och när det ska dela resultatet av huvudtransaktionen.

Vanliga frågor