SQLite DELETE: WHERE ve RETURNING ile Satır Silme

DELETE Sadece Satır Siler, Başka Bir Şey Değil

DELETE, bir tablodan satır çıkarır. Tabloyu silmez, şemasını değiştirmez, başka tablolara da dokunmaz (tabii cascade ayarlamadıysanız). Söz dizimi gayet kısa:

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

INSERT INTO users (email, active) VALUES
    ('ada@example.com', 1),
    ('boris@example.com', 0),
    ('rosa@example.com', 1);

DELETE FROM users WHERE id = 2;

SELECT * FROM users;

DELETE FROM users WHERE id = 2; ifadesi, koşula uyan satırları bulur ve onları siler. Diğer iki satır olduğu gibi kalır. Tablonun kendisi hâlâ yerinde duruyor — istediğiniz kadar yeni kayıt eklemeye devam edebilirsiniz.

Olayı şöyle düşünün: DELETE, eşleşen satırları döndürmek yerine çöpe atan bir SELECT gibidir.

Asıl İşi Yapan WHERE Koşulu

Ciddi bir DELETE sorgusunun kaderi, tamamen WHERE koşulunda saklıdır. Doğru yazarsanız tam olarak silmek istediğiniz satırlar gider. Yanlış yazarsanız niyet ettiğinizden çok daha fazlasını — bazen tablonun tamamını — silmiş olursunuz.

CREATE TABLE posts (
    id INTEGER PRIMARY KEY,
    title TEXT,
    published INTEGER NOT NULL DEFAULT 0,
    views INTEGER NOT NULL DEFAULT 0
);

INSERT INTO posts (title, published, views) VALUES
    ('Birinci taslak',  0, 0),
    ('Eski hit',        1, 5000),
    ('Yayımlandı',      1, 120),
    ('Boş taslak',      0, 0);

DELETE FROM posts WHERE published = 0 AND views = 0;

SELECT * FROM posts;

Yayınlanmamış ve hiç görüntülenmemiş iki taslak silindi. Yayındaki satırlar ise koşula uymadığı için olduğu gibi duruyor. WHERE ifadesinde aklınıza gelen her şeyi kullanabilirsiniz: IN, LIKE, BETWEEN, alt sorgular, AND/OR kombinasyonları...

Edinmeye değer bir alışkanlık: DELETE çalıştırmadan önce aynı WHERE koşulunu bir de SELECT ile deneyin.

-- Nelerin gideceğini önizleyin:
SELECT * FROM posts WHERE published = 0 AND views = 0;

-- Satırlardan memnun musunuz? Şimdi onları silin:
DELETE FROM posts WHERE published = 0 AND views = 0;

Bu iki adımlık dans, bütün yedekleme araçlarının toplamından daha fazla veritabanını kurtarmıştır.

WHERE Olmadan DELETE Tabloyu Boşaltır

WHERE koşulunu yazmazsan DELETE tüm satırları siler:

CREATE TABLE log (
    id INTEGER PRIMARY KEY,
    message TEXT
);

INSERT INTO log (message) VALUES ('bir'), ('iki'), ('üç');

DELETE FROM log;

SELECT COUNT(*) AS remaining FROM log;

Tablo boş ama hâlâ duruyor. SQLite'ta TRUNCATE diye bir komut yok; bunun yerine DELETE FROM tablo; kullanılıyor. SQLite arka planda "truncate optimizasyonu" denilen bir numara çeviriyor: satırları tek tek silmek yerine ilgili sayfaları topluca düşürüyor. Hızlı ama yine de transactional bir işlem, yani gerektiğinde rollback yapabilirsiniz.

Birincil anahtarda AUTOINCREMENT kullandıysan sayaç kendiliğinden sıfırlanmaz. id'leri tekrar 1'den başlatmak istiyorsanız ilgili sequence satırını da temizlemeniz gerekir:

DELETE FROM log;
DELETE FROM sqlite_sequence WHERE name = 'log';

Düz INTEGER PRIMARY KEY (yani AUTOINCREMENT olmadan) kullanıyorsanız SQLite zaten id'leri serbestçe yeniden kullanır; dolayısıyla buna gerek kalmaz.

