Perintah SQL UPDATE di SQLite: WHERE, Banyak Kolom, dan FROM

UPDATE Mengubah Baris yang Sudah Ada

INSERT menambahkan baris baru. UPDATE mengubah baris yang sudah ada. Bentuknya singkat dan layak dihafal:

UPDATE table_name
SET column = value
WHERE condition;

Contoh yang berjalan:

CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    email TEXT,
    status TEXT DEFAULT 'active'
);

INSERT INTO users (name, email) VALUES
    ('Ada', 'ada@old.com'),
    ('Boris', 'boris@old.com'),
    ('Rosa', 'rosa@old.com');

UPDATE users
SET email = 'ada@new.com'
WHERE id = 1;

SELECT * FROM users;

SET menyatakan apa yang berubah. WHERE menyatakan baris mana. Bagian tabel lainnya tidak disentuh.

Dalam Praktiknya, Klausa WHERE Tidak Opsional

Secara teknis, WHERE bersifat opsional. Secara praktis, melupakannya adalah cara engineer junior merusak sore harinya:

UPDATE users SET status = 'inactive';
-- every single user is now inactive

Tanpa filter, setiap baris cocok. SQLite akan menurut tanpa banyak bicara. Selalu tulis WHERE lebih dulu, baru kemudian SET. Kebiasaan itu saja sudah mencegah banyak kecelakaan.

Kalau kamu tidak yakin WHERE-mu benar, jalankan dulu kondisi yang sama sebagai SELECT:

CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, status TEXT);
INSERT INTO users VALUES (1, 'Ada', 'active'), (2, 'Boris', 'active'), (3, 'Rosa', 'pending');

-- Preview which rows would be touched.
SELECT id, name, status FROM users WHERE status = 'pending';

-- Then run the update with the exact same WHERE.
UPDATE users SET status = 'active' WHERE status = 'pending';

SELECT * FROM users;

Kondisi yang sama, dua pernyataan. SELECT itu adalah uji cobamu.

Meng-update Banyak Kolom

Pisahkan penugasan dengan koma di dalam satu SET. Satu SET, banyak kolom:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL,
    stock INTEGER
);

INSERT INTO products VALUES (1, 'Widget', 9.99, 100);

UPDATE products
SET price = 12.99,
    stock = 75,
    name = 'Premium Widget'
WHERE id = 1;

SELECT * FROM products;

Satu kali bolak-balik ke database, satu baris berubah, tiga kolom di-update. Jangan tulis tiga pernyataan UPDATE terpisah jika satu saja sudah cukup.

Ekspresi di Sebelah Kanan =

Nilai setelah = tidak harus literal. Nilainya bisa ekspresi apa pun, termasuk yang merujuk ke nilai kolom saat ini:

CREATE TABLE products (id INTEGER PRIMARY KEY, name TEXT, price REAL, stock INTEGER);
INSERT INTO products VALUES
    (1, 'Widget', 10.00, 50),
    (2, 'Gadget', 20.00, 30),
    (3, 'Gizmo', 15.00, 80);

-- Raise prices by 10%.
UPDATE products
SET price = price * 1.10;

-- Decrement stock for one row.
UPDATE products
SET stock = stock - 1
WHERE id = 2;

SELECT * FROM products;

price * 1.10 membaca harga yang ada, mengalikannya, lalu menulis hasilnya kembali. SQLite mengevaluasi sisi kanan memakai nilai baris saat ini sebelum penugasan apa pun dari pernyataan ini berlaku, jadi kamu bisa merujuk beberapa kolom dengan aman:

UPDATE products SET price = price * 1.10, stock = stock + price;
-- 'price' on the right side here is the OLD price, not the just-updated one.

UPDATE ... FROM: Mengambil Nilai dari Tabel Lain

Sejak SQLite 3.33, UPDATE mendukung klausa FROM untuk update lintas tabel. Ini cara paling rapi untuk menyinkronkan data antartabel:

CREATE TABLE customers (id INTEGER PRIMARY KEY, name TEXT, total_spent REAL DEFAULT 0);
CREATE TABLE orders (id INTEGER PRIMARY KEY, customer_id INTEGER, amount REAL);

INSERT INTO customers (name) VALUES ('Ada'), ('Boris'), ('Rosa');
INSERT INTO orders (customer_id, amount) VALUES
    (1, 50.00), (1, 30.00),
    (2, 100.00),
    (3, 25.00), (3, 75.00);

UPDATE customers
SET total_spent = totals.sum_amount
FROM (
    SELECT customer_id, SUM(amount) AS sum_amount
    FROM orders
    GROUP BY customer_id
) AS totals
WHERE customers.id = totals.customer_id;

SELECT * FROM customers;

Subquery menghitung total per pelanggan; UPDATE di luar menggabungkan hasil itu kembali ke customers berdasarkan id. Tanpa UPDATE ... FROM, kamu harus menulis correlated subquery untuk setiap kolom, jauh lebih berantakan.

