SQLite-transaktion

Sammanfattning :i den här handledningen kommer vi att visa dig hur du använder SQLite-transaktionen för att säkerställa datas integritet och tillförlitlighet.

SQLite &ACID

SQLite är en transaktionsdatabas där alla ändringar och frågor är atomära, konsekventa, isolerade och hållbara (ACID).

SQLite garanterar att alla transaktioner är ACID-kompatibla även om transaktionen avbryts av en programkrasch, operativsystemdump eller strömavbrott till datorn.

A tomisk:en transaktion bör vara atomär. Det innebär att en förändring inte kan delas upp i mindre. När du genomför en transaktion tillämpas antingen hela transaktionen eller inte.
C onsistent:en transaktion måste säkerställa att databasen ändras från ett giltigt tillstånd till ett annat. När en transaktion startar och exekverar en sats för att modifiera data, blir databasen inkonsekvent. Men när transaktionen genomförs eller rullas tillbaka är det viktigt att transaktionen måste hålla databasen konsekvent.
Jag solation:en väntande transaktion som utförs av en session måste isoleras från andra sessioner. När en session startar en transaktion och exekverar INSERT eller UPDATE uttalande för att ändra data, är dessa ändringar endast synliga för den aktuella sessionen, inte andra. Å andra sidan bör ändringarna som utförts av andra sessioner efter att transaktionen startade inte vara synliga för den aktuella sessionen.
Varaktig:om en transaktion genomförs framgångsrikt måste ändringarna vara permanenta i databasen oavsett tillstånd som strömavbrott eller programkrasch. Tvärtom, om programmet kraschar innan transaktionen genomförs bör förändringen inte bestå.

SQLite-transaktionsutdrag

Som standard fungerar SQLite i auto-commit-läge. Det betyder att för varje kommando startar, bearbetar och utför SQLite transaktionen automatiskt.

För att starta en transaktion explicit använder du följande steg:

Öppna först en transaktion genom att utfärda BEGIN TRANSACTION kommando.

BEGIN TRANSACTION;Code language: SQL (Structured Query Language) (sql)

Efter att ha kört satsen BEGIN TRANSACTION , transaktionen är öppen tills den uttryckligen har begåtts eller återställts.

För det andra, utfärda SQL-satser för att välja eller uppdatera data i databasen. Observera att ändringen endast är synlig för den aktuella sessionen (eller klienten).

För det tredje, genomför ändringarna i databasen genom att använda COMMIT eller COMMIT TRANSACTION uttalande.

COMMIT;Code language: SQL (Structured Query Language) (sql)

Om du inte vill spara ändringarna kan du gå tillbaka med ROLLBACK eller ROLLBACK TRANSACTION uttalande:

ROLLBACK;Code language: SQL (Structured Query Language) (sql)

SQLite-transaktionsexempel

Vi kommer att skapa två nya tabeller:accounts och account_changes för demonstrationen.

accounts Tabellen lagrar data om kontonumren och deras saldon. account_changes tabellen lagrar ändringarna av kontona.

Skapa först accounts och account_changes tabeller genom att använda följande CREATE TABLE uttalanden:

CREATE TABLE accounts ( 
	account_no INTEGER NOT NULL, 
	balance DECIMAL NOT NULL DEFAULT 0,
	PRIMARY KEY(account_no),
        CHECK(balance >= 0)
);

CREATE TABLE account_changes (
	change_no INT NOT NULL PRIMARY KEY,
	account_no INTEGER NOT NULL, 
	flag TEXT NOT NULL, 
	amount DECIMAL NOT NULL, 
	changed_at TEXT NOT NULL 
);Code language: SQL (Structured Query Language) (sql)

För det andra, infoga några exempeldata i accounts bord.

INSERT INTO accounts (account_no,balance)
VALUES (100,20100);

INSERT INTO accounts (account_no,balance)
VALUES (200,10100);
Code language: SQL (Structured Query Language) (sql)

För det tredje, fråga efter data från accounts tabell:

SELECT * FROM accounts;Code language: SQL (Structured Query Language) (sql)

För det fjärde, överför 1000 från konto 100 till 200 och logga ändringarna i tabellen account_changes i en enda transaktion.

BEGIN TRANSACTION;

UPDATE accounts
   SET balance = balance - 1000
 WHERE account_no = 100;

UPDATE accounts
   SET balance = balance + 1000
 WHERE account_no = 200;
 
INSERT INTO account_changes(account_no,flag,amount,changed_at) 
VALUES(100,'-',1000,datetime('now'));

INSERT INTO account_changes(account_no,flag,amount,changed_at) 
VALUES(200,'+',1000,datetime('now'));

COMMIT;Code language: SQL (Structured Query Language) (sql)

För det femte, fråga efter data från accounts tabell:

SELECT * FROM accounts;Code language: SQL (Structured Query Language) (sql)

Som du kan se har saldon uppdaterats framgångsrikt.

För det sjätte, fråga efter innehållet i account_changes tabell:

SELECT * FROM account_changes;Code language: SQL (Structured Query Language) (sql)

Låt oss ta ett annat exempel på att återställa en transaktion.

Försök först att dra av 20 000 från konto 100:

BEGIN TRANSACTION;

UPDATE accounts
   SET balance = balance - 20000
 WHERE account_no = 100;

INSERT INTO account_changes(account_no,flag,amount,changed_at) 
VALUES(100,'-',20000,datetime('now'));Code language: SQL (Structured Query Language) (sql)

SQLite utfärdade ett fel på grund av att saldot inte var tillräckligt:

[SQLITE_CONSTRAINT]  Abort due to constraint violation (CHECK constraint failed: accounts)Code language: CSS (css)

Loggen har dock sparats i account_changes tabell:

SELECT * FROM account_changes;Code language: SQL (Structured Query Language) (sql)

För det andra, återställ transaktionen genom att använda ROLLBACK uttalande:

ROLLBACK;Code language: SQL (Structured Query Language) (sql)

Fråga slutligen data från account_changes tabell, kommer du att se att ändring nr #3 inte finns där längre:

SELECT * FROM account_changes;Code language: SQL (Structured Query Language) (sql)

I den här handledningen har du lärt dig hur du hanterar SQLite-transaktioner genom att använda BEGIN TRANSACTION , COMMIT , och ROLLBACK satser för att kontrollera transaktionerna i SQLite-databasen.