SELECT: veriyi sorgulamak

Ders 33'te veriyi bir tabloya koydun. Veritabanının asıl gücü ise o veriye soru sorabilmekte: "Hangi şampiyonla en çok kazandım?", "Deniz maç başına kaç kill alıyor?", "En az iki kez oynanan şampiyonlardan hangisi daha iyi gidiyor?" Bu soruların hepsi tek bir SQL komutuyla sorulur: SELECT. Bu derste onu bir maç geçmişi tablosu üzerinde adım adım kuracaksın: sütun seçmek, satır süzmek, sıralamak, saymak ve gruplamak. Sonunda istatistik sitelerinin gösterdiği tabloları kendi sorgunla üretebileceksin.

SELECT yalnız okur, tabloyu değiştirmez. İstediğin kadar dene; yanlış yazılmış bir sorgu verini bozamaz.

#Örnek veri: maç geçmişi tablosu

Dersin bütün sorguları aynı tabloda çalışacak: üç arkadaşın (Deniz, Ece ve Mert) son 20 maçı. Her satır bir maç, her sütun o maçın bir bilgisi. Sütunlar ve tipleri:

• id (integer): maçın numarası; veritabanı kendisi verir (birincil anahtar).
• oyuncu (text): maçı oynayan, Deniz, Ece ya da Mert.
• sampiyon (text): seçilen şampiyon.
• rol (text): üst, orman, orta, alt ya da destek; ARAM maçlarında boş.
• sonuc (text): zafer ya da yenilgi.
• kill, olum, asist (integer): maç sonu skoru, 8/2/11 gibi.
• sure_dk (integer): maçın süresi, dakika olarak.
• tarih (timestamptz): maçın başladığı an.

Aşağıdaki betik tabloyu kurar ve 20 maçı ekler. Bu dersin amacı veri girmek değil sorgu yazmak; bu yüzden betiği kopyalayabilirsin. Neon'da SQL Editor'ü aç (Ders 33), New Query ile boş bir sayfa aç, betiği yapıştır ve Run'a bas. Dersin sonunda bu betiği maclar.sql adıyla bir dosyaya da kaydedeceksin.

1-- Maç geçmişi tablosu. Yeniden çalıştırırsan tabloyu sıfırdan kurar.2DROP TABLE IF EXISTS maclar;3 4CREATE TABLE maclar (5    id integer GENERATED ALWAYS AS IDENTITY PRIMARY KEY,6    oyuncu text,7    sampiyon text,8    rol text,9    sonuc text,10    kill integer,11    olum integer,12    asist integer,13    sure_dk integer,14    tarih timestamptz15);16 17INSERT INTO maclar (oyuncu, sampiyon, rol, sonuc, kill, olum, asist, sure_dk, tarih) VALUES18    ('Deniz', 'Ahri',    'orta',   'zafer',   8,  2, 11, 31, '2026-09-28 20:40+03'),19    ('Ece',   'Jinx',    'alt',    'zafer',   12, 3, 8,  32, '2026-09-28 21:30+03'),20    ('Mert',  'Garen',   'üst',    'zafer',   9,  3, 5,  34, '2026-09-29 19:10+03'),21    ('Deniz', 'Ahri',    'orta',   'yenilgi', 3,  6, 4,  27, '2026-09-29 22:05+03'),22    ('Ece',   'Thresh',  'destek', 'zafer',   1,  4, 19, 36, '2026-09-30 18:20+03'),23    ('Mert',  'Lee Sin', 'orman',  'yenilgi', 4,  7, 10, 29, '2026-09-30 21:45+03'),24    ('Deniz', 'Lux',     'destek', 'zafer',   2,  3, 15, 35, '2026-10-01 20:15+03'),25    ('Ece',   'Kai''Sa', 'alt',    'yenilgi', 5,  7, 4,  28, '2026-10-01 22:40+03'),26    ('Deniz', 'Jinx',    NULL,     'zafer',   14, 6, 22, 19, '2026-10-02 19:55+03'),27    ('Mert',  'Darius',  'üst',    'yenilgi', 3,  8, 3,  26, '2026-10-02 22:20+03'),28    ('Ece',   'Jinx',    'alt',    'zafer',   9,  2, 10, 30, '2026-10-03 17:25+03'),29    ('Deniz', 'Yasuo',   'orta',   'yenilgi', 6,  9, 2,  24, '2026-10-03 20:50+03'),30    ('Mert',  'Lee Sin', 'orman',  'zafer',   6,  4, 14, 31, '2026-10-04 16:30+03'),31    ('Ece',   'Lux',     NULL,     'yenilgi', 6,  8, 25, 17, '2026-10-04 19:00+03'),32    ('Deniz', 'Ahri',    'orta',   'zafer',   11, 1, 7,  29, '2026-10-05 21:20+03'),33    ('Ece',   'Ashe',    'alt',    'zafer',   7,  0, 12, 25, '2026-10-06 20:05+03'),34    ('Mert',  'Teemo',   'üst',    'yenilgi', 2,  7, 6,  35, '2026-10-07 22:30+03'),35    ('Deniz', 'Annie',   'orta',   'zafer',   7,  4, 9,  33, '2026-10-08 21:00+03'),36    ('Ece',   'Jinx',    'alt',    'yenilgi', 3,  5, 6,  40, '2026-10-09 23:15+03'),37    ('Mert',  'Garen',   NULL,     'zafer',   10, 9, 18, 21, '2026-10-10 18:45+03');