Birden Fazla Belirli Satırı Silme

Belirli bir satır kümesini silmenin en temiz yolu IN kullanmaktır:

CREATE TABLE tasks (
    id INTEGER PRIMARY KEY,
    title TEXT,
    status TEXT
);

INSERT INTO tasks (title, status) VALUES
    ('dokümanları yaz', 'done'),
    ('PR incele',       'todo'),
    ('dağıt',           'done'),
    ('test yaz',        'todo'),
    ('arşivle',         'done');

DELETE FROM tasks WHERE id IN (1, 3, 5);

SELECT * FROM tasks;

Bir alt sorgu kullanarak da silme işlemi yapabilirsiniz — silinecek satırlar bir join ya da başka bir tablo üzerinden belirleniyorsa bu yöntem çok işine yarar:

CREATE TABLE tasks (
    id INTEGER PRIMARY KEY,
    title TEXT,
    status TEXT
);
CREATE TABLE archived_status (status TEXT);

INSERT INTO tasks (title, status) VALUES
    ('a', 'done'), ('b', 'todo'), ('c', 'cancelled');
INSERT INTO archived_status VALUES ('done'), ('cancelled');

DELETE FROM tasks
WHERE status IN (SELECT status FROM archived_status);

SELECT * FROM tasks;

SQLite, MySQL'deki gibi DELETE ... JOIN sözdizimini desteklemez; ama WHERE içindeki bir alt sorgu (subquery) aynı işi pekala görür.

RETURNING: Sildiğiniz Satırları Görmek

DELETE sorgusuna RETURNING eklerseniz, silinen satırları tıpkı bir SELECT çalıştırmış gibi geri alırsınız:

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

INSERT INTO users (email, active) VALUES
    ('ada@example.com',   1),
    ('boris@example.com', 0),
    ('carol@example.com', 0);

DELETE FROM users
WHERE active = 0
RETURNING id, email;

Silinen her satırın id ve email değerleri elinize geliyor. Bu da şu durumlarda hayat kurtarır:

• Tam olarak nelerin silindiğini loglamak.
• Geri alma (undo) özelliği eklemek — dönen satırları bir kenara stashleyip sonra geri yazabilirsiniz.
• Silme işleminin beklediğiniz satırları etkileyip etkilemediğini tek seferde, ek sorgu atmadan doğrulamak.

RETURNING; INSERT, UPDATE ve DELETE ifadelerinin hepsinde çalışır. Ayrıntılı anlatımı kendi sayfasında bulabilirsiniz.

İlişkili Satırlar İçin ON DELETE CASCADE

Ana tablo ile alt tablo bir foreign key ile bağlıyken ana tablodaki satırı sildiğinizde alt tabloda öksüz kalan satırlar oluşur — tabii SQLite'a cascade yapmasını söylemediyseniz:

PRAGMA foreign_keys = ON;

CREATE TABLE authors (
    id INTEGER PRIMARY KEY,
    name TEXT
);

CREATE TABLE books (
    id INTEGER PRIMARY KEY,
    title TEXT,
    author_id INTEGER REFERENCES authors(id) ON DELETE CASCADE
);

INSERT INTO authors (id, name) VALUES (1, 'Le Guin'), (2, 'Borges');
INSERT INTO books (title, author_id) VALUES
    ('A Wizard of Earthsea', 1),
    ('The Dispossessed',     1),
    ('Ficciones',            2);

DELETE FROM authors WHERE id = 1;

SELECT * FROM books;

Yazarı silmek, ona ait kitapları da siler. ON DELETE CASCADE olmasaydı aynı DELETE ya başarılı olur ve sahipsiz kitaplar bırakırdı (foreign key kapalıysa) ya da constraint hatasıyla patlardı (açıksa).

Asıl tuzak şu: SQLite'ta foreign key'ler varsayılan olarak kapalıdır. Her bağlantı için PRAGMA foreign_keys = ON; komutunu çalıştırmanız gerekir. Bu pragma ayarlanmadıysa ON DELETE CASCADE sessiz sedasız görmezden gelinir — kitaplar yerinde kalır. Çoğu uygulama sürücüsü bunu sizin yerinize ayarlar veya bir seçenek olarak sunar; kullandığınızı bir kontrol edin.

