SQLite - Transaktionen

Eine Transaktion ist eine Arbeitseinheit, die für eine Datenbank ausgeführt wird. Transaktionen sind Einheiten oder Abfolgen von Arbeiten, die in einer logischen Reihenfolge ausgeführt werden, entweder manuell von einem Benutzer oder automatisch von einer Art Datenbankprogramm.

Eine Transaktion ist die Weitergabe einer oder mehrerer Änderungen an der Datenbank. Wenn Sie beispielsweise einen Datensatz erstellen, aktualisieren oder aus der Tabelle löschen, führen Sie eine Transaktion für die Tabelle aus. Es ist wichtig, Transaktionen zu steuern, um die Datenintegrität sicherzustellen und Datenbankfehler zu behandeln.

In der Praxis werden Sie viele SQLite-Abfragen zu einer Gruppe zusammenfassen und alle zusammen als Teil einer Transaktion ausführen.

Eigenschaften von Transaktionen

Transaktionen haben die folgenden vier Standardeigenschaften, die normalerweise mit dem Akronym ACID bezeichnet werden.

  • Atomicity- stellt sicher, dass alle Vorgänge innerhalb der Arbeitseinheit erfolgreich abgeschlossen wurden; Andernfalls wird die Transaktion zum Zeitpunkt des Ausfalls abgebrochen und frühere Vorgänge werden auf ihren vorherigen Status zurückgesetzt.

  • Consistency - Stellt sicher, dass die Datenbank bei einer erfolgreich festgeschriebenen Transaktion den Status ordnungsgemäß ändert.

  • Isolation - Ermöglicht den unabhängigen und transparenten Betrieb von Transaktionen.

  • Durability - Stellt sicher, dass das Ergebnis oder die Wirkung einer festgeschriebenen Transaktion bei einem Systemausfall bestehen bleibt.

Transaktionskontrolle

Die folgenden Befehle werden zur Steuerung von Transaktionen verwendet:

  • BEGIN TRANSACTION - Um eine Transaktion zu starten.

  • COMMIT - Um die Änderungen zu speichern, können Sie sie alternativ verwenden END TRANSACTION Befehl.

  • ROLLBACK - Um die Änderungen rückgängig zu machen.

Transaktionssteuerungsbefehle werden nur mit den DML-Befehlen INSERT, UPDATE und DELETE verwendet. Sie können beim Erstellen oder Löschen von Tabellen nicht verwendet werden, da diese Vorgänge automatisch in der Datenbank festgeschrieben werden.

Befehl TRANSACTION BEGINNEN

Transaktionen können mit BEGIN TRANSACTION oder einfach mit dem Befehl BEGIN gestartet werden. Solche Transaktionen bleiben normalerweise bestehen, bis der nächste Befehl COMMIT oder ROLLBACK auftritt. Eine Transaktion wird jedoch auch zurückgesetzt, wenn die Datenbank geschlossen wird oder ein Fehler auftritt. Es folgt die einfache Syntax zum Starten einer Transaktion.

BEGIN;
or 
BEGIN TRANSACTION;

Befehl COMMIT

Der Befehl COMMIT ist der Transaktionsbefehl, mit dem Änderungen, die von einer Transaktion aufgerufen werden, in der Datenbank gespeichert werden.

Der Befehl COMMIT speichert alle Transaktionen in der Datenbank seit dem letzten Befehl COMMIT oder ROLLBACK.

Es folgt die Syntax für den Befehl COMMIT.

COMMIT;
or
END TRANSACTION;

ROLLBACK-Befehl

Der Befehl ROLLBACK ist der Transaktionsbefehl, mit dem Transaktionen rückgängig gemacht werden, die noch nicht in der Datenbank gespeichert wurden.

Der Befehl ROLLBACK kann nur zum Rückgängigmachen von Transaktionen verwendet werden, seit der letzte Befehl COMMIT oder ROLLBACK ausgegeben wurde.

Es folgt die Syntax für den Befehl ROLLBACK.

ROLLBACK;

Example

Betrachten Sie die COMPANY- Tabelle mit den folgenden Datensätzen.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Starten Sie nun eine Transaktion und löschen Sie Datensätze aus der Tabelle mit dem Alter = 25. Verwenden Sie dann den Befehl ROLLBACK, um alle Änderungen rückgängig zu machen.

sqlite> BEGIN;
sqlite> DELETE FROM COMPANY WHERE AGE = 25;
sqlite> ROLLBACK;

Wenn Sie nun die COMPANY-Tabelle überprüfen, enthält sie weiterhin die folgenden Datensätze:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Beginnen wir eine weitere Transaktion und löschen Datensätze aus der Tabelle mit dem Alter = 25. Schließlich verwenden wir den Befehl COMMIT, um alle Änderungen festzuschreiben.

sqlite> BEGIN;
sqlite> DELETE FROM COMPANY WHERE AGE = 25;
sqlite> COMMIT;

Wenn Sie jetzt überprüfen, dass die COMPANY-Tabelle noch die folgenden Datensätze enthält:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0