Betikte dört şeye dikkat et:

• -- ile başlayan satır yorumdur. JavaScript'teki // gibi; veritabanı onu okumaz.
• DROP TABLE IF EXISTS maclar; "maclar adında bir tablo varsa sil" demek. Betiği ikinci kez çalıştırırsan tablo baştan kurulur ve maçlar iki kez eklenmez. İlk çalıştırmada NOTICE: table "maclar" does not exist, skipping gibi bir bilgi satırı görebilirsin; hata değil. DROP TABLE geri alınamaz (Ders 33), ama bu tabloda yalnız deneme verisi var.
• Üç maçta rol yerine tırnaksız NULL yazıyor. Bunlar ARAM maçları: orada koridor seçilmez, rol bilgisi yok. NULL'u dersin ortasında ayrıntılı göreceksin.
• 'Kai''Sa' Ders 33'teki gibi yazıldı: metnin içindeki kesme işareti iki kez yazılır. Saatler de Ders 33'teki gibi Türkiye saatiyle (+03) girildi; Neon onları UTC'ye çevirip gösterir.

#SELECT: hangi sütunlar gelsin?

İlk sorgu, Ders 33'te tabloya bakmak için kullandığın kalıp: tablonun tamamını getirir. Editöre kendin yaz ve Run'a bas; altta şu sonuç tablosu belirir:

SELECT * FROM maclar;

Sorgunun dört parçası var:

• SELECT: "seç, getir". Arkasına hangi sütunları istediğini yazarsın.
• * (yıldız): "bütün sütunlar".
• FROM maclar: "maclar tablosundan".
• ; komutun bittiğini söyler. Editörde tek komut varken unutsan da çalışır, ama komutları birbirinden ayıran odur; her sorgunun sonuna koymayı alışkanlık edin.

NULL yazan hücreler boş hücreler; başka araçlar onları boş da gösterebilir. Tarihler Ders 33'te gördüğün gibi UTC'ye çevrilmiş gelir (+00): 20:40+03 diye girilen maç 17:40:00+00 görünür, ikisi aynı an.

Anahtar sözcükleri büyük harfle yazmak bir gelenek: SQL, anahtar sözcüklerde ve tırnaksız adlarda büyük-küçük harfe bakmaz; select * from maclar; da çalışır. Büyük yazınca hangi sözcüğün SQL'e, hangisinin senin tablona ait olduğu bir bakışta ayrılır.

Çoğu zaman bütün sütunlar gerekmez. İstediğin sütunları virgülle ayırarak yaz; sonuç o sütunlarla, senin yazdığın sırayla gelir:

SELECT oyuncu, sampiyon, sonuc FROM maclar;

#Neden her zaman * yazmıyoruz?

* bir tabloyu ilk kez tanırken çok kullanışlıdır. Ama bir programın içinde her gün çalışacak sorgularda onu alışkanlık hâline getirme:

• Gereksiz veri taşır. Ekranda yalnız şampiyon adı gösterecekken tarih, süre ve skor da gelir. 20 satırda fark etmez; iki milyon satırda veritabanı, ağ ve sunucun boşuna yorulur.
• Tablo değişince sürpriz yapar. Tabloya yeni bir sütun eklenince (Ders 35'te ALTER TABLE ile yapacaksın) * onu da getirmeye başlar ve kodun beklemediği bir alanla karşılaşır.
• Gizli bilgiyi sızdırabilir. Ders 31'deki gibi bir kullanicilar tablosunda sifre_hash sütunu varsa ve API'n SELECT * sonucunu olduğu gibi JSON'a çevirip gönderiyorsa, hash'ler herkesin tarayıcısına gider.
• Okuyanı yorar. SELECT oyuncu, sampiyon ne istediğini kendisi söyler; SELECT * okuyanı tabloya bakmaya zorlar.

SELECT oyuncu, sampiyon, FROM maclar;

ERROR:  syntax error at or near "FROM"

#WHERE: hangi satırlar gelsin?

SELECT sütunları seçer, ama satırların hepsi yine gelir. Yalnız Ahri maçlarını görmek istiyorsan satırları süzmen gerekir. Bu iş WHERE'in:

SELECT sampiyon, sonuc, kill FROM maclar WHERE sampiyon = 'Ahri';

WHERE'den sonra bir koşul gelir. PostgreSQL tablonun her satırı için koşula bakar: doğruysa satır sonuca girer, değilse elenir. Ders 11'de öğrendiğin filter ile aynı fikir, maclar.filter((mac) => mac.sampiyon === "Ahri") gibi; tek fark, işi bu kez veritabanının yapması.

Koşullarda kullanacağın karşılaştırma işaretleri:

SQL'de eşitlik tek = ile sorulur. JavaScript'te = "koy", === "eşit mi" demekti; SQL'de WHERE içindeki = her zaman karşılaştırmadır. Sayılar tırnaksız yazılır. 10 ya da daha fazla kill alınan maçlar:

SELECT oyuncu, sampiyon, kill FROM maclar WHERE kill >= 10;

#Metin tek tırnakla yazılır

Ders 33'teki kural WHERE'de de geçerli: metin değerleri tek tırnak içinde yazılır, 'Ahri'. JavaScript'te hep çift tırnak kullandığın için parmakların koşul yazarken de ona gidecek:

SELECT sampiyon, sonuc, kill FROM maclar WHERE sampiyon = "Ahri";

ERROR:  column "Ahri" does not exist

Metin karşılaştırması büyük-küçük harfe duyarlıdır: WHERE sampiyon = 'ahri' hiç satır döndürmez, çünkü tablodaki değer büyük A ile Ahri. Harf büyüklüğüne bakmayan aramayı LIKE bölümünde göreceksin.

#Koşulları birleştirmek: AND, OR, NOT

Gerçek sorular çoğu zaman tek koşulla bitmez: "Deniz'in kazandığı maçlar" iki koşul demek. Koşullar eklendikçe sorgu da uzar ve tek satıra sığmaz olur.

Sorgunun SELECT …, FROM …, WHERE … gibi bir anahtar sözcükle başlayan her parçasına cümlecik (clause) denir. SQL satır sonlarına ve girintiye bakmaz, komutu yalnız ; bitirir. Bu yüzden bundan sonra uzun sorguları cümleciklerine bölüp alt alta yazacağız; editörde de böyle yaz, okuması kolaylaşır.

AND iki koşulun ikisi de doğruysa satırı geçirir:

SELECT oyuncu, sampiyon, sonuc, killFROM maclarWHERE oyuncu = 'Deniz' AND sonuc = 'zafer';

OR için koşullardan birinin doğru olması yeter. Ahri ya da Yasuo oynanan maçlar:

SELECT oyuncu, sampiyon, sonucFROM maclarWHERE sampiyon = 'Ahri' OR sampiyon = 'Yasuo';

NOT bir koşulu tersine çevirir. Mert'in kazanamadığı maçlar:

SELECT oyuncu, sampiyon, sonucFROM maclarWHERE oyuncu = 'Mert' AND NOT sonuc = 'zafer';

Bunlar Ders 3'teki mantık işaretlerinin (&&, ||, !) SQL'deki adları. Kuralları da aynı, tuzakları da.

#AND, OR'dan önce bağlanır

Ahri ya da Lux oynanan maçlardan kazanılanları istiyorsun ve aklındaki cümleyi sırasıyla yazıyorsun:

SELECT oyuncu, sampiyon, sonucFROM maclarWHERE sampiyon = 'Ahri' OR sampiyon = 'Lux' AND sonuc = 'zafer';

Listede bir yenilgi var. Hata mesajı yok, sorgu çalıştı, ama sonuç yanlış. Sebebi Ders 3'tekiyle aynı: AND, OR'dan önce bağlanır. PostgreSQL bu koşulu "Ahri ya da (Lux ve zafer)" diye okudu ve Ahri'nin bütün maçları geçti. Ne kastettiğini parantezle söyle:

SELECT oyuncu, sampiyon, sonucFROM maclarWHERE (sampiyon = 'Ahri' OR sampiyon = 'Lux') AND sonuc = 'zafer';

#IN ve BETWEEN: kısa yollar

Aynı sütun için uzun bir OR zinciri yazmak yerine IN ile bir liste verebilirsin. Yukarıdaki parantezli sorgu kısaca şöyle yazılır:

SELECT oyuncu, sampiyon, sonucFROM maclarWHERE sampiyon IN ('Ahri', 'Lux') AND sonuc = 'zafer';

IN "bu listedekilerden biri" demek; Ders 5'teki takim.includes("Lux") kalıbının SQL'deki karşılığı. NOT IN ise "listedekilerin hiçbiri".

BETWEEN bir aralık verir ve iki ucu da dahildir. 6 ile 9 arasında kill alınan maçlar:

SELECT oyuncu, sampiyon, kill FROM maclar WHERE kill BETWEEN 6 AND 9;

Sonuçta tam 6 ve tam 9 kill'li maçlar da var. Aynı koşulu uzun yoldan kill >= 6 AND kill <= 9 diye de yazabilirdin.

#ORDER BY: sıralamak

Şimdiye kadarki sonuçlar tabloya eklendikleri sırayla geldi. Bu bir tesadüf: ORDER BY yazmadığın sürece PostgreSQL sıra sözü vermez. Tablo büyüyüp değiştikçe aynı sorgu satırları başka bir sırayla getirebilir. Sıra önemliyse, ki neredeyse her zaman önemlidir, ORDER BY yaz. Deniz'in maçları, en çok kill alınan en üstte:

SELECT sampiyon, sonuc, killFROM maclarWHERE oyuncu = 'Deniz'ORDER BY kill DESC;

DESC (descending, azalan) büyükten küçüğe demek. Hiçbir şey yazmazsan ya da ASC (ascending, artan) yazarsan küçükten büyüğe sıralar. Metinler alfabetik, tarihler eskiden yeniye dizilir.

ORDER BY'ın yeri WHERE'den sonradır. Türkçe harfli metinlerin sırası veritabanının dil ayarına bağlıdır; bazı ayarlarda Çağla, Zeynep'ten sonra bile gelebilir.

#Birden çok sütuna göre

Kazanılan maçlar; önce oyuncuya göre, aynı oyuncunun maçları da kill'e göre:

SELECT oyuncu, sampiyon, killFROM maclarWHERE sonuc = 'zafer'ORDER BY oyuncu, kill DESC;

Her sütunun yönü ayrı yazılır: oyuncu'nun yanında DESC olmadığı için o artan (A'dan Z'ye) sıralandı, kill ise azalan.

#LIMIT ve OFFSET: ilk birkaç satır ve sayfalar

Bütün listeye değil, en iyi üç maça bakmak istiyorsun. LIMIT sonucun ilk birkaç satırını alır:

SELECT oyuncu, sampiyon, kill FROM maclar ORDER BY kill DESC LIMIT 3;

LIMIT sorgunun en sonuna yazılır ve ORDER BY ile birlikte anlam kazanır. ORDER BY olmadan LIMIT 3 "herhangi üç satır" demektir; hangilerinin geleceği belli değildir.

#OFFSET ile sayfa sayfa

Maç geçmişi ekranları bütün maçları bir anda yüklemez: önce birkaç maç gelir, "daha fazla göster"e basınca sonrakiler. Buna sayfalama denir.

OFFSET n "ilk n satırı atla" demek; LIMIT ile birlikte sonuçtan bir sayfa keser. Kill sıralamasını 5'er maçlık sayfalara böldüğünü düşün. 2. sayfa, ilk 5 satırı atlayıp sonraki 5'ini alır:

SELECT id, oyuncu, sampiyon, killFROM maclarORDER BY kill DESC, idLIMIT 5 OFFSET 5;

Üçüncü sayfa için OFFSET 10, dördüncü sayfa için OFFSET 15 yazarsın: her sayfada önceki sayfaların bütün satırları atlanır. Son sayfadan sonrasını istersen boş bir tablo gelir; bu hata değil.

#SELECT'te hesap ve takma ad

SELECT'in arkasına yalnız sütun adı değil, hesap da yazabilirsin. Kill ile asistin toplamı, oyuncunun takım savaşlarına ne kadar katıldığını kabaca gösterir. Bu toplamın en yüksek olduğu üç maç:

SELECT oyuncu, sampiyon, kill + asistFROM maclarORDER BY kill + asist DESCLIMIT 3;

Hesap doğru, ama sütunun adı ?column? oldu. Ders 33'te söylenen buydu: hesaba ad vermezsen PostgreSQL ona kendisi bir ad uyduramaz.

Ders 33'teki ilk sorguda yaptığın gibi AS ile ad ver. Sonuç sütununa böyle verilen ada takma ad (alias) denir. Takma adı ORDER BY'da da kullanabilirsin:

SELECT oyuncu, sampiyon, kill + asist AS katkiFROM maclarORDER BY katki DESCLIMIT 3;

#LIKE ve ILIKE: metin içinde aramak

Şampiyon seçim ekranındaki arama kutusunu düşün: a yazınca yalnız adında a geçenler kalır. = bunu yapamaz; satırı ancak metnin tamamı eşitse bulur. Metnin bir kısmına göre aramak için LIKE ve bir kalıp kullanırsın:

SELECT oyuncu, sampiyon FROM maclar WHERE sampiyon LIKE 'A%';

Kalıptaki % "burada herhangi sayıda karakter olabilir, hiç olmayabilir de" demek; 'A%' A ile başlayan her şeyi tutar. Kalıplarda iki joker karakter var: % ve tam bir karakterin yerini tutan _ (alt çizgi). Bu tablodaki şampiyonlarla:

• 'A%': A ile başlayan. Ahri, Ashe, Annie.
• '%e': e ile biten. Ashe, Annie.
• '%in%': içinde "in" geçen. Jinx, Lee Sin.
• '____' (dört alt çizgi): tam dört karakterli. Ahri, Jinx, Ashe.
• '_e%': ikinci harfi e olan. Lee Sin, Teemo.

Kalıpta joker karakter yoksa LIKE, = gibi davranır: sampiyon LIKE 'Lee' hiçbir şey bulmaz, çünkü tam ad Lee Sin.

#Büyük-küçük harf: ILIKE

LIKE da = gibi büyük-küçük harfe duyarlıdır. Kullanıcı arama kutusuna küçük a yazarsa:

SELECT oyuncu, sampiyon FROM maclar WHERE sampiyon LIKE 'a%';

Boş tablo, çünkü bütün adlar büyük harfle başlıyor. PostgreSQL'in ILIKE'ı aynı kalıbı harf büyüklüğüne bakmadan uygular:

SELECT oyuncu, sampiyon FROM maclar WHERE sampiyon ILIKE 'a%';

Arama kutuları neredeyse her zaman ILIKE ister. İki not: ILIKE PostgreSQL'e özgüdür, başka veritabanlarında adı ve davranışı farklıdır. Türkçedeki İ, ı gibi harflerde büyük-küçük eşleştirmesi veritabanının dil ayarına bağlıdır; Ders 9'daki toLocaleUpperCase("tr") tuzağının bir benzeri.

#NULL: bilinmeyen değer

Üç ARAM maçında rol boş. Onları bulmak için aklına gelen ilk sorgu muhtemelen şudur:

SELECT id, oyuncu, sampiyon, rol FROM maclar WHERE rol = NULL;

Neden boş? Ders 33'te NULL'u "değer yok" diye tanıdın. Karşılaştırmalarda PostgreSQL onu "bilinmiyor" diye ele alır. rol = NULL sorusu "bu maçın rolü, bilinmeyen bir şeye eşit mi?" olur; cevabı da "bilinmiyor"dur.

Bunu kendin görebilirsin. Ders 33'teki ilk sorgun gibi SELECT'i tablosuz çalıştır; tek satırlık bir hesap makinesi gibi davranır:

SELECT NULL = NULL AS bos_bosa_esit_mi,    'orta' = 'orta' AS orta_ortaya_esit_mi;

İki NULL'un eşitliği bile NULL çıktı, yani bilinmiyor. (Bazı araçlar true yerine t yazar.) WHERE ise yalnız sonucu doğru (true) olan satırları geçirir; yanlış çıkanlar da bilinmeyenler de elenir.

Doğru sorgu:

SELECT id, oyuncu, sampiyon, rol FROM maclar WHERE rol IS NULL;

Rolü belli maçları da WHERE rol IS NOT NULL getirir. NULL'la yapılan hesaplar da NULL verir: NULL + 5 sonucu NULL'dur, çünkü bilinmeyen bir sayıya beş eklersen sonuç yine bilinmez.

#Toplama fonksiyonları: COUNT, SUM, AVG, MIN, MAX

Şimdiye kadarki her sorgu satır döndürdü. Bazen satırların kendisini değil özetini istersin: "Kaç maç oynandı?" COUNT(*) satırları sayar:

SELECT COUNT(*) FROM maclar;

20 satır tek bir sayıya indi. Sütunun adı count oldu; ona da AS ile daha anlamlı bir ad verebilirsin. COUNT gibi çok satırı alıp tek bir değer üreten fonksiyonlara toplama fonksiyonu denir. Beş temel toplama fonksiyonu var:

SELECT SUM(kill) AS toplam_kill, AVG(kill) AS ortalama_kill,    MIN(kill) AS en_az, MAX(kill) AS en_cokFROM maclar;

Ortalama 6.4000000000000000 çıktı, çünkü PostgreSQL ortalamayı tam hassasiyetle verir. ROUND(değer, basamak) onu istediğin basamağa yuvarlar. Toplama fonksiyonları WHERE ile birlikte de çalışır; o zaman yalnız süzülen satırlar özetlenir. Deniz'in karnesi:

SELECT COUNT(*) AS mac, SUM(kill) AS toplam_kill,    ROUND(AVG(kill), 2) AS ortalama_kill, MAX(kill) AS en_cok_killFROM maclarWHERE oyuncu = 'Deniz';

MIN ve MAX yalnız sayılarla sınırlı değil; tarihte en eskiyi ve en yeniyi, metinde alfabetik ilk ve sonu bulur:

SELECT MIN(tarih) AS ilk_mac, MAX(tarih) AS son_mac FROM maclar;

#Toplama fonksiyonları NULL'u atlar

COUNT(*) satırları sayar. COUNT(sütun) ise o sütunda NULL olmayan değerleri sayar:

SELECT COUNT(*) AS tum_maclar, COUNT(rol) AS rolu_belli FROM maclar;

Aradaki fark, rolü boş üç ARAM maçı. SUM, AVG, MIN ve MAX da NULL'ları görmezden gelir.

NULL bölümündeki <> tuzağını da şimdi sayılarla görebilirsin. Rolü orta olan 5 maç var; demek ki rolü orta olmayan 15 maç olmalı:

SELECT COUNT(*) AS orta_olmayanFROM maclarWHERE rol <> 'orta';

12 geldi: üç ARAM maçında NULL <> 'orta' bilinmiyor çıktı ve elendi. ARAM maçlarını da saymak istiyorsan bunu açıkça söylemelisin:

SELECT COUNT(*) AS orta_olmayanFROM maclarWHERE rol <> 'orta' OR rol IS NULL;

#Tam sayı bölmesi

Ders 33'ün sonunda gördüğün tuzak, KDA hesaplarken kesin karşına çıkacak: JavaScript'te 7 / 2 sonucu 3.5'ti, SQL'de ise iki tam sayının bölümü yine tam sayıdır ve küsurat atılır.

Orada çözüm sayıyı 7.0 diye yazmaktı. Sütunlarda bunu yapamazsın; kill ve olum tam sayı (integer) sütunları. Onun yerine bölmeden önce 1.0 ile çarparsın:

SELECT 7 / 2 AS tam_bolme, 7 * 1.0 / 2 AS ondalikli;

* 1.0 değeri değiştirmez ama hesabı ondalıklı sayılara taşır; sütunla da aynı çalışır: kill * 1.0 / olum. AVG bunu kendisi yapar; elle bölerken unutma.

SELECT sampiyon, (kill + asist) / olum AS kda FROM maclar;

ERROR:  division by zero

SELECT sampiyon, olum,    ROUND((kill + asist) * 1.0 / NULLIF(olum, 0), 2) AS kdaFROM maclarWHERE oyuncu = 'Ece'ORDER BY id;

#GROUP BY: her oyuncu için ayrı hesap

Her oyuncunun kaç maç oynadığını bilmek istiyorsun. COUNT(*)'un yanına oyuncu yazınca:

SELECT oyuncu, COUNT(*) AS mac_sayisi FROM maclar;

ERROR:  column "maclar.oyuncu" must appear in the GROUP BY clause or be used in an aggregate function

COUNT(*) 20 satırı tek satıra indiriyor. O tek satırın oyuncu hücresine kimin adı yazılacak, Deniz'in mi Ece'nin mi? PostgreSQL tahmin yürütmez, hata verir. Önce satırları oyunculara ayırman gerekiyor:

SELECT oyuncu, COUNT(*) AS mac_sayisi FROM maclar GROUP BY oyuncu;

GROUP BY oyuncu satırları oyuncu adına göre kovalara ayırdı, COUNT(*) her kovayı ayrı saydı ve her kova sonuçta tek satır oldu. Sıraya dikkat et: Mert, Deniz, Ece. GROUP BY sıralamaz; senin ekranında sıra başka olabilir. Sıra istiyorsan yine ORDER BY yazarsın:

SELECT oyuncu, COUNT(*) AS mac_sayisi, SUM(kill) AS toplam_killFROM maclarGROUP BY oyuncuORDER BY oyuncu;

Buradan bir kural çıkıyor: GROUP BY'lı bir sorguda SELECT'e yazdığın her sütun ya GROUP BY'da olmalı ya da bir toplama fonksiyonunun içinde. Sonuçtaki her satır bir kovadır; Deniz kovasının tek bir oyuncu adı vardır, ama tek bir şampiyonu yoktur.

SELECT sampiyon, rol, COUNT(*) AS macFROM maclarGROUP BY sampiyon;

ERROR:  column "maclar.rol" must appear in the GROUP BY clause or be used in an aggregate function

Aynı kalıpla şampiyon istatistiği:

SELECT sampiyon, COUNT(*) AS mac, ROUND(AVG(kill), 1) AS ort_killFROM maclarGROUP BY sampiyonORDER BY mac DESC, sampiyon;

Birden çok sütuna göre de gruplayabilirsin; o zaman her farklı çift ayrı bir kova olur. Her oyuncunun zafer ve yenilgi sayısı:

SELECT oyuncu, sonuc, COUNT(*) AS macFROM maclarGROUP BY oyuncu, sonucORDER BY oyuncu, sonuc;

NULL'lar da kendi kovalarında toplanır. Rol başına maç sayısında ARAM maçları ayrı bir NULL grubu olur; ORDER BY artan sıralamada NULL'u en sona koyar:

SELECT rol, COUNT(*) AS mac FROM maclar GROUP BY rol ORDER BY rol;

Ders 11'de reduce ile bir diziden gruplanmış bir obje çıkarmıştın; biriktiriciyi kurup her elemanı doğru anahtara eklemek birkaç satır sürüyordu. GROUP BY aynı işi tek satırda yapıyor.

#HAVING: grupları süzmek

Şampiyon tablosuna tekrar bak: Annie'nin kill ortalaması 7.0, ama tek maçtan. Tek maçlık bir ortalama şans eseri olabilir. Yalnız en az iki kez oynanan şampiyonları görmek istiyorsun. Bir koşul olduğuna göre WHERE yazarsın:

SELECT sampiyon, COUNT(*) AS macFROM maclarWHERE COUNT(*) >= 2GROUP BY sampiyon;

ERROR:  aggregate functions are not allowed in WHERE

SELECT sampiyon, COUNT(*) AS mac, ROUND(AVG(kill), 1) AS ort_killFROM maclarGROUP BY sampiyonHAVING COUNT(*) >= 2ORDER BY ort_kill DESC, sampiyon;

HAVING grupları süzer: en az iki maçı olan beş şampiyon kaldı. Garen ile Jinx'in ortalaması eşit; sıralamanın sonundaki sampiyon onları alfabetik dizdi.

İkisi aynı sorguda birlikte de kullanılır: önce WHERE satırları süzer, kalanlar gruplanır, sonra HAVING grupları süzer. Bir sonraki bölümdeki sorgu tam olarak bunu yapıyor.

#Sorgu hangi sırayla çalışır?

Şimdi hepsini bir araya getir. ARAM dışındaki maçlarda, en az iki kez oynanan şampiyonlardan kill ortalaması en yüksek iki tanesi:

SELECT sampiyon, COUNT(*) AS mac, ROUND(AVG(kill), 1) AS ort_killFROM maclarWHERE rol IS NOT NULLGROUP BY sampiyonHAVING COUNT(*) >= 2ORDER BY ort_kill DESCLIMIT 2;

Sorguyu yukarıdan aşağı yazıyorsun, ama PostgreSQL onu bu sırayla çalıştırmaz. SELECT en üstte yazılır, oysa beşinci sırada çalışır:

Bu sırayı bilince dersteki hataların çoğu kendiliğinden anlam kazanır:

• WHERE (2) gruplamadan (3) önce çalışır; bu yüzden içine COUNT(*) yazılamaz. Grup koşulu HAVING'e (4) gider.
• SELECT (5), WHERE'den sonra çalışır. AS ile verdiğin takma adlar WHERE çalışırken henüz yoktur. PostgreSQL'de HAVING de takma adı tanımaz; orada da hesabın kendisini (COUNT(*)) yazarsın.
• ORDER BY (6), SELECT'ten sonra çalışır; takma adı (ort_kill) orada rahatça kullanabilirsin.
• LIMIT (7) en sonda çalışır. "İlk 2" her zaman sıralanmış sonucun ilk ikisidir.

SELECT oyuncu, sampiyon, kill + asist AS katkiFROM maclarWHERE katki >= 20;

ERROR:  column "katki" does not exist

SELECT oyuncu, sampiyon, kill + asist AS katkiFROM maclarWHERE kill + asist >= 20ORDER BY katki DESC, sampiyon;

#Sorgularını bir dosyada sakla

Sorgular Neon'un History listesinde de durur, ama asıl yerleri bir dosya: Git'e kaydedilir, istediğin an yeniden çalıştırırsın. Ders 33'teki C:\kod\veritabani klasörünü VS Code'da aç ve iki dosya ekle: dersin başındaki betiği maclar.sql adıyla kaydet, işine yarayan sorguları ders34.sql'e yaz. VS Code .sql uzantısını tanır ve anahtar sözcükleri renklendirir.

1-- Ders 34: maç geçmişini sorgulamak2-- Sorguları Neon'da tek tek çalıştır.3 4-- Deniz'in kazandığı maçlar5SELECT sampiyon, kill, olum, asist6FROM maclar7WHERE oyuncu = 'Deniz'8    AND sonuc = 'zafer'9ORDER BY kill DESC;10 11-- Oyuncu başına maç sayısı ve kill12SELECT oyuncu, COUNT(*) AS mac_sayisi,13    SUM(kill) AS toplam_kill14FROM maclar15GROUP BY oyuncu16ORDER BY oyuncu;17 18-- En az 2 kez oynanan şampiyonlar19SELECT sampiyon, COUNT(*) AS mac,20    ROUND(AVG(kill), 1) AS ort_kill21FROM maclar22GROUP BY sampiyon23HAVING COUNT(*) >= 224ORDER BY ort_kill DESC, sampiyon;

#Sık hatalar

Dersteki hataların çoğunu ilgili bölümlerde gördün. Birkaçı daha; hepsi hata rehberinde de duruyor.

SELECT * FROM maclar ORDER BY kill DESC WHERE oyuncu = 'Ece';

ERROR:  syntax error at or near "WHERE"

SELECT oyuncu, sampion FROM maclar;

ERROR:  column "sampion" does not existHINT:  Perhaps you meant to reference the column "maclar.sampiyon".

SELECT oyuncu, sampiyonFROM maclarWHERE sampiyon = 'Ahri' OR 'Lux';

ERROR:  invalid input syntax for type boolean: "Lux"

#Görevler

Görevleri SQL Editor'de yap; çözümlerini ders34.sql'e de ekleyebilirsin. Her görevde beklenen sonuç var: seninki satır satır aynı olmalı. Önce kendin dene, takılırsan ipuçlarını sırayla aç, çözüme en son bak.

SELECT oyuncu, sampiyon, sure_dkFROM maclarWHERE sure_dk >= 35ORDER BY sure_dk DESC, oyuncu;

SELECT oyuncu, sampiyon, rol, asistFROM maclarWHERE rol IN ('destek', 'orman') AND asist BETWEEN 10 AND 15ORDER BY asist DESC;

SELECT id, oyuncu, sampiyon, rolFROM maclarWHERE sampiyon ILIKE '%ji%' AND rol IS NOT NULLORDER BY tarih DESC;

SELECT id, oyuncu, sampiyon, sonucFROM maclarORDER BY tarih DESCLIMIT 6 OFFSET 6;

SELECT id, oyuncu, sampiyon, sonucFROM maclarORDER BY tarih DESCLIMIT 6 OFFSET 18;

SELECT sampiyon, COUNT(*) AS zafer_sayisi,    ROUND(AVG(sure_dk), 1) AS ort_sure, MIN(sure_dk) AS en_kisaFROM maclarWHERE sonuc = 'zafer'GROUP BY sampiyonORDER BY zafer_sayisi DESC, sampiyonLIMIT 3;

SELECT oyuncu, COUNT(*) AS mac,    ROUND((SUM(kill) + SUM(asist)) * 1.0 / SUM(olum), 2) AS kdaFROM maclarGROUP BY oyuncuHAVING COUNT(*) >= 7ORDER BY kda DESC;

#Kendini sına

SELECT * FROM maclar WHERE rol = NULL;

SELECT sonuc, COUNT(*) FROM maclar;

SELECT oyuncu, COUNT(*) AS zaferFROM maclarWHERE sonuc = 'zafer'GROUP BY oyuncuHAVING COUNT(*) >= 4ORDER BY oyuncu;

SELECT sampiyon, kill + asist AS katkiFROM maclarWHERE katki > 25ORDER BY katki DESC;

SELECT COUNT(*) AS a, COUNT(rol) AS b, SUM(kill) / COUNT(*) AS cFROM maclar;

#Kayıt noktası

C:\kod\veritabani klasörüne maclar.sql ve ders34.sql eklendi. Git'i bu klasörde Ders 33'te başlattın; şimdi yalnız yeni bir kayıt alacaksın. VS Code terminalinde, bu klasördeyken:

Bir sonraki derste veriyi okumakla kalmayıp değiştireceksin: INSERT, UPDATE ve DELETE ile maç ekleyip düzelteceksin, kısıtlarla tabloyu bozuk veriye karşı koruyacaksın ve WHERE'siz bir DELETE'in neden felaket olduğunu güvenli bir ortamda göreceksin.