MySQL Joins, UNION, GROUP BY, HAVING ve İleri SQL

MySQL yalnızca tek bir tablodan satır seçmekle ilgili değildir. Gerçek database çalışması genellikle ilgili tabloların birleştirilmesini, gruplandırılmış sonuçların filtrelenmesini, değerlerin alt sorgulara göre karşılaştırılmasını, verilerin tablolar arasında kopyalanmasını, NULL değerlerinin doğru şekilde işlenmesini ve yeniden kullanılabilir database mantığının yazılmasını gerektirir.

Bu makalede öğrenme yolunda gösterilen gelişmiş MySQL konuları açıklanmaktadır: joins, INNER JOIN, LEFT JOIN, RIGHT JOIN, CROSS JOIN, self join, UNION, UNION ALL, GROUP BY, HAVING, EXISTS, ANY, ALL, INSERT SELECT, CASE, NULL işlevleri, stored procedures, yorumlar ve operators.

Amaç sadece sözdizimini ezberlemek değildir. Amaç, her özelliğin ne zaman kullanılması gerektiğini, nasıl davrandığını ve geliştiricilerin gerçek MySQL sorguları yazarken hangi hatalardan kaçınması gerektiğini anlamaktır.

MySQL Joins

Join, iki veya daha fazla tablodaki satırları, aralarındaki ilgili sütuna göre birleştirmek için kullanılır. İlişkisel databases'da veriler, kopyaları önlemek ve tasarımı temiz tutmak için normalde birden fazla tabloya bölünür. Örneğin müşteriler bir tabloda depolanırken siparişler başka bir tabloda saklanabilir.

Joins olmadan, her tabloyu ayrı ayrı sorgulamanız ve verileri uygulamanızda manuel olarak bağlamanız gerekir. Joins sayesinde MySQL ilgili verileri tek bir sorguda döndürebilir.

İki basit tablomuz olduğunu varsayalım:

customers
+----+---------+
| id | name    |
+----+---------+
| 1  | Adnan   |
| 2  | Noor    |
| 3  | Sara    |
+----+---------+

orders
+----+-------------+--------+
| id | customer_id | total  |
+----+-------------+--------+
| 1  | 1           | 120.00 |
| 2  | 1           | 80.00  |
| 3  | 2           | 50.00  |
+----+-------------+--------+

İlişki açıktır: siparişler.müşteri_id, müşteriler.id'yi ifade eder. Join, her siparişin yanında müşteri adını göstermemize olanak tanır.

SELECT
    customers.name,
    orders.total
FROM customers
JOIN orders
    ON customers.id = orders.customer_id;

ON koşulu MySQL'ya tabloların nasıl ilişkili olduğunu söyler. Doğru bir birleştirme koşulu olmadan sonuç yanlış olabilir veya çok büyük olabilir.

Profesyonel projelerde, raporlarda, kontrol panellerinde, yönetici panellerinde, search sayfalarında, faturalarda, kullanıcı izinlerinde, ürün kataloglarında ve analiz sorgularında joins sürekli olarak kullanılır.

MySQL INNER JOIN

INNER JOIN yalnızca her iki tabloda da eşleşen değerlere sahip satırları döndürür. Bir müşterinin siparişi yoksa bu müşteri sonuçta görünmez. Bir sipariş eksik bir müşteriye atıfta bulunuyorsa bu sipariş de görünmez.

SELECT
    c.id,
    c.name,
    o.id AS order_id,
    o.total
FROM customers AS c
INNER JOIN orders AS o
    ON c.id = o.customer_id;

Burada c ve o tablo takma adlarıdır. Takma adlar, özellikle birden fazla tablo birleştirildiğinde sorguları kısaltır ve okunmasını kolaylaştırır.

Yalnızca ilişkinin her iki tarafında da bulunan kayıtları istediğinizde INNER JOIN'yu kullanın. Yaygın örnekler şunları içerir:

• Mevcut müşterilere ait siparişler.

• Mevcut gönderilere ait yorumlar.

• Mevcut kategorilere ait ürünler.

• Mevcut faturalara ait ödemeler.