Beberapa aturan yang perlu diingat:

• Tabel target ditulis setelah UPDATE, bukan di daftar FROM.
• Klausa WHERE yang melakukan join: tidak ada kata kunci ON di sini.
• Jika join bisa mencocokkan lebih dari satu baris di FROM, hasilnya tidak terdefinisi. Pastikan kunci join-mu menghasilkan paling banyak satu kecocokan per baris target.

RETURNING: Lihat Apa yang Berubah

SQLite (3.35+) memungkinkan UPDATE mengembalikan baris yang diubah dalam pernyataan yang sama. Praktis saat aplikasimu butuh nilai setelah update tanpa SELECT susulan:

CREATE TABLE products (id INTEGER PRIMARY KEY, name TEXT, price REAL);
INSERT INTO products VALUES (1, 'Widget', 10.00), (2, 'Gadget', 20.00);

UPDATE products
SET price = price * 0.9
WHERE price > 15
RETURNING id, name, price;

Kamu mendapat kembali baris yang benar-benar disentuh, beserta nilai barunya. Ini menghemat satu kali bolak-balik dan menghilangkan satu golongan race condition di kode yang berjalan serentak. Ada satu halaman penuh tentang RETURNING nanti di bab ini.

UPDATE OR REPLACE: Menangani Konflik Constraint

Jika update-mu akan melanggar constraint UNIQUE, perilaku default-nya adalah membatalkan pernyataan dengan error. Klausa OR memungkinkanmu memilih kebijakan lain:

CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    email TEXT UNIQUE,
    name TEXT
);

INSERT INTO users VALUES
    (1, 'ada@x.com', 'Ada'),
    (2, 'boris@x.com', 'Boris');

-- This would fail with a UNIQUE constraint violation:
-- UPDATE users SET email = 'boris@x.com' WHERE id = 1;

-- OR REPLACE deletes the conflicting row, then performs the update.
UPDATE OR REPLACE users
SET email = 'boris@x.com'
WHERE id = 1;

SELECT * FROM users;

Pilihannya adalah OR ABORT (default), OR REPLACE, OR IGNORE, OR FAIL, dan OR ROLLBACK. REPLACE adalah yang berbahaya: ia menghapus baris yang berkonflik, dan itu bisa merambat lewat foreign key. Pakai hanya saat kamu benar-benar bermaksud "jika sudah ada baris dengan nilai unik ini, buang saja."

Untuk sebagian besar pekerjaan bergaya upsert, sintaks khusus INSERT ... ON CONFLICT lebih jelas. Ada halaman tersendiri untuk itu.

Bungkus Update yang Berisiko dalam Transaksi

Saat kamu mengubah banyak baris atau menjalankan beberapa pernyataan UPDATE yang harus berhasil bersama-sama, bungkus semuanya dalam transaksi. Jika ada yang salah, kamu bisa melakukan rollback ke keadaan sebelumnya:

CREATE TABLE accounts (id INTEGER PRIMARY KEY, name TEXT, balance REAL);
INSERT INTO accounts VALUES (1, 'Ada', 100.00), (2, 'Boris', 50.00);

BEGIN;
    UPDATE accounts SET balance = balance - 25 WHERE id = 1;
    UPDATE accounts SET balance = balance + 25 WHERE id = 2;
COMMIT;

SELECT * FROM accounts;

Jika pernyataan kedua gagal (misalnya ada constraint yang terpicu), ROLLBACK membatalkan yang pertama. Tanpa transaksi, kamu akan tertinggal dengan transfer yang setengah jadi: saldo Ada berkurang 25, Boris tidak berubah. Transaksi punya babnya sendiri nanti; cukup ketahui bahwa transaksi itu ada dan update massal hampir selalu sebaiknya berada di dalamnya.

Jebakan Umum

Daftar singkat hal-hal yang sering menjebak:

• Lupa WHERE: setiap baris ikut di-update. Bacakan pernyataanmu keras-keras sebelum menjalankannya.
• Operator yang salah di WHERE: WHERE status = NULL tidak mencocokkan apa pun. Pakai IS NULL. Kita akan membahasnya di halaman operator.
• Update dengan subquery yang mengembalikan lebih dari satu baris padahal kamu mengharapkan satu. Pakai LIMIT 1 atau agregasikan subquery-nya, kalau tidak kamu akan mendapat error atau hasil yang mengejutkan.
• Mengira UPDATE OR REPLACE sama dengan UPSERT. OR REPLACE menghapus baris yang berkonflik. INSERT ... ON CONFLICT DO UPDATE mengubahnya di tempat. Operasinya berbeda.

Berikutnya: DELETE

UPDATE mengubah baris; DELETE menghapusnya. Disiplin WHERE yang sama berlaku, dan kebiasaan "jalankan SELECT dulu" yang sama akan menyelamatkanmu dari bencana yang sama. Itu halaman berikutnya.