SQLite Savepoint: ROLLBACK TO ile İç İçe Transaction

Savepoint, Transaction İçinde İsimlendirilmiş Bir Yer İmidir

Klasik bir transaction ya hep ya hiç mantığıyla çalışır: BEGIN ile COMMIT arasındaki her şey ya birlikte kaydedilir ya da topluca çöpe gider. Çoğu zaman tam da bunu istersiniz — ama bazen daha ince bir kontrol işinize yarar. Yani şöyle bir şey: "Şu değişiklik kümesini deneyeyim; ters giderse sadece o kısmı geri alayım, transaction'ın geri kalanı yaşamaya devam etsin."

İşte sqlite savepoint tam burada devreye giriyor. İsimli bir yer imi koyarsınız, biraz iş yaparsınız, sonra ya yaptığınız işi kalıcılaştırırsınız (RELEASE) ya da yer imine kadar geri sararsınız (ROLLBACK TO).

CREATE TABLE accounts (name TEXT, balance INTEGER);
INSERT INTO accounts VALUES ('Ada', 100), ('Boris', 100);

BEGIN;
  UPDATE accounts SET balance = balance - 30 WHERE name = 'Ada';

  SAVEPOINT risky;
    UPDATE accounts SET balance = balance + 30 WHERE name = 'Nobody';
  ROLLBACK TO risky;

  UPDATE accounts SET balance = balance + 30 WHERE name = 'Boris';
COMMIT;

SELECT * FROM accounts;

Ada'nın hesabından düşülen tutar da, Boris'in hesabına yatan tutar da yerinde kalır. Yanlışlıkla Nobody üzerinde yapılan güncelleme ise işlemin geri kalanını kaybetmeden geri alınmış olur.

Üç Temel Komut

Aslında tüm API üç ifadeden ibaret:

• SAVEPOINT name — bir yer imi koyar.
• RELEASE SAVEPOINT name — yer iminden bu yana yapılan işleri korur ve yer imini kaldırır.
• ROLLBACK TO SAVEPOINT name — yer iminden bu yana olan her şeyi geri alır; yer imi yerinde kalır, böylece tekrar deneyebilirsiniz.

RELEASE ve ROLLBACK TO sonrasındaki SAVEPOINT kelimesi isteğe bağlıdır — yani RELEASE risky ve ROLLBACK TO risky da pekâlâ çalışır.

CREATE TABLE log (msg TEXT);

BEGIN;
  INSERT INTO log VALUES ('başlangıç');

  SAVEPOINT step1;
    INSERT INTO log VALUES ('adım 1 tamam');
  RELEASE step1;

  SAVEPOINT step2;
    INSERT INTO log VALUES ('adım 2 denemesi');
  ROLLBACK TO step2;
    INSERT INTO log VALUES ('adım 2 yeniden deneme');
  RELEASE step2;
COMMIT;

SELECT * FROM log;

adım 2 denemesi satırı, son veritabanı açısından bakıldığında hiçbir zaman var olmamış gibi davranır. Geri kalan her şey kalıcı olur.

Dış Transaction Olmadan Savepoint Kullanımı

Burada küçük bir incelik var: BEGIN yazmadan da doğrudan SAVEPOINT açabilirsiniz. SQLite arka planda sizin için bir transaction başlatır ve en dıştaki savepoint, transaction'ın kendisi rolünü üstlenir. O savepoint üzerinde RELEASE çağırmak commit anlamına gelir; ROLLBACK TO ise commit etmeden geri sarar.

CREATE TABLE notes (text TEXT);

SAVEPOINT outer;
  INSERT INTO notes VALUES ('merhaba');
RELEASE outer;

SELECT * FROM notes;

İşte savepoint'lerin neden bazen "isimli transaction" olarak anıldığını gösteriyor. Ama gerçek kodda bu iki stili karıştırmak kafa karıştırıcı olur — birini seçin. Çoğu kişi dış sınır için açıkça BEGIN ... COMMIT kullanıp, savepoint'leri yalnızca içerideki kısmi geri alma noktaları için tercih ediyor.

SQLite İç İçe Savepoint Kullanımı

Savepoint'ler yığın gibi çalışır. Birinin içinde başka bir savepoint tanımlayabilir ve dıştakine dokunmadan içtekini geri alabilirsiniz:

CREATE TABLE items (name TEXT);

