SQLite GROUP BY ve HAVING: Grupları Filtrelemek

Q: SQLite'ta WHERE ile HAVING arasındaki fark nedir?

WHERE, satırları gruplama yapılmadan önce tek tek filtreler. HAVING ise toplama işleminden sonra grupları filtreler. Yani WHERE amount > 100 sadece tutarı 100'den büyük olan satırları bırakır; HAVING SUM(amount) > 100 ise toplamı 100'ü geçen grupları bırakır. COUNT veya SUM gibi toplama (aggregate) fonksiyonları WHERE içinde kullanılamaz — zaten HAVING tam da bunun için var.

Q: SQLite'ta GROUP BY olmadan HAVING kullanılabilir mi?

Evet, kullanılabilir. GROUP BY olmadığında SQLite tüm sonuç kümesini tek bir grup gibi ele alır ve HAVING o tek grubu bir bütün olarak filtreler. Sorgu ya tek satır döner ya da hiç satır dönmez. Pratikte pek karşılaşılan bir durum değildir; genelde HAVING varsa yanında bir GROUP BY da bulunur.

Q: SQLite'ta grupları COUNT'a göre nasıl filtelerim?

Toplama fonksiyonunu WHERE içine değil, HAVING içine yazmalısın. Örneğin SELECT customerid, COUNT() FROM orders GROUP BY customerid HAVING COUNT() > 1 sorgusu birden fazla siparişi olan müşterileri döndürür. SQLite'ta HAVING içinde SELECT listesindeki kolon takma adını (alias) da kullanabilirsin.

GROUP BY ile Satırları Gruplara Toplama

COUNT, SUM, AVG gibi aggregate fonksiyonlar bir sürü satırı tek bir değere indirger. GROUP BY ise bu işi kategori bazında yapmanı sağlar: müşteri başına, ay başına, durum başına tek bir sayı. Her benzersiz değer (ya da değer kombinasyonu) sonuçta tek bir satır olarak karşına çıkar.

CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    customer TEXT,
    amount REAL
);

INSERT INTO orders (customer, amount) VALUES
    ('Ada',   50.00),
    ('Ada',   30.00),
    ('Boris', 80.00),
    ('Boris', 20.00),
    ('Boris', 15.00),
    ('Cleo', 200.00);

SELECT customer, COUNT(*) AS order_count, SUM(amount) AS total
FROM orders
GROUP BY customer;

Üç müşteri, üç satır sonuç. Başlangıçtaki altı satır artık yok — her müşteri için ayrı bir kovaya toplandı ve COUNT(*) ile SUM(amount) her kovanın içinde ayrı ayrı hesaplandı.

Olayı şöyle düşün: GROUP BY customer demek, "aynı customer değerine sahip tüm satırları tek bir grup olarak değerlendir" demek. Aggregate fonksiyonlar da bundan sonra her grup üzerinde ayrı ayrı çalışır.

SELECT Listesinde Neler Yer Alabilir?

Burası genelde kafa karıştırır. GROUP BY kullandığında, SELECT listesindeki her sütun ya GROUP BY ifadesinde geçmeli ya da bir aggregate fonksiyonun içinde olmalı. Aksi hâlde değer belirsiz kalır — gruptaki hangi satırdan alınacağı belli değildir ki.

CREATE TABLE sales (
    region TEXT,
    rep TEXT,
    amount REAL
);

INSERT INTO sales VALUES
    ('North', 'Ada', 100),
    ('North', 'Boris', 200),
    ('South', 'Cleo', 150);

-- Bu çalışır: region gruplanmış, amount toplanmıştır.
SELECT region, SUM(amount) AS total
FROM sales
GROUP BY region;

SELECT region, rep, SUM(amount) yazıp GROUP BY region koyarsanız, SQLite bunu sorunsuz çalıştırır (başka veritabanları reddederken o esnek davranır), ama rep değeri grup içinden rastgele seçilir. Her bölge için bir temsilci ismi alırsınız, ama hangisinin geleceğinin garantisi yoktur. Buna bel bağlamayın — gösterdiğiniz ve aggregate olmayan her sütunu GROUP BY'a ekleyin.

HAVING ile Gruplara Aggregation Sonrası Filtre Uygulama

