Data: Database dan SQL · 6/7

Transaction: semua atau tidak sama sekali

Alat yang mencegah adanya pembayaran yang setengah jadi.

Baca 25 menit

Setelah pelajaran ini kamu bisa

Membungkus beberapa penulisan dalam sebuah transaction
Menjelaskan apa yang dijamin rollback
Mengenali operasi yang membutuhkannya
Menjelaskan apa itu deadlock dan cara menghindarinya

Transaction mengelompokkan beberapa statement supaya mereka berhasil bersama atau tidak sama sekali. Di antara BEGIN dan COMMIT, tidak ada yang permanen; sebuah ROLLBACK membatalkan semuanya sejak BEGIN.

sql

BEGIN;
  UPDATE accounts SET balance = balance - 200000 WHERE id = 1;
  UPDATE accounts SET balance = balance + 200000 WHERE id = 2;
COMMIT;
-- or, if anything failed:
ROLLBACK;

Contoh klasiknya adalah transfer, dan ia klasik karena kegagalannya sangat jelas. Dijalankan terhadap SQLite proyek ini dengan constraint CHECK (balance >= 0) dan transfer yang lebih besar dari saldonya, hasilnya adalah berikut.

text

Ana 100000, Budi 50000. Transfer 200000 from Ana to Budi.

WITH a transaction:
  first UPDATE fails: CHECK constraint failed: balance >= 0
  ROLLBACK
  => Ana 100000, Budi 50000        (unchanged, correct)

WITHOUT a transaction:
  first UPDATE fails: CHECK constraint failed: balance >= 0
  second UPDATE runs anyway
  => Ana 100000, Budi 250000       (200000 created from nothing)

Keduanya output nyata yang sudah diverifikasi. Yang kedua menciptakan uang — dan tidak ada error pada penulisan yang penting itu.

Coba sendiri

Sebuah transaction, diimplementasikan. Rollback-nya cuma memulihkan snapshot yang diambil saat BEGIN.

function createStore(initial) {
  let data = structuredClone(initial);
  let snapshot = null;

return {
    read: () => structuredClone(data),
    begin() { snapshot = structuredClone(data); },
    commit() { snapshot = null; },
    rollback() {
      if (snapshot === null) throw new Error("no transaction to roll back");
      data = snapshot;                 // everything since begin() is discarded
      snapshot = null;
    },
    update(id, change) {
      const account = data.find((a) => a.id === id);
      const next = account.balance + change;
      // A constraint, checked by the store itself.
      if (next < 0) throw new Error("CHECK constraint failed: balance >= 0");
      account.balance = next;
    },
  };
}

const initial = [
  { id: 1, name: "Ana", balance: 100000 },
  { id: 2, name: "Budi", balance: 50000 },
];

// WITH a transaction: any failure undoes the whole thing.
function transferInTransaction(store, from, to, amount) {
  store.begin();
  try {
    store.update(from, -amount);
    store.update(to, amount);
    store.commit();
    return "committed";
  } catch (error) {
    store.rollback();
    return "rolled back: " + error.message;
  }
}

// WITHOUT one. Each statement stands alone, so a failure in the middle leaves
// the earlier ones applied and the later ones still to come. Here the code
// logs the error and carries on - which is what "no rollback" looks like in
// real code, and it is how the real SQLite run above produced Budi=250000.
function transferNoTransaction(store, from, to, amount) {
  const problems = [];
  try { store.update(from, -amount); } catch (e) { problems.push("debit: " + e.message); }
  try { store.update(to, amount); } catch (e) { problems.push("credit: " + e.message); }
  return problems.length ? "PARTIALLY APPLIED - " + problems.join("; ") : "both applied";
}

const withTx = createStore(initial);
console.log("with transaction:  ", transferInTransaction(withTx, 1, 2, 200000));
console.log("   ", JSON.stringify(withTx.read().map((a) => a.name + "=" + a.balance)));

const withoutTx = createStore(initial);
console.log("");
console.log("without:           ", transferNoTransaction(withoutTx, 1, 2, 200000));
console.log("   ", JSON.stringify(withoutTx.read().map((a) => a.name + "=" + a.balance)));
const total = withoutTx.read().reduce((s, a) => s + a.balance, 0);
console.log("    total money in the system is now", total, "- it started at 150000");

console.log("");
console.log("A successful transfer, for contrast:");
const ok = createStore(initial);
console.log("   ", transferInTransaction(ok, 1, 2, 50000), JSON.stringify(ok.read().map((a) => a.name + "=" + a.balance)));

Hasil

Tekan Jalankan untuk melihat hasilnya.

Ini jalan di browser kamu, di dalam sandbox. Apa pun yang kamu tulis di sini tidak bisa merusak situs.

Kapan kamu membutuhkannya

Setiap penulisan multi-tabel yang harus sepakat. Membuat booking dan mengurangi ketersediaan. Keduanya atau tidak sama sekali.
Baca-lalu-tulis pada data yang sama. Memeriksa sebuah kursi masih kosong, lalu memesannya — transaction mencegah orang lain mengambilnya di sela itu.
Apa pun yang menyangkut uang. Selalu. Tidak ada kondisi setengah jadi yang bisa diterima.
Migration. Perubahan skema yang setengah diterapkan sangat sulit dipulihkan — itu sebabnya proyek ini membungkus setiap migration dengan BEGIN/COMMIT.

Tugas praktik

Baca function migrate di features/db/index.ts. Identifikasi BEGIN, COMMIT, dan ROLLBACK-nya, dan jelaskan dalam satu kalimat apa yang akan terjadi tanpa rollback-nya kalau statement ketiga sebuah migration gagal. Lalu tulis transaction dua statement milikmu sendiri terhadap database latihan dan sengaja buat yang kedua gagal.

Hasil yang diharapkan

Skema yang setengah termigrasi dengan nomor versinya belum maju — tidak bisa dipulihkan tanpa pekerjaan manual.

Cek pemahaman

Sebuah transfer mendebit satu akun dan mengkredit yang lain. Debitnya gagal karena constraint CHECK. Tanpa transaction, apa yang terjadi?

Kedua statement otomatis di-rollbackDebitnya gagal, kreditnya bisa tetap diterapkan, dan uang tercipta dari ketiadaanSeluruh request-nya error sebelum salah satu statement jalan

Pilih jawaban dulu