MySQL'da türü belirtmeden JOIN yazmak genellikle INNER JOIN anlamına gelir.

MySQL LEFT JOIN

LEFT JOIN, sol tablodaki tüm satırları ve sağ tablodaki eşleşen satırları döndürür. Eşleşme yoksa MySQL, sağ tablo sütunları için NULL değerini döndürür.

Bu, ilgili kayıtlar mevcut olmasa bile ana tablonun her zaman görünmesi gerektiğinde kullanışlıdır.

SELECT
    c.id,
    c.name,
    o.id AS order_id,
    o.total
FROM customers AS c
LEFT JOIN orders AS o
    ON c.id = o.customer_id;

Bu sorgu tüm müşterileri döndürür. Siparişi olan müşteriler sipariş verileriyle birlikte görünecektir. Siparişi olmayan müşteriler yine görünecektir ancak sipariş sütunları NULL'yu içerecektir.

LEFT JOIN genellikle eksik ilgili verileri bulmak için kullanılır. Örneğin, hiç sipariş vermemiş müşterileri bulmak için:

SELECT
    c.id,
    c.name
FROM customers AS c
LEFT JOIN orders AS o
    ON c.id = o.customer_id
WHERE o.id IS NULL;

WHERE o.id IS NULL koşulu yalnızca eşleşen bir sıranın bulunmadığı satırları tutar.

Yaygın bir hata, LEFT JOIN kullanılırken WHERE yan tümcesine sağ tablo filtreleri koymaktır. Örneğin, WHERE o.status = 'paid' yazarsanız sorgu INNER JOIN gibi davranabilir çünkü siparişleri olmayan satırlar NULL değerlerine sahiptir. LEFT JOIN davranışını korumak için, uygun olduğunda isteğe bağlı sağ taraftaki filtreleri AÇIK durumuna getirin.

SELECT
    c.id,
    c.name,
    o.total
FROM customers AS c
LEFT JOIN orders AS o
    ON c.id = o.customer_id
   AND o.status = 'paid';

MySQL RIGHT JOIN

RIGHT JOIN, sağ tablodaki tüm satırları ve sol tablodaki eşleşen satırları döndürür. Eşleşme yoksa MySQL, sol tablo sütunları için NULL değerini döndürür.

SELECT
    c.name,
    o.id AS order_id,
    o.total
FROM customers AS c
RIGHT JOIN orders AS o
    ON c.id = o.customer_id;

Bu sorgu, bazı siparişlerin eşleşen bir müşterisi olmasa bile tüm siparişleri döndürür. Yabancı anahtar kısıtlamalarına sahip iyi tasarlanmış bir database'da bu durumun normalde önlenmesi gerekir.

RIGHT JOIN, SQL için geçerlidir, ancak birçok geliştirici, tablo sırasını değiştirerek onu LEFT JOIN olarak yeniden yazmayı tercih eder. LEFT JOIN'nun okunması genellikle daha kolaydır çünkü ana tablo ilk önce görünür.

SELECT
    c.name,
    o.id AS order_id,
    o.total
FROM orders AS o
LEFT JOIN customers AS c
    ON c.id = o.customer_id;

Bu sürüm genellikle amacı daha net bir şekilde ifade eder: tüm siparişleri iade edin ve mevcut olduğunda müşteri verilerini ekleyin.

MySQL CROSS JOIN

CROSS JOIN, iki tablonun Kartezyen çarpımını döndürür. Bu, ilk tablodaki her satırın ikinci tablodaki her satırla birleştirildiği anlamına gelir.

İlk tablonun 3 satırı ve ikinci tablonun 4 satırı varsa sonuç 12 satır içerecektir.

SELECT
    s.size,
    c.color
FROM sizes AS s
CROSS JOIN colors AS c;

Bu, ürün boyutları ve renkleri, takvim tarihleri ve zaman aralıkları veya bir yapılandırma sistemindeki mevcut seçenekler gibi tüm olası kombinasyonları oluştururken yararlı olabilir.

CROSS JOIN dikkatli kullanılmalıdır. Büyük masalarda çok hızlı bir şekilde büyük bir sonuç yaratabilmektedir. Örneğin 10.000 satırı 10.000 satırla birleştirmek 100.000.000 kombinasyon üretir.