BEGIN;
  INSERT INTO items VALUES ('a');

  SAVEPOINT outer;
    INSERT INTO items VALUES ('b');

    SAVEPOINT inner;
      INSERT INTO items VALUES ('c');
    ROLLBACK TO inner;
    -- 'c' kayboldu; 'a' ve 'b' hâlâ burada

    INSERT INTO items VALUES ('d');
  RELEASE outer;
COMMIT;

SELECT * FROM items;

Son durumdaki kayıtlar: a, b, d. inner noktasına dönmek c kaydını sildi, ama inner öncesinde yapılan işi (yani b eklemesini) olduğu gibi bıraktı; transaction da kaldığı yerden devam etti.

Dış (outer) bir savepoint'e geri dönmek, iç seviyelerde yapılan her şeyi de çöpe atar — o ismin üzerindeki tüm yığın tek seferde çözülür:

CREATE TABLE items (name TEXT);

BEGIN;
  SAVEPOINT outer;
    INSERT INTO items VALUES ('b');
    SAVEPOINT inner;
      INSERT INTO items VALUES ('c');
  ROLLBACK TO outer;
COMMIT;

SELECT * FROM items;

b ve c artık yok. ROLLBACK TO outer, outer belirlendikten sonra olan her şeyi geri alıyor; buna inner ve c insert'i de dahil.

SQLite SAVEPOINT ne işe yarar?

Klasik kullanım senaryosu şu: bir batch işliyorsunuz ve tek bir kaydın hatalı olması yüzünden tüm batch'in çöpe gitmesini istemiyorsunuz. Her kaydı bir savepoint içine sarın; hata olursa o savepoint'e geri dönüp bir sonrakine geçin:

CREATE TABLE imports (id INTEGER PRIMARY KEY, value INTEGER CHECK(value > 0));

BEGIN;
  SAVEPOINT row1;
    INSERT INTO imports(value) VALUES (10);
  RELEASE row1;

  SAVEPOINT row2;
    INSERT INTO imports(value) VALUES (-5);  -- CHECK kısıtını ihlal eder
  ROLLBACK TO row2;

  SAVEPOINT row3;
    INSERT INTO imports(value) VALUES (20);
  RELEASE row3;
COMMIT;

SELECT * FROM imports;

Gerçek uygulama kodunda hatalı INSERT bir hata fırlatır, uygulama bunu yakalar, ROLLBACK TO çalıştırır ve yoluna devam eder. Sağlam iki satır kaydedilir; bozuk satır ise tüm grubu zehirlemez.

Bu desen aynı zamanda ORM'lerin ve migration araçlarının iç içe transaction'ları nasıl uyguladığının da yanıtıdır — aslında BEGIN bloklarını iç içe açmazlar (zaten SQLite buna izin vermez), iç içe çağrıları savepoint'lere eşlerler.

Dikkat Edilmesi Gereken Birkaç Nokta

Savepoint konusuna yeni başlayanların sıkça takıldığı birkaç ayrıntı:

• COMMIT her zaman transaction'ın tamamını işler. Kaç tane açık savepoint olduğu fark etmez — COMMIT (veya takma adı END) en dıştaki transaction'ı kapatır. RELEASE'i kısmi bir commit gibi düşünmeyin; çevreleyen transaction commit edilene kadar hiçbir şey kalıcı değildir.
• ROLLBACK (yanında TO olmadan) her şeyi iptal eder. Transaction'ı sonlandırır ve tüm açık savepoint'leri çöpe atar. Transaction'ı hayatta tutmak istiyorsanız ROLLBACK TO ad kullanın.
• Bir savepoint, release edilene veya üzerinden geri alınana kadar açık kalır. RELEASE etmeyi unutmak veri kaybına yol açmaz; yer imi sadece transaction bitene kadar orada öylece bekler.
• İsimlerin benzersiz olması gerekmiyor. SAVEPOINT s komutunu iki kez verirseniz, ROLLBACK TO s en yakın olanı bulur. Özyinelemede işe yarar; ama yanlışlıkla yapılırsa kafa karıştırır.

Sırada: View'lar

Savepoint'ler size yazma işlemleri üzerinde daha ince bir kontrol sağlıyor. Bir sonraki adım ise okuma tarafını şekillendirmek — bir sorguyu adlandırılmış, tekrar kullanılabilir bir nesne olarak kaydedip ona tablo gibi SELECT çekmek. İşte buna view deniyor ve bir sonraki konumuz bu.