WHERE satırları gruplama öncesinde filtreler. HAVING ise grupları gruplama sonrasında filtreler. SQLite'da where ile having farkı aslında bundan ibaret. İşte tam da bu yüzden COUNT(*) > 1 ifadesini WHERE içine koyamazsınız — çünkü WHERE çalıştığı anda ortada henüz bir sayım yoktur.

CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    customer TEXT,
    amount REAL
);

INSERT INTO orders (customer, amount) VALUES
    ('Ada', 50), ('Ada', 30),
    ('Boris', 80), ('Boris', 20), ('Boris', 15),
    ('Cleo', 200);

SELECT customer, COUNT(*) AS order_count
FROM orders
GROUP BY customer
HAVING COUNT(*) > 1;

Cleo yalnızca tek bir sipariş verdiği için onun grubu eleniyor. Geriye Ada ve Boris kalıyor. Koşul, tek tek satırlara değil, her grubun birleştirilmiş (aggregate) değerine uygulanıyor.

SQLite'ta SELECT listesindeki sütun takma adlarını (alias) doğrudan HAVING içinde kullanabilirsiniz — buna izin verilir:

CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    customer TEXT,
    amount REAL
);

INSERT INTO orders (customer, amount) VALUES
    ('Ada',   50.00),
    ('Ada',   30.00),
    ('Boris', 80.00),
    ('Boris', 20.00),
    ('Boris', 15.00),
    ('Cleo', 200.00);

SELECT customer, SUM(amount) AS total
FROM orders
GROUP BY customer
HAVING total >= 100;

SUM(amount) ifadesini HAVING içinde tekrar tekrar yazmaktan çoğu zaman daha okunaklı olur.

WHERE ve HAVING farkı: İkisini birlikte kullanın

Bu iki cümleyi birbirinin alternatifi gibi düşünmeyin. WHERE, gruplamaya hangi satırların dahil olacağını daraltır; HAVING ise hangi grupların sonuca yansıyacağını süzer. Gerçek hayattaki sorguların büyük çoğunluğu ikisini birden kullanır.

CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    customer TEXT,
    amount REAL,
    status TEXT
);

INSERT INTO orders (customer, amount, status) VALUES
    ('Ada', 50, 'paid'),
    ('Ada', 30, 'refunded'),
    ('Boris', 80, 'paid'),
    ('Boris', 20, 'paid'),
    ('Cleo', 200, 'paid'),
    ('Cleo', 50, 'refunded');

SELECT customer, SUM(amount) AS paid_total
FROM orders
WHERE status = 'paid'
GROUP BY customer
HAVING SUM(amount) > 75;

Yukarıdan aşağıya, çalışma sırasıyla okuyalım:

WHERE status = 'paid' — iade edilmiş satırları tamamen ele.
GROUP BY customer — kalan satırları müşteriye göre grupla.
SUM(amount) her grup için ayrı ayrı çalışır.
HAVING SUM(amount) > 75 — yalnızca eşiği geçen grupları tut.

Boris (80 + 20 = 100) ve Cleo (200) elemeyi geçer. Ada'nın tek ödenmiş siparişi 50 olduğu için eşiğin altında kalır.

Birden Fazla Koşul ve Birden Fazla Gruplama Sütunu

HAVING, WHERE ile aynı mantıksal operatörleri kabul eder — AND, OR, NOT — ayrıca birden fazla sütuna göre gruplayarak alt kırılımlar elde edebilirsiniz:

CREATE TABLE sales (
    region TEXT,
    quarter TEXT,
    amount REAL
);

INSERT INTO sales VALUES
    ('North', 'Q1', 100), ('North', 'Q1', 50),
    ('North', 'Q2', 300),
    ('South', 'Q1', 80),
    ('South', 'Q2', 120), ('South', 'Q2', 60);

SELECT region, quarter, SUM(amount) AS total, COUNT(*) AS deals
FROM sales
GROUP BY region, quarter
HAVING SUM(amount) > 100 AND COUNT(*) >= 2;

Her (region, quarter) ikilisi ayrı bir grup oluşturuyor. Buradaki HAVING koşulu hem toplamın 100'ün üzerinde olmasını hem de en az iki anlaşma bulunmasını istiyor. Bu kriterleri yalnızca ('North', 'Q1') ve ('South', 'Q2') karşılıyor.

Pratik Bir Kullanım: Tekrarlanan Kayıtları Bulmak