MySQL Kendi Kendine Katılma

Kendi kendine birleştirme, bir tablonun kendisine birleştirildiği bir birleştirmedir. Aynı tablodaki satırlar aynı tablodaki diğer satırlarla ilişkili olduğunda kullanışlıdır.

Yaygın bir örnek, her çalışanın bir yöneticisinin olabileceği çalışanlar tablosudur. Yönetici de aynı masanın çalışanıdır.

SELECT
    e.name AS employee_name,
    m.name AS manager_name
FROM employees AS e
LEFT JOIN employees AS m
    ON e.manager_id = m.id;

Tablo iki kez kullanılır ancak farklı takma adlarla kullanılır: e çalışanlar için ve m yöneticiler için. Takma adlar olmadan MySQL, tablonun hangi sürümünü kastettiğinizi bilemez.

Kendi kendine katılımlar aynı zamanda kategori ağaçları, yönlendirme sistemleri, ebeveyn-çocuk ilişkileri, zincirleme yorumlar, organizasyon yapıları ve hiyerarşik veriler için de kullanılır.

MySQL UNION

UNION, iki veya daha fazla SELECT sorgusunun sonucunu tek bir sonuç kümesinde birleştirir. SELECT ifadeleri aynı sayıda sütun döndürmeli ve sütunlar uyumlu veri türlerine sahip olmalıdır.

SELECT email FROM customers
UNION
SELECT email FROM subscribers;

Bu sorgu, müşterilerden ve abonelerden gelen e-postaların birleştirilmiş bir listesini döndürür. Varsayılan olarak UNION yinelenen satırları kaldırır.

UNION, veriler farklı kaynaklardan geldiğinde ancak tek bir liste olarak görüntülenmesi gerektiğinde kullanışlıdır. Örneğin, etkin kullanıcıları ve davet edilen kullanıcıları, eski siparişleri ve yeni siparişleri veya birden fazla tablodan search sonuçlarını birleştirebilirsiniz.

Nihai sonuçtaki sütun adları genellikle ilk SELECT ifadesinden gelir.

SELECT name AS person_name, email FROM customers
UNION
SELECT full_name, email_address FROM leads;

İkinci SELECT farklı sütun adları kullansa da son çıktı, ilk SELECT'daki takma adları kullanır.

Nihai birleştirilmiş sonucu sıralamanız gerekiyorsa, belirli bir nedenden dolayı alt sorgular kullanmıyorsanız ORDER BY'yu her SELECT'nun içine değil, tam UNION sorgusunun sonuna yerleştirin.

SELECT name, email FROM customers
UNION
SELECT full_name, email_address FROM leads
ORDER BY name;

MySQL UNION ALL

UNION ALL ayrıca birden fazla SELECT sonucunu birleştirir, ancak kopyaları kaldırmaz. Bu, çoğu durumda UNION'dan daha hızlı olmasını sağlar çünkü MySQL'nun yinelenen elemeyi gerçekleştirmesine gerek yoktur.

SELECT email FROM customers
UNION ALL
SELECT email FROM subscribers;

Yinelenen satırlar kabul edilebilir veya anlamlı olduğunda UNION ALL kullanın. Örneğin, farklı tablolardaki günlükleri birleştiriyorsanız tekrarlanan değerler gerçekten ayrı olayları temsil edebilir ve kaldırılmamalıdır.

Pratik bir kural basittir: özellikle benzersiz satırlara ihtiyaç duyduğunuzda UNION kullanın; Tüm satırların tam olarak SELECT ifadelerinden geldiği gibi olmasını istiyorsanız UNION ALL'yu kullanın.

MySQL GROUP BY

GROUP BY, bir veya daha fazla sütunda aynı değere sahip satırları gruplandırır. Genellikle COUNT(), SUM(), AVG(), MIN() ve MAX() gibi toplama işlevleriyle birlikte kullanılır.

Örneğin her müşterinin toplam satış tutarını hesaplamak için:

SELECT
    customer_id,
    SUM(total) AS total_spent
