Autonome transactie in Oracle PL / SQL

Wat zijn TCL-instructies in PL/SQL?

TCL staat voor Transaction Control Statements (transactiecontrole-instructies). Deze instructies slaan de lopende transacties op of draaien ze terug. Ze spelen een cruciale rol, want als een transactie niet wordt opgeslagen, blijven de wijzigingen die via TCL zijn aangebracht van kracht. DML-instructies wordt niet permanent in de database opgeslagen. Hieronder staan ​​de verschillende TCL-instructies in PL / SQL.

De transactie is voltooid onder de volgende omstandigheden:

• Wanneer een van de bovenstaande verklaringen wordt afgegeven (behalve SAVEPOINT).
• Wanneer DDL-instructies worden uitgegeven (DDL zijn auto-commit-instructies).
• Wanneer DCL-statements worden uitgegeven (DCL's zijn auto-commit-statements).

Gebruik maken van SAVEPOINT en ROLLBACK TO

De bovenstaande tabel introduceert SAVEPOINT en ROLLBACK TO. Samen geven ze u gedeeltelijke controle over een transactie. Een SAVEPOINT markeert een benoemd punt binnen de huidige transactie. Een latere ROLLBACK TO naar dat savepoint maakt alle wijzigingen die erna zijn aangebracht ongedaan, terwijl een ROLLBACK TO de transactie behoudt.ping Het werk dat eraan voorafging, blijft intact.

Dit is handig wanneer een langdurige transactie meerdere acties uitvoert. SQL Je kunt de transactie stap voor stap afbreken, maar alleen de laatste stap mislukt. In plaats van de hele transactie te annuleren, kun je teruggaan naar het laatst succesvolle opslagpunt en verdergaan.

Syntax:

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

Belangrijke punten om te onthouden over savepoints:

• Een savepoint bestaat alleen binnen de huidige transactie; een commit of een volledige rollback wist alle savepoints.
• Wanneer je terugkeert naar een eerder opgeslagen spelstandpunt, worden alle daarna gemaakte opslagpunten verwijderd, maar het opslagpunt waarnaar je terugkeert, blijft behouden.
• ROLLBACK TO beëindigt de transactie niet; de wijzigingen die vóór het opslagpunt zijn aangebracht, blijven in behandeling totdat u COMMIT of ROLLBACK uitvoert.
• Als je een savepointnaam hergebruikt, verplaatst de nieuwere savepointnaam de markering naar de latere positie.

Omdat ROLLBACK TO de transactie open laat, beslis je uiteindelijk nog steeds of je de resterende wijzigingen wilt COMMITTEN of ze wilt terugdraaien met een volledige ROLLBACK.

Wat is autonome transactie

In PL/SQL worden alle wijzigingen die aan gegevens worden aangebracht een transactie genoemd. Een transactie wordt als voltooid beschouwd wanneer er een save- of discard-commando aan is gekoppeld. Als er geen save- of discard-commando wordt gegeven, wordt de transactie niet als voltooid beschouwd en worden de wijzigingen aan de gegevens niet permanent op de server opgeslagen.

Standaard behandelt PL/SQL alle wijzigingen tijdens een sessie als één transactie, en het opslaan of annuleren van die transactie heeft invloed op alle lopende wijzigingen in de sessie. Een autonome transactie biedt de ontwikkelaar de mogelijkheid om wijzigingen in een aparte transactie aan te brengen en die specifieke transactie op te slaan of te annuleren zonder de hoofdtransactie van de sessie te beïnvloeden.

• Een autonome transactie kan op subprogrammaniveau worden gespecificeerd.
• Om er een te maken subprogramma Om in een andere transactie te werken, moet het trefwoord PRAGMA AUTONOMOUS_TRANSACTION in het declaratiegedeelte van dat blok worden opgenomen.
• Dit instrueert de compiler om dit als een aparte transactie te behandelen, en het opslaan of verwijderen binnen dit blok heeft geen invloed op de hoofdtransactie.
• Het uitvoeren van een COMMIT- of ROLLBACK-opdracht is verplicht voordat u deze autonome transactie verlaat en terugkeert naar de hoofdtransactie, omdat er op elk moment slechts één transactie actief kan zijn.
• Zodra een autonome transactie is gestart, moet deze worden opgeslagen en voltooid voordat de controle weer kan worden overgedragen aan de hoofdtransactie.

Syntax:

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

In de bovenstaande syntax is het blok een autonome transactie geworden.

Voorbeeld 1: In dit voorbeeld gaan we begrijpen hoe een autonome transactie werkt.

De onderstaande schermafbeelding toont dit voorbeeld van een autonome transactie en de bijbehorende uitvoer. 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;

uitgang

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 Uitleg:

• Code lijn 2: Het salaris van l_salary declareren als NUMMER.
• Code lijn 3: De procedure nested_block declareren.
• Code lijn 4: De geneste_blokprocedure een AUTONOMOUS_TRANSACTION maken.
• Code regel 7-9: Verhoging van het salaris voor medewerker nummer 1002 met 15000.
• Code lijn 10: De autonome transactie voltooien.
• Code regel 13-16: Het afdrukken van de salarisgegevens van werknemers 1001 en 1002 vóór de wijzigingen.
• Code regel 17-19: Verhoging van het salaris voor medewerker nummer 1001 met 5000.
• Code lijn 20: De geneste_blokprocedure aanroepen.
• Code lijn 21: De hoofdtransactie weggooien.
• Code regel 22-25: Het afdrukken van de salarisgegevens van werknemers 1001 en 1002 na de wijzigingen.

De salarisverhoging voor medewerker nummer 1001 wordt niet weergegeven omdat de hoofdtransactie is verwijderd. De salarisverhoging voor medewerker nummer 1002 wordt wel weergegeven omdat dit blok als een aparte transactie is aangemaakt en aan het einde is opgeslagen.

Ongeacht of de wijzigingen in de autonome transactie worden opgeslagen of verwijderd tijdens de hoofdtransactie, worden ze opgeslagen zonder de hoofdtransactie te beïnvloeden.

Wanneer moet je autonome transacties gebruiken?

Autonome transacties zijn krachtig, dus het is handig om te weten wanneer ze gepast zijn. Reserveer ze voor taken die onafhankelijk van de hoofdtransactie moeten slagen of mislukken, en niet voor de kernlogica van een bedrijf. Veelvoorkomende gebruiksscenario's zijn onder andere:

• Auditregistratie: Leg vast wie gevoelige gegevens heeft gewijzigd, wanneer, en de oude en nieuwe waarden, zodat het logboek behouden blijft, zelfs als de hoofdtransactie wordt teruggedraaid.
• Fout loggen: Schrijf een foutrecord binnen een uitzondering handler en COMMIT deze, zodat de diagnostische details behouden blijven terwijl de mislukte transactie wordt verworpen.
• Tellers en statistieken: Verhoog een gebruiksteller of hit-teller die moet blijven bestaan, ongeacht de uitkomst van de oproep.
• COMMIT binnen een trigger: Een trigger kan niet rechtstreeks een COMMIT-opdracht geven; een autonome transactie is de enige ondersteunde manier om dit te doen.

Vermijd autonome transacties voor gewone updates die hetzelfde lot moeten delen als de hoofdtransactie. Overmatig gebruik ervan kan gegevens achter onafhankelijke commits verbergen en debuggen bemoeilijken. In de regel moet elk autonoom blok eindigen met een expliciete COMMIT of ROLLBACK.

Autonome versus reguliere transacties

Het verschil tussen een reguliere (hoofd)transactie en een autonome transactie zit hem in de reikwijdte en onafhankelijkheid. De onderstaande tabel vergelijkt ze.

Anders dan een gewone genest blokEen autonoom blok, waarvan de wijzigingen altijd de uitkomst van de omringende transactie delen, staat op zichzelf. Het begrijpen van dit verschil helpt je te bepalen wanneer een blok onafhankelijk moet zijn en wanneer het de uitkomst van de hoofdtransactie moet delen.

Veelgestelde vragen