SQLite Self Join: Tabloyu Kendisiyle Birleştirme

Self Join Aslında Alias'lı Bir Join'dir

Self join'in aslında özel bir tarafı yok. Sıradan bir JOIN işlemi, sadece iki tarafın da aynı tablo olduğu bir durum. İşin püf noktası şu: SQLite'ın bu iki kopyayı birbirinden ayırt edebilmesi gerekiyor, bu yüzden her birine bir alias veriyorsunuz.

Bu yönteme, bir tablodaki bir satırın aynı tablodaki başka bir satıra referans verdiği durumlarda başvurursunuz. En klasik örnek: her satırın başka bir çalışana işaret eden manager_id alanına sahip olduğu bir employees tablosu:

CREATE TABLE employees (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    manager_id INTEGER REFERENCES employees(id)
);

INSERT INTO employees (id, name, manager_id) VALUES
    (1, 'Ada',   NULL),
    (2, 'Boris', 1),
    (3, 'Cleo',  1),
    (4, 'Diego', 2),
    (5, 'Esme',  2);

SELECT * FROM employees;

Ada'nın yöneticisi yok. Boris ve Cleo, Ada'ya bağlı çalışıyor. Diego ile Esme ise Boris'e raporluyor. Bu hiyerarşi tamamen tek bir tablonun içinde duruyor — işte tam da bu noktada self join devreye giriyor ve değerini gösteriyor.

Self Join Söz Dizimi: Temel Yapı

Her çalışanı kendi yöneticisinin adıyla eşleştirmek için employees tablosunu kendisiyle birleştiriyoruz. Bir kopya "çalışan" rolünü üstlenirken diğeri "yönetici" rolünü oynuyor:

CREATE TABLE employees (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    manager_id INTEGER REFERENCES employees(id)
);

INSERT INTO employees (id, name, manager_id) VALUES
    (1, 'Ada',   NULL),
    (2, 'Boris', 1),
    (3, 'Cleo',  1),
    (4, 'Diego', 2),
    (5, 'Esme',  2);

SELECT
    e.name AS employee,
    m.name AS manager
FROM employees AS e
INNER JOIN employees AS m
    ON e.manager_id = m.id;

İki ayrı tablo gibi düşün; sadece aynı yerde duruyorlar. e çalışan satırını, m ise yönetici satırını temsil ediyor. Birleştirme koşulu olan e.manager_id = m.id ikisini eşliyor: her çalışan için m tarafında id değeri o çalışanın manager_id'sine denk gelen satırı buluyor.

Dikkat ederseniz Ada sonuçta yok. Çünkü manager_id değeri NULL ve INNER JOIN eşleşmeyen satırları eliyor.

Eşleşmeyen Satırları Korumak: LEFT JOIN

Yöneticisi olmayanlar dahil herkesi sonuçta görmek istiyorsanız LEFT JOIN'e geçmeniz yeterli:

CREATE TABLE employees (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    manager_id INTEGER REFERENCES employees(id)
);

INSERT INTO employees (id, name, manager_id) VALUES
    (1, 'Ada',   NULL),
    (2, 'Boris', 1),
    (3, 'Cleo',  1),
    (4, 'Diego', 2),
    (5, 'Esme',  2);

SELECT
    e.name AS employee,
    m.name AS manager
FROM employees AS e
LEFT JOIN employees AS m
    ON e.manager_id = m.id
ORDER BY e.id;

Artık Ada da listede görünüyor; yönetici sütununda NULL var. Self join mantığı aynı, sadece join tipi LEFT JOIN'in her zaman yaptığı şeyi yapıyor: sol taraftaki tüm satırları koruyor, eşleşme olmayan yerleri boş bırakıyor.

Bir kişi listesi gösteriyorsanız, genelde tam olarak bu davranışı istersiniz. "Yöneticisi yok" bilgisi de bir bilgidir; o satırı tamamen düşürmek olmaz.

Alias Kullanmak Zorunlu

Aynı sorguyu alias'sız yazmaya kalkarsanız SQLite ne demek istediğinizi anlayamaz:

SELECT name, manager_id FROM employees JOIN employees ON manager_id = id;
-- Hata: belirsiz sütun adı: name

Her sütun iki kez görünür — tablonun her bir kopyasından bir tane — ve SQLite hangisini seçeceğini bilemez. İşte tam burada alias'lar devreye girer ve her örneğe kendi adını vererek bu karmaşayı çözer. Alias seçerken tablo adını değil, satırın oynadığı rolü düşünün:

• Çalışan/yönetici için e ve m.
• Hiyerarşiler için parent ve child.
• Rastgele çiftleri karşılaştırırken a ve b.

Bir self join'in temiz okunmasının asıl sebebi zaten alias'tır.

Aynı Tablodaki Satır Çiftlerini Bulma

Self join sadece hiyerarşiler için değildir. Aynı tablodaki satırları karşılaştırmak istediğiniz her durumda bu kalıp işinize yarar. Aşağıda bir ürün listesi var; amacımız aynı fiyata sahip tüm ürün çiftlerini bulmak:

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

INSERT INTO products (name, price) VALUES
    ('Kupa',     9.99),
    ('Defter', 9.99),
    ('Kalem',     2.50),
    ('Kurşun Kalem',  2.50),
    ('Lamba',   29.00);

SELECT a.name AS product_a, b.name AS product_b, a.price
FROM products AS a
INNER JOIN products AS b
    ON a.price = b.price
   AND a.id < b.id;

Dikkat etmemiz gereken iki nokta var. Birincisi, asıl eşleştirme koşulu a.price = b.price. İkincisi ise a.id < b.id kısmı; bu da sorgunun her çifti iki kez döndürmesini (önce (Kupa, Defter), sonra (Defter, Kupa) olarak) ve her satırı kendisiyle eşleştirmesini engelliyor. O < numarasını aklınızın bir köşesinde tutun — çift listelemeniz gereken her durumda işinize yarayacak.

Hiyerarşide İki Seviye Yukarı Çıkmak

Tek bir self join, hiyerarşide tek bir adım atmanızı sağlar. Peki ya her çalışanın "yöneticisinin yöneticisini" bulmak isterseniz? O zaman üç kere join yapmanız gerekir:

CREATE TABLE employees (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    manager_id INTEGER REFERENCES employees(id)
);

INSERT INTO employees (id, name, manager_id) VALUES
    (1, 'Ada',   NULL),
    (2, 'Boris', 1),
    (3, 'Cleo',  1),
    (4, 'Diego', 2),
    (5, 'Esme',  2);

SELECT
    e.name      AS employee,
    m.name      AS manager,
    gm.name     AS grand_manager
FROM employees AS e
LEFT JOIN employees AS m  ON e.manager_id = m.id
LEFT JOIN employees AS gm ON m.manager_id = gm.id
ORDER BY e.id;

Her yeni alias, ağaçta bir kademe daha yukarı çıkmak demek. İki ya da üç seviye için iş görür ama ondan sonrası çorba olur — sorguyu yazarken hiyerarşinin kaç seviye derin olduğunu bilmeniz ve her seviye için ayrı bir join eklemeniz gerekir. İşte tam da bu duvarı yıkmak için recursive CTE'ler icat edildi.

Self Join Kullanmamanız Gereken Durumlar

Self join, ilişkinin iki tarafından da sütunlara ihtiyaç duyduğunda doğru araçtır. Ama yalnızca filtreleme yapacaksanız — mesela yöneticisi Ada olan tüm çalışanları bulmak gibi — alt sorgu (subquery) genelde daha okunaklı durur:

CREATE TABLE employees (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    manager_id INTEGER REFERENCES employees(id)
);

INSERT INTO employees (id, name, manager_id) VALUES
    (1, 'Ada',   NULL),
    (2, 'Boris', 1),
    (3, 'Cleo',  1),
    (4, 'Diego', 2),
    (5, 'Esme',  2);

SELECT name
FROM employees
WHERE manager_id = (SELECT id FROM employees WHERE name = 'Ada');

No alias cambazlığı yok, niyet de gayet net. Pratik bir kural: çıktıda her iki satırdan da veri görmek istiyor musun? O zaman self join. Yalnızca karşılaştıracağın bir değer mi lazım? O zaman subquery.

Derinliği belirsiz hiyerarşilerde (organizasyon şemaları, dosya ağaçları, iç içe yorumlar) iki yaklaşım da ölçeklenmez. Orası artık recursive CTE'nin sahası.

Sırada: Subquery'ler

Self join ve subquery'ler benzer problemleri çözer; hangisinin nereye uyduğunu bilmek, ileride SQL'e gözlerini kısarak bakmaktan seni kurtarır. Bir sonraki sayfada subquery'leri enine boyuna ele alacağız — scalar, correlated ve IN biçimleriyle birlikte, hangisinin nerede parladığını da göreceksiniz.