FROM orders
GROUP BY customer_id;

Bu sorgu sipariş başına bir satır döndürmez. Satırlar müşteri_kimliğine göre gruplandırıldığından, müşteri başına bir satır döndürür.

Ayrıca birden çok sütuna göre gruplandırabilirsiniz. Örneğin, duruma göre müşteri başına satış:

SELECT
    customer_id,
    status,
    COUNT(*) AS orders_count,
    SUM(total) AS total_amount
FROM orders
GROUP BY customer_id, status;

GROUP BY, raporlama ve analizde yoğun olarak kullanılmaktadır. Aşağıdaki gibi soruların yanıtlanmasına yardımcı olur:

• Her müşterinin kaç siparişi var?

• Aylık toplam gelir ne kadar?

• Her kategoride kaç gönderi var?

• Bölüm başına ortalama maaş ne kadar?

MySQL katı gruplandırma kurallarıyla çalışırken, MySQL, sütunun işlevsel olarak gruplandırılmış sütuna bağımlı olduğunu belirleyemediği sürece, seçilen her sütun ya GROUP BY'nun parçası olmalı ya da bir toplama işlevi içinde kullanılmalıdır. Bu kural belirsiz sonuçların önlenmesini sağlar.

MySQL HAVING

HAVING gruplandırılmış sonuçları filtreler. WHERE'ya benzer, ancak WHERE gruplandırmadan önce satırları filtrelerken HAVING, aggregation'dan sonraki grupları filtreler.

Örneğin, yalnızca toplam harcaması 1000'in üzerinde olan müşterileri göstermek için:

SELECT
    customer_id,
    SUM(total) AS total_spent
FROM orders
GROUP BY customer_id
HAVING SUM(total) > 1000;

WHERE, SUM(toplam) gibi toplu sonuçlarla aynı şekilde doğrudan kullanılamaz çünkü WHERE, gruplar oluşturulmadan önce çalışır.

Yaygın bir model, normal sıra filtreleri için WHERE ve toplu filtreler için HAVING kullanmaktır:

SELECT
    customer_id,
    COUNT(*) AS paid_orders
FROM orders
WHERE status = 'paid'
GROUP BY customer_id
HAVING COUNT(*) >= 3;

Bu sorguda WHERE öncelikle yalnızca ücretli emirleri tutar. Daha sonra GROUP BY bu ücretli siparişleri müşteriye göre gruplandırır. Son olarak, HAVING yalnızca en az üç ücretli siparişi olan müşterileri tutar.

MySQL EXISTS

EXISTS, bir alt sorgunun en az bir satır döndürüp döndürmediğini kontrol eder. Alt sorgu eşleşen bir kayıt bulursa true değerini döndürür.

Örneğin, en az bir siparişi olan müşterilere ulaşmak için:

SELECT
    c.id,
    c.name
FROM customers AS c
WHERE EXISTS (
    SELECT 1
    FROM orders AS o
    WHERE o.customer_id = c.id
);

Alt sorgu dış sorguya o.customer_id = c.id aracılığıyla bağlanır. Buna ilişkili alt sorgu denir çünkü iç sorgu, dış sorgudaki geçerli satıra bağlıdır.

EXISTS genellikle ilgili satırların değerlerini döndürmek yerine ilgili satırların varlığıyla ilgilendiğinizde kullanılır.

Siparişi olmayan müşterileri bulmak için NOT EXISTS kullanın:

SELECT
    c.id,
    c.name
FROM customers AS c
WHERE NOT EXISTS (
    SELECT 1
    FROM orders AS o
    WHERE o.customer_id = c.id
);

NOT EXISTS, özellikle NULL değerleri NOT IN'in beklenmedik şekilde davranmasına neden olabiliyorsa, genellikle birleşme önleme mantığını ifade etmenin açık ve güvenli bir yoludur.

MySQL ANY

ANY, bir değeri bir alt sorgu tarafından döndürülen herhangi bir değerle karşılaştırır. Alt sorgu sonucundaki en az bir değer için karşılaştırma doğruysa true değerini döndürür.

ANY, =, >, <, >=, <= ve <> gibi operators karşılaştırmasıyla kullanılır.

SELECT
    product_name,
    price
FROM products
WHERE price > ANY (
    SELECT price
    FROM products
    WHERE category_id = 5
);

Bu sorgu, fiyatı kategori 5'teki en az bir ürün fiyatından yüksek olan ürünleri döndürür.

Başka bir örnek: toplamı yüksek öncelikli siparişlerin toplamına eşit olan siparişleri bulun:

SELECT
    id,
    total
FROM orders
WHERE total = ANY (
    SELECT total
    FROM orders
    WHERE priority = 'high'
);

Birçok durumda = ANY IN'e benzer. Ancak ANY daha geneldir çünkü operators farklı karşılaştırmalarla kullanılabilir.

MySQL ALL

ALL, bir değeri bir alt sorgu tarafından döndürülen her değerle karşılaştırır. Yalnızca alt sorgu sonucundaki tüm değerler için karşılaştırma doğruysa true değerini döndürür.

SELECT
    product_name,
    price
FROM products
WHERE price > ALL (
    SELECT price
    FROM products
    WHERE category_id = 5
);

Bu sorgu, fiyatı kategori 5'teki tüm ürün fiyatlarından daha yüksek olan ürünleri döndürür. Başka bir deyişle, ürün fiyatının o kategoride bulunan maksimum fiyattan yüksek olması gerekir.

ALL, mantığın yalnızca bir satıra değil tüm alt sorgu sonucuna göre bir karşılaştırma iletmesi için bir değer gerektirdiğinde kullanışlıdır.

ANY ve ALL güçlüdür ancak dikkatli kullanılmaları gerekir. Çoğu durumda aynı mantık, diğer geliştiricilerin anlaması daha kolay olabilecek MIN(), MAX(), EXISTS veya joinsle yazılabilir.

MySQL INSERT SELECT

INSERT SELECT, SELECT sorgusunun sonucunu kullanarak verileri bir tabloya ekler. Verileri kopyalarken, kayıtları arşivlerken, raporlar oluştururken, seçilen satırları taşırken veya özet tabloları hazırlarken kullanışlıdır.

INSERT INTO archived_orders (order_id, customer_id, total, archived_at)
SELECT
    id,
    customer_id,
    total,
    NOW()
FROM orders
WHERE status = 'completed'
  AND created_at < '2025-01-01';

INSERT listesindeki sütunların, SELECT sorgusu tarafından döndürülen değerlerin sayısı ve uyumlu türleriyle eşleşmesi gerekir.

Aynı yapıya sahip bir tablodan başka bir tabloya da ekleyebilirsiniz:

INSERT INTO customers_backup (id, name, email)
SELECT id, name, email
FROM customers;

INSERT SELECT'yu üretim verileri üzerinde çalıştırmadan önce, tam olarak hangi satırların ekleneceğini doğrulamak için SELECT parçasını tek başına çalıştırmak akıllıca olacaktır.

MySQL CASE

CASE, SQL sorgusunun içine koşullu mantık ekler. Koşullara bağlı olarak farklı değerler döndürmenizi sağlar.

CASE okunabilir etiketler, hesaplanan sütunlar, özel sıralama, koşullu aggregation ve rapor biçimlendirme için kullanışlıdır.

SELECT
    id,
    total,
    CASE
        WHEN total >= 1000 THEN 'High'
        WHEN total >= 500 THEN 'Medium'
        ELSE 'Low'
    END AS order_value
FROM orders;

Bu sorgu order_value adında hesaplanmış bir sütun oluşturur. Değer sipariş toplamına bağlıdır.

CASE, GROUP BY raporlarıyla da kullanılabilir. Örneğin, siparişleri değer düzeyine göre sayın:

SELECT
    CASE
        WHEN total >= 1000 THEN 'High'
        WHEN total >= 500 THEN 'Medium'
        ELSE 'Low'
    END AS value_level,
    COUNT(*) AS orders_count
FROM orders
GROUP BY value_level;

CASE depolanan verileri değiştirmez. Yalnızca sorgu sonucunda değerlerin nasıl döndürüldüğünü değiştirir.

CASE'nun iki yaygın biçimi vardır: aranan CASE ve basit CASE. Aranan CASE tüm koşulları kontrol eder. Basit CASE, bir ifadeyi birden çok değerle karşılaştırır.

SELECT
    id,
    status,
    CASE status
        WHEN 'paid' THEN 'Payment received'
        WHEN 'pending' THEN 'Waiting for payment'
        WHEN 'cancelled' THEN 'Order cancelled'
        ELSE 'Unknown status'
    END AS status_label
FROM orders;

MySQL Boş İşlevler

NULL eksik, bilinmiyor veya uygulanamaz anlamına gelir. Sıfırla, boş bir dizeyle veya false ile aynı şey değildir. NULL bilinmeyen bir değeri temsil ettiğinden normal karşılaştırmalar yeni başlayanların beklediğinden farklı davranabilir.

Örneğin şu koşul yanlıştır:

SELECT * FROM users
WHERE deleted_at = NULL;

NULL'yu kontrol etmek için IS NULL veya IS NOT NULL kullanın:

SELECT * FROM users
WHERE deleted_at IS NULL;

MySQL, NULL değerleriyle çalışmak için çeşitli işlevler sağlar.

IFNULL(), ilk değer NULL olduğunda alternatif bir değer döndürür:

SELECT
    name,
    IFNULL(phone, 'No phone number') AS phone_display
FROM customers;

COALESCE(), listeden NULL olmayan ilk değeri döndürür. Birkaç geri dönüş değerinin mümkün olduğu durumlarda kullanışlıdır:

SELECT
    name,
    COALESCE(work_phone, mobile_phone, home_phone, 'No phone') AS contact_phone
FROM customers;

NULLIF(), iki ifade eşitse NULL değerini döndürür; aksi takdirde ilk ifadeyi döndürür:

SELECT
    product_name,
    NULLIF(discount_price, regular_price) AS real_discount_price
FROM products;

NULL değerlerinin göz ardı edilmesi veya yanlış işlenmesi durumunda toplu hesaplamalar ve görüntüleme değerleri kafa karıştırıcı hale gelebileceğinden, raporlarda boş işlevler önemlidir.

MySQL Saklı Prosedürler

Saklı prosedür, database içinde saklanan yeniden kullanılabilir bir SQL kod bloğudur. Uygulamadan her seferinde aynı SQL mantığını göndermek yerine prosedürü ismine göre çağırabilirsiniz.

Saklı prosedürler parametreleri kabul edebilir, birden fazla ifadeyi yürütebilir, değişkenleri kullanabilir, koşullu mantık içerebilir ve sonuç kümelerini döndürebilir.

DELIMITER //

CREATE PROCEDURE GetCustomerOrders(IN customerId INT)
BEGIN
    SELECT
        id,
        total,
        status,
        created_at
    FROM orders
    WHERE customer_id = customerId
    ORDER BY created_at DESC;
END //

DELIMITER ;

Prosedürü oluşturduktan sonra şu şekilde çağırabilirsiniz:

CALL GetCustomerOrders(1);

Yordam gövdesi noktalı virgül içerdiğinden, birçok MySQL istemcisinde DELIMITER komutu kullanılır. Sınırlayıcının geçici olarak değiştirilmesi, tüm prosedür tanımının tek bir ifade olarak ele alınmasına olanak tanır.

Saklı prosedürler database tarafı işlemleri, tekrarlanan raporlama mantığı, eski sistemler ve belirli işlemlere kontrollü erişim için yararlı olabilir. Ancak temiz uygulama mimarisinin yerini alacak şekilde aşırı kullanılmamalıdırlar. Birçok modern web uygulamasında business logic çoğunlukla uygulama katmanında tutulurken stored procedures yalnızca net bir fayda sağladığında kullanılır.

Çıkış parametresine sahip bir saklı prosedür şöyle görünebilir:

DELIMITER //

CREATE PROCEDURE CountCustomerOrders(
    IN customerId INT,
    OUT ordersCount INT
)
BEGIN
    SELECT COUNT(*)
    INTO ordersCount
    FROM orders
    WHERE customer_id = customerId;
END //

DELIMITER ;

CALL CountCustomerOrders(1, @count);
SELECT @count AS orders_count;

MySQL Yorumlar

Yorumlar SQL kodunun içine yazılan notlardır. MySQL yürütme sırasında bunları yok sayar. Karmaşık sorguların, document kararlarının açıklanmasına veya test sırasında bir sorgunun bir kısmının geçici olarak devre dışı bırakılmasına yardımcı olurlar.

MySQL, -- veya # kullanarak tek satırlık yorumları destekler:

-- Get active customers only
SELECT *
FROM customers
WHERE status = 'active';

# This is also a single-line comment
SELECT COUNT(*) FROM orders;

MySQL ayrıca /*... */ kullanılarak çok satırlı yorumları da destekler:

/*
  This query calculates total revenue
  from paid orders only.
*/
SELECT
    SUM(total) AS revenue
FROM orders
WHERE status = 'paid';

Yorumlar bir şeyin neden yapıldığını açıklamalı, SQL'nun zaten söylediklerini tekrarlamamalıdır. İyi yorumlar karmaşık joinsde, raporlarda, geçişlerde ve bakım komut dosyalarında faydalıdır.

MySQL Operatörleri

Operatörler hesaplamaları, karşılaştırmaları, mantıksal koşulları ve model eşleştirmeyi gerçekleştirmek için kullanılan semboller veya anahtar sözcüklerdir. Bunlar neredeyse her SQL sorgusunun parçasıdır.

Hesaplamalar için aritmetik operators kullanılır:

SELECT
    price,
    quantity,
    price * quantity AS line_total
FROM order_items;

Yaygın aritmetik operators şunları içerir: +, -, *, / ve %.

Karşılaştırma operators karşılaştırma değerleri:

SELECT *
FROM products
WHERE price >= 100
  AND stock <> 0;

Yaygın karşılaştırma operators şunları içerir: =, <>,!=, >, <, >= ve <=.

Mantıksal operators koşulları birleştirme:

SELECT *
FROM orders
WHERE status = 'paid'
  AND total > 500;

En yaygın mantıksal operators, AND, OR ve NOT'tur. Açık olmayan mantıktan kaçınmak için AND ve OR birleştirirken parantez kullanılmalıdır.

SELECT *
FROM orders
WHERE status = 'paid'
  AND (total > 500 OR priority = 'high');

Desen ve aralık operators esnek filtreleme için kullanılır:

SELECT *
FROM customers
WHERE name LIKE 'A%'
  AND city IN ('Istanbul', 'Samsun', 'Ankara')
  AND created_at BETWEEN '2025-01-01' AND '2025-12-31';

Önemli SQL operators ve ifadeler şunları içerir: LIKE, IN, BETWEEN, IS NULL, IS NOT NULL, EXISTS, ANY, ve ALL.

MySQL ayrıca NULL-güvenli eşitliği operator <=> destekler. NULL dahil olduğunda bile değerleri karşılaştırabilir:

SELECT *
FROM users
WHERE deleted_at <=> NULL;

Normal uygulama sorgularında IS NULL genellikle daha açıktır. Ancak NULL-güvenli operator bazı karşılaştırma ve senkronizasyon senaryolarında kullanışlıdır.

Bu MySQL Özellikleri Birlikte Nasıl Çalışır?

Gerçek uygulamalarda bu özellikler nadiren tek başına kullanılır. Bir rapor sorgusu birden fazla tabloyu birleştirebilir, sonuçları gruplayabilir, HAVING ile toplanan değerleri filtreleyebilir, COALESCE ile NULL değerlerini işleyebilir ve CASE ile satırları sınıflandırabilir.

Aşağıdaki örnek, çeşitli kavramları tek bir pratik raporda birleştirir:

SELECT
    c.id,
    c.name,
    COALESCE(c.city, 'Unknown') AS city,
    COUNT(o.id) AS orders_count,
    SUM(CASE WHEN o.status = 'paid' THEN o.total ELSE 0 END) AS paid_total,
    CASE
        WHEN SUM(CASE WHEN o.status = 'paid' THEN o.total ELSE 0 END) >= 5000 THEN 'VIP'
        WHEN COUNT(o.id) >= 5 THEN 'Regular'
        ELSE 'New'
    END AS customer_level