Bir kolondaki tekrar eden değerleri yakalamanın en yaygın yolu GROUP BY ... HAVING COUNT(*) > 1 sorgusudur:

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

INSERT INTO users (email) VALUES
    ('ada@example.com'),
    ('boris@example.com'),
    ('ada@example.com'),
    ('cleo@example.com'),
    ('boris@example.com');

SELECT email, COUNT(*) AS occurrences
FROM users
GROUP BY email
HAVING COUNT(*) > 1;

İki adet mükerrer kayıt karşımıza çıkıyor. Buradan sonrası genelde şuna karar vermekle geçer: hesapları birleştirmek mi, UNIQUE kısıtı eklemek mi, yoksa veriyi temizlemek mi gerekiyor? Ama bu tarz tespit sorgularının iskeleti her seferinde aynıdır.

GROUP BY Olmadan HAVING Kullanımı

Pek alışılmış olmasa da SQLite bunu kabul eder. GROUP BY yazmadığınızda tüm sonuç kümesi tek bir gruba indirgenir; HAVING da bu tek grubu bir bütün olarak süzer. Yani ya tüm toplulaştırılmış değerleri görürsünüz ya da hiçbir şey:

CREATE TABLE orders (id INTEGER PRIMARY KEY, amount REAL);
INSERT INTO orders (amount) VALUES (50), (30), (80);

SELECT COUNT(*) AS total_orders, SUM(amount) AS revenue
FROM orders
HAVING SUM(amount) > 100;

Tek bir sonuç satırı dönmesinin sebebi, toplamın 160 olması. Eşiği > 200 yapın; sorgu hiç satır döndürmez. Pratikte HAVING'i neredeyse her zaman GROUP BY ile birlikte kullanırsınız — ama dilin bunu zorunlu kılmadığını bilmek de iyidir.

Kısa Özet

GROUP BY, satırları anahtara göre kovalara toplar; aggregate fonksiyonlar her kovanın içinde çalışır.
SELECT içindeki aggregate olmayan her sütun GROUP BY içinde de yer almalı.
WHERE gruplamadan önce satırları filtreler; HAVING ise gruplamadan sonra grupları filtreler.
COUNT(*) ve SUM(...) gibi aggregate ifadeler HAVING içine yazılır, asla WHERE'e değil.
HAVING birden fazla koşulu birleştirebilir ve SELECT'teki takma adlara (alias) referans verebilir.

Sırada: Foreign Key'ler

Tek bir tabloyu gruplayıp özetlemek işe yarar, ama gerçek hayattaki şemaların çoğu veriyi birden fazla tabloya yayar — siparişler bir tabloda, müşteriler başka bir tabloda, ürünler bambaşka bir yerde. Foreign key'ler de bu tabloları birbirine bağlayıp ilişkilerin tutarlı kalmasını sağlayan mekanizmadır. Bir sonraki bölümün konusu tam olarak bu.

Sıkça Sorulan Sorular

SQLite'ta WHERE ile HAVING arasındaki fark nedir?

WHERE, satırları gruplama yapılmadan önce tek tek filtreler. HAVING ise toplama işleminden sonra grupları filtreler. Yani WHERE amount > 100 sadece tutarı 100'den büyük olan satırları bırakır; HAVING SUM(amount) > 100 ise toplamı 100'ü geçen grupları bırakır. COUNT veya SUM gibi toplama (aggregate) fonksiyonları WHERE içinde kullanılamaz — zaten HAVING tam da bunun için var.

SQLite'ta GROUP BY olmadan HAVING kullanılabilir mi?

Evet, kullanılabilir. GROUP BY olmadığında SQLite tüm sonuç kümesini tek bir grup gibi ele alır ve HAVING o tek grubu bir bütün olarak filtreler. Sorgu ya tek satır döner ya da hiç satır dönmez. Pratikte pek karşılaşılan bir durum değildir; genelde HAVING varsa yanında bir GROUP BY da bulunur.

SQLite'ta grupları COUNT'a göre nasıl filtelerim?

Toplama fonksiyonunu WHERE içine değil, HAVING içine yazmalısın. Örneğin SELECT customer_id, COUNT(*) FROM orders GROUP BY customer_id HAVING COUNT(*) > 1 sorgusu birden fazla siparişi olan müşterileri döndürür. SQLite'ta HAVING içinde SELECT listesindeki kolon takma adını (alias) da kullanabilirsin.

İlgili kavramlar