Bilmeye değer diğer cascade seçenekleri: ON DELETE SET NULL (foreign key'i temizler), ON DELETE RESTRICT (alt kayıtlar varsa silmeyi reddeder), ON DELETE NO ACTION (varsayılan — çoğu durumda RESTRICT ile aynı).

LIMIT ile DELETE (Derleme Zamanı Seçeneği)

Bazı SQLite derlemeleri DELETE ... LIMIT kullanımını destekler; bu da devasa tablolardan parça parça satır silmek için oldukça işe yarar:

DELETE FROM logs
WHERE created_at < '2024-01-01'
ORDER BY created_at
LIMIT 1000;

Bunun çalışması için SQLite'ın SQLITE_ENABLE_UPDATE_DELETE_LIMIT bayrağıyla derlenmiş olması gerekiyor. Resmi binary'lerde ve çoğu dil bağlayıcısında (Python'un sqlite3'ü, Node'un better-sqlite3'ü) bu özellik zaten açık. Sizinkinde açık değilse sözdizimi hatası alırsınız; bu durumda alt sorgu kullanarak şu şekilde halledebilirsiniz:

DELETE FROM logs
WHERE id IN (
    SELECT id FROM logs
    WHERE created_at < '2024-01-01'
    ORDER BY created_at
    LIMIT 1000
);

Toplu silme işlemlerini küçük parçalara bölmek, transaction'ları kısa tutar — başka bağlantılar veritabanını okurken bu çok önemli olur.

Büyük Silme İşlemlerini Transaction İçine Alın

DELETE zaten örtük olarak transaction'lıdır: ya eşleşen tüm satırlar silinir ya da hiçbiri. Ama çok sayıda satır sileceğiniz zaman, işlemi açık bir transaction içine almak size bir avantaj sağlar — bir terslik fark ederseniz ROLLBACK ile geri dönebilirsiniz:

CREATE TABLE accounts (
    id INTEGER PRIMARY KEY,
    balance INTEGER
);

INSERT INTO accounts (balance) VALUES (100), (200), (0), (50), (0);

BEGIN;
    DELETE FROM accounts WHERE balance = 0;
    SELECT COUNT(*) AS remaining FROM accounts;
ROLLBACK;

SELECT COUNT(*) AS still_here FROM accounts;

ROLLBACK silme işlemini tamamen geri alır. Gerçek bir oturumda, sayılar doğru göründüğünde COMMIT ile işlemi onaylarsınız. Ayrıca, çok sayıda satırı tek tek silerken transaction kullanmak işi inanılmaz hızlandırır — döngüyü BEGIN/COMMIT arasına almak, her silme için ayrı ayrı fsync yapılmasının önüne geçer.

Silinmeyen Şeyler

Sık karşılaşılan birkaç kafa karışıklığını netleştirelim:

• DELETE FROM tablo; tabloyu boşaltır ama ortadan kaldırmaz. Tablonun kendisini silmek için DROP TABLE tablo; kullan.
• DELETE veritabanı dosyasını küçültmez. Boşalan sayfalar yeniden kullanılmak üzere "boş" olarak işaretlenir. Disk alanını geri kazanmak için VACUUM; çalıştır (performans bölümünde anlatılıyor).
• Bir satırı silmek, başka tablolardaki bağlı satırları otomatik olarak silmez — bunun olması için hem ON DELETE CASCADE tanımlı olmalı hem de foreign key desteği açık olmalı.
• Hiçbir satıra denk gelmeyen bir DELETE hata değildir. changes() = 0 döndüren başarılı bir ifadedir. Bilmeniz gerekiyorsa etkilenen satır sayısını kontrol et.

Sırada: UPSERT

Çoğu zaman aslında silmek istemezsin — satır yeniyse eklemek, varsa güncellemek istersiniz. SQLite buna UPSERT diyor ve ON CONFLICT ifadesi sayesinde üç ayrı sorgu yerine tek bir ifadeyle hallediyorsunuz. Sıradaki konu bu.