FROM customers AS c
LEFT JOIN orders AS o
    ON c.id = o.customer_id
GROUP BY
    c.id,
    c.name,
    c.city
HAVING paid_total > 0
ORDER BY paid_total DESC;

Bu sorgu, ücretli sipariş etkinliği olan müşterileri döndürür, şehirlerini bir yedek değerle gösterir, siparişlerini sayar, ödenen geliri hesaplar ve bir müşteri düzeyi atar. LEFT JOIN, GROUP BY, HAVING, COALESCE, CASE, COUNT(), SUM(), takma adları ve sıralamayı kullanır.

Bu, kontrol panellerinde, CRM sistemlerinde, analiz sayfalarında, e-ticaret yönetici panellerinde ve finansal raporlarda görünen sorgu türüdür.

Performans ve En İyi Uygulamalar

Gelişmiş SQL özellikleri güçlüdür ancak dikkatli bir şekilde yazılmaları gerekir. database büyürse bir sorgu mantıksal olarak doğru olmasına rağmen yine de kötü performans gösterebilir.

Önemli uygulamalar şunları içerir:

• Uygun olduğunda birleştirme sütunlarında, filtre sütunlarında ve sıklıkla gruplanan sütunlarda indexes kullanın.

• Birleşimler için daima AÇIK koşullarını açıkça yazın.

• Her sütuna gerçekten ihtiyacınız olmadığı sürece raporlarda ve birleştirilmiş sorgularda SELECT * kullanmaktan kaçının.

• Yinelenen kopyaların kaldırılması gerekmediğinde UNION yerine UNION ALL kullanın.

• GROUP BY uygulanacak satır sayısını azaltmak için GROUP BY’dan önce WHERE kullanın.

• HAVING'yu yalnızca toplu sonuçlara bağlı koşullar için kullanın.

• SELECT sorgularını INSERT SELECT içinde kullanmadan önce test edin.

• Okunabilirliği artırmak için takma adları tutarlı bir şekilde kullanın.

• MySQL'nun önemli sorguları nasıl yürütmeyi planladığını incelemek için EXPLAIN'i kullanın.

Okunabilir SQL aynı zamanda profesyonel bir beceridir. İyi biçimlendirilmiş, anlamlı takma adlar kullanan ve mantığı açıkça ayıran bir sorgunun hata ayıklaması, optimize edilmesi ve bakımı daha kolay olacaktır.

Sonuç

MySQL joinsi ve gelişmiş SQL özellikleri, gerçek database odaklı uygulamalar oluşturmak için gereklidir. INNER JOIN, LEFT JOIN, RIGHT JOIN, CROSS JOIN ve kendi kendine joins, ilgili verilerin birleştirilmesine yardımcı olur. UNION ve UNION ALL, birden çok SELECT sorgusunun sonuçlarını birleştirir. GROUP BY ve HAVING, raporlamayı ve aggregation'yu mümkün kılar.

EXISTS, ANY ve ALL daha gelişmiş alt sorgu mantığına olanak tanır. INSERT SELECT, verilerin tablolar arasında kopyalanmasına ve dönüştürülmesine yardımcı olur. CASE koşullu çıktı ekler. NULL işlevleri eksik değerleri daha güvenli ve net hale getirir. Saklı prosedürler yeniden kullanılabilir database tarafı mantığı sağlar. Yorumlar sürdürülebilirliği artırır ve operators filtreleme, karşılaştırma ve hesaplamanın temelini oluşturur.

MySQL konusunda uzmanlaşmak için bu konuları gerçek tablolarla ve gerçekçi verilerle uygulayın. Basit joinsle başlayın, ardından adım adım gruplandırmayı, filtrelemeyi, CASE ifadelerini ve alt sorguları ekleyin. Bu özelliklerin birlikte nasıl çalıştığını ne kadar çok anlarsanız, gerçek projeler için temiz, doğru ve verimli SQL yazmak o kadar kolay olur.