SQLite Sorgu: Seç, Nerede, LİMİT, OFSET, Sayım, Gruplandırma Ölçütü

Aşağıdaki bölümlerde, SELECT ve FROM ile veri okuma, WHERE ve operatörleriyle satırları filtreleme, sonuçları sıralama ve sınırlandırma, toplama fonksiyonları, GROUP BY ve HAVING, alt sorgular, küme işlemleri, NULL işleme, CASE ifadeleri ve yaygın tablo ifadeleri ele alınmaktadır.

Yazmak SQL sorguları bir bölgesindeki SQLite veritabanında SELECT, FROM, WHERE, GROUP BY, ORDER BY ve LIMIT cümleciklerinin nasıl çalıştığını ve bunların nasıl kullanılacağını bilmeniz gerekir.

Bu eğitim sırasında bu cümleciklerin nasıl kullanılacağını ve nasıl yazılacağını öğreneceksiniz. SQLite maddeleri.

Seçimle Veri Okuma

SELECT yan tümcesi bir sorguyu sorgulamak için kullandığınız ana ifadedir. SQLite veri tabanı. SELECT yan tümcesinde neyi seçeceğinizi belirtirsiniz. Ancak select deyiminden önce FROM deyimini kullanarak verileri nereden seçebileceğimize bakalım.

FROM ifadesi, verileri nereden seçmek istediğinizi belirtmek için kullanılır. From ifadesinde, eğitimlerde daha sonra göreceğimiz gibi, verileri seçmek için bir veya daha fazla tablo veya alt sorgu belirtebilirsiniz.

Aşağıdaki tüm örnekler için sqlite3.exe'yi çalıştırmanız ve örnek veritabanına aşağıdaki gibi bir bağlantı açmanız gerektiğini unutmayın:

) 1 Adım Bu adımda,

Bilgisayarım'ı açın ve "C:\sqlite" dizinine gidin, ardından "sqlite3.exe" dosyasını açın:

) 2 Adım Aşağıdaki komutu kullanarak “TutorialsSampleDB.db” veritabanını açın:

Artık veritabanında her türlü sorguyu çalıştırmaya hazırsınız.

SELECT ifadesinde yalnızca bir sütun adı seçemezsiniz, aynı zamanda neyi seçeceğinizi belirtmek için birçok başka seçeneğiniz de vardır. Aşağıdaki gibi:

SEÇ *

Bu komut, FROM yan tümcesinde başvurulan tüm tablolardan (veya alt sorgulardan) tüm sütunları seçecektir. Örneğin:

SELECT *
FROM Students
INNER JOIN Departments ON Students.DepartmentId = Departments.DepartmentId;

Bu, hem öğrenci tablolarındaki hem de bölüm tablolarındaki tüm sütunları seçecektir:

Tablo adını SEÇİN.*

Bu, yalnızca “tablo adı” tablosundaki tüm sütunları seçecektir. Örneğin:

SELECT Students.*
FROM Students
INNER JOIN Departments ON Students.DepartmentId = Departments.DepartmentId;

Bu, yalnızca öğrenciler tablosundaki tüm sütunları seçecektir:

Gerçek bir değer

Değişmez değer, select ifadesinde belirtilebilen sabit bir değerdir. Değişmez değerleri normalde SELECT yan tümcesinde sütun adlarını kullandığınız şekilde kullanabilirsiniz. Bu değişmez değerler, SQL sorgusunun döndürdüğü satırlardaki her satır için görüntülenecektir.

Seçebileceğiniz farklı değişmez değerlerin bazı örnekleri şunlardır:

• Sayısal Değişmez – 1, 2.55 vb. gibi herhangi bir formattaki sayılar.
• Dize değişmezleri – Herhangi bir dize 'ABD', 'bu bir örnek metindir' vb.
• NULL – NULL değeri.
• Current_TIME – Size şu anki saati verecektir.
• CURRENT_DATE – bu size geçerli tarihi verecektir.

Bu, döndürülen tüm satırlar için sabit bir değer seçmeniz gereken bazı durumlarda kullanışlı olabilir. Örneğin, Öğrenciler tablosundan tüm öğrencileri “ABD” değerini içeren ülke adı verilen yeni bir sütunla seçmek istiyorsanız şunu yapabilirsiniz:

SELECT *, 'USA' AS Country FROM Students;

Bu size tüm öğrencilerin sütunlarını ve ayrıca şunun gibi yeni bir "Ülke" sütununu verecektir:

Bu yeni Ülke sütununun aslında tabloya eklenen yeni bir sütun olmadığını unutmayın. Sonuçları görüntülemek için sorguda oluşturulan sanal bir sütundur ve tabloda oluşturulmayacaktır.

İsimler ve Takma Adlar

Takma ad, sütunu yeni bir adla seçmenizi sağlayan yeni bir sütun adıdır. Sütun takma adları “AS” anahtar sözcüğü kullanılarak belirtilir.

Örneğin, ÖğrenciAdı sütununun "ÖğrenciAdı" yerine "Öğrenci Adı" ile döndürülmesini istiyorsanız ona şu şekilde bir takma ad verebilirsiniz:

SELECT StudentName AS 'Student Name' FROM Students;

Bu size aşağıdaki gibi "ÖğrenciAdı" yerine "Öğrenci Adı" adlı öğrencilerin adlarını verecektir:

Dikkat edin, sütun adı hala "StudentName"; StudentName sütunu hala aynı, takma adla değişmiyor.

Takma ad, sütun adını değiştirmez; yalnızca SELECT yan tümcesindeki görünen adı değiştirecektir.

Ayrıca, "AS" anahtar sözcüğünün isteğe bağlı olduğunu unutmayın; takma adı bu olmadan da koyabilirsiniz, buna benzer bir şey:

SELECT StudentName 'Student Name' FROM Students;

Ve size önceki sorguyla tamamen aynı çıktıyı verecektir:

Yalnızca sütunlar değil, tablolara takma adlar da verebilirsiniz. Aynı anahtar kelime olan “AS” ile. Örneğin şunu yapabilirsiniz:

SELECT s.* FROM Students AS s;

Bu size Öğrenciler tablosundaki tüm sütunları verecektir:

Bu, birden fazla tabloyu birleştiriyorsanız çok yararlı olabilir; sorguda tam tablo adını tekrarlamak yerine, her tabloya kısa bir takma ad verebilirsiniz. Örneğin, aşağıdaki sorguda:

SELECT Students.StudentName, Departments.DepartmentName
FROM Students
INNER JOIN Departments ON Students.DepartmentId = Departments.DepartmentId;

Bu sorgu, her öğrencinin adını “Öğrenciler” tablosundan, bölüm adını ise “Bölümler” tablosundan seçecektir:

Ancak aynı sorgu şu şekilde de yazılabilir:

SELECT s.StudentName, d.DepartmentName
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Öğrenciler tablosuna “s”, bölümler tablosuna ise “d” takma adını verdik. Daha sonra, tabloların tam adlarını kullanmak yerine, onlara atıfta bulunmak için takma adlarını kullandık. INNER JOIN, bir koşul kullanarak iki veya daha fazla tabloyu birleştirir. Örneğimizde, Öğrenciler tablosunu Bölümler tablosuyla BölümId sütunu üzerinden birleştirdik. INNER JOIN hakkında daha ayrıntılı bir açıklama da “SQLite Katıldı” öğretici.

Bu size önceki sorgudakinin tam çıktısını verecektir:

NEREDE

Önceki bölümde gördüğümüz gibi FROM cümlesiyle birlikte yalnızca SELECT cümleciğini kullanarak SQL sorguları yazmak, tablolardaki tüm satırları size verecektir. Ancak döndürülen verileri filtrelemek istiyorsanız “WHERE” ifadesini eklemeniz gerekir.

WHERE yan tümcesi, SQL sorgusunun döndürdüğü sonuç kümesini filtrelemek için kullanılır. WHERE yan tümcesinin çalışma şekli şöyledir:

• WHERE yan tümcesinde bir “ifade” belirtebilirsiniz.
• Bu ifade, FROM yan tümcesinde belirtilen tablolardan döndürülen her satır için değerlendirilecektir.
• İfade, sonucu doğru, yanlış veya boş olan bir Boolean ifadesi olarak değerlendirilecektir.
• Daha sonra yalnızca ifadenin doğru değerle değerlendirildiği satırlar döndürülecek ve yanlış veya boş sonuçları olan satırlar göz ardı edilecek ve sonuç kümesine dahil edilmeyecektir.

WHERE yan tümcesini kullanarak sonuç kümesini filtrelemek için ifadeleri ve işleçleri kullanmanız gerekir.

Operatörlerin listesi SQLite ve nasıl kullanılacağını

Aşağıdaki bölümde ifade ve operatörleri kullanarak nasıl filtreleme yapabileceğinizi anlatacağız.

İfade, bir operatörle birbiriyle birleştirilen bir veya daha fazla değişmez değer veya sütundur.

İfadeleri hem SELECT yan tümcesinde hem de WHERE yan tümcesinde kullanabileceğinizi unutmayın.

Aşağıdaki örneklerde, hem select ifadesindeki hem de WHERE ifadesindeki ifadeleri ve operatörleri deneyeceğiz. Bunların nasıl performans gösterdiğini size göstermek için.

Aşağıdaki gibi belirtebileceğiniz farklı türde ifadeler ve operatörler vardır:

SQLite birleştirme operatörü “||”

Bu operatör, bir veya daha fazla değişmez değeri veya sütunu birbiriyle birleştirmek için kullanılır. Birleştirilmiş tüm değişmez değerlerden veya sütunlardan bir sonuç dizisi üretecektir. Örneğin:

SELECT 'Id with Name: '|| StudentId || StudentName AS StudentIdWithName
FROM Students;

Bu, "StudentIdWithName" adında yeni bir takma ad oluşturmak üzere birleştirilecektir:

• "İsimli Kimlik: " dizesinin tam değeri
• “StudentId” sütunundaki değer ile
• “Öğrenci Adı” sütunundaki değerle

SQLite CAST operatörü:

CAST operatörü, bir değeri bir başka değere dönüştürmek için kullanılır. veri tipi başka bir veri türüne.

Örneğin, "'12.5'" gibi bir dize değeri olarak saklanmış sayısal bir değeriniz varsa ve bunu sayısal bir değere dönüştürmek istiyorsanız, bunu "CAST('12.5' ​​AS REAL)" şeklinde CAST operatörünü kullanarak yapabilirsiniz. Veya 12.5 gibi ondalık bir değeriniz varsa ve yalnızca tam sayı kısmını elde etmeniz gerekiyorsa, bunu "CAST(12.5 AS INTEGER)" şeklinde tam sayıya dönüştürebilirsiniz.

Örnek E-posta

Aşağıdaki komutta farklı değerleri diğer veri tiplerine dönüştürmeye çalışacağız:

SELECT CAST('12.5' AS REAL) ToReal, CAST(12.5 AS INTEGER) AS ToInteger;

Bu size şunları sağlayacaktır:

Sonuç şu şekilde:

• CAST('12.5' ​​AS REAL) – '12.5' ​​değeri bir dize değeridir, REAL değerine dönüştürülecektir.
• CAST(12.5 AS TAM SAYI) – 12.5 değeri ondalık bir değerdir, bir tamsayı değerine dönüştürülür. Ondalık kısım kesilecek ve 12 olacak.

SQLite Aritmetik Operator:

İki veya daha fazla sayısal sabit değer veya sayısal sütun alın ve bir sayısal değer döndürün. Desteklenen aritmetik operatörler SQLite şunlardır:

• Toplama işlemi “+” – iki işlemin toplamını verir.
• Alttraction “–” – alttracİki işleneni birbirine bağlar ve aradaki farkı bulur.
• Çarpma işlemi “*” – iki işlemin çarpımı.
• Kalan (modül) “%” – bir işlenenin ikinci işlenene bölünmesinden elde edilen kalanı verir.
• Bölme işlemi “/” – sol işleneni sağ işlenene bölmenin sonucunu döndürür.

Örnek:

Aşağıdaki örnekte, aynı SELECT sorgusunda beş aritmetik operatörü sayısal değerlerle deneyeceğiz:

SELECT 25+6, 25-6, 25*6, 25%6, 25/6;

Bu size şunları sağlayacaktır:

Burada FROM yan tümcesi olmadan bir SELECT ifadesini nasıl kullandığımıza dikkat edin. Ve buna izin veriliyor SQLite değişmez değerleri seçtiğimiz sürece.

SQLite Karşılaştırma operatörleri

İki işleneni birbiriyle karşılaştırın ve aşağıdaki gibi doğru veya yanlış değerini döndürün:

• “<” operatörü, sol işlenen sağ işlenenden küçükse doğru (true) değerini döndürür.
• “<=" operatörü, sol işlenen sağ işlenenden küçük veya eşitse true değerini döndürür.
• “>” operatörü, sol işlenen sağ işlenenden büyükse doğru (true) değerini döndürür.
• “>=" operatörü, sol işlenen sağ işlenenden büyük veya eşitse true değerini döndürür.
• "=" ve "==" operatörleri, iki işlenen eşitse true değerini döndürür. Her iki operatörün de aynı olduğunu ve aralarında hiçbir fark olmadığını unutmayın.
• “!=" ve “<>” operatörleri, iki işlenen eşit değilse true değerini döndürür. Her iki operatörün de aynı olduğunu ve aralarında hiçbir fark olmadığını unutmayın.

Dikkat, SQLite 1 ile doğru değeri, 0 ile yanlış değeri ifade eder.

Örnek:

SELECT
  10<6 AS '<', 10<=6 AS '<=',
  10>6 AS '>', 10>=6 AS '>=',
  10=6 AS '=', 10==6 AS '==',
  10!=6 AS '!=', 10<>6 AS '<>';

Bu şöyle bir şey verecektir:

SQLite Desen Eşleştirme operatörleri

“LIKE” – desen eşleştirme için kullanılır. “Like” kullanarak, joker karakterle belirtilen bir desene uyan değerleri arayabilirsiniz.

Soldaki işlenen, bir dize değişmez değeri veya bir dize sütunu olabilir. Desen şu şekilde belirtilebilir:

• Desen içerir. Örneğin, StudentName LIKE '%a%' – bu, StudentName sütununda herhangi bir konumda "a" harfini içeren öğrencilerin adlarını arayacaktır.
• Desenle başlar. Örneğin, “ÖğrenciAdı LIKE 'a%'” – “a” harfiyle başlayan öğrenci adlarını arar.
• Belirtilen kalıpla biter. Örneğin, “ÖğrenciAdı LIKE '%a'” – Adı “a” harfiyle biten öğrencileri arar.
• Bir dizedeki herhangi bir tek karakteri alt çizgi "_" harfiyle eşleştirme. Örneğin, "StudentName LIKE 'J___'" – 4 karakter uzunluğundaki öğrenci adlarını arar. "J" harfiyle başlamalı ve "J" harfinden sonra herhangi üç karakter daha içerebilir.

Desen eşleştirme örnekleri:

'j' harfiyle başlayan Öğrenci adlarını alın:

SELECT StudentName FROM Students WHERE StudentName LIKE 'j%';

Sonuç:

Öğrencilerin adlarının 'y' harfiyle bitmesini sağlayın:

SELECT StudentName FROM Students WHERE StudentName LIKE '%y';

Sonuç:

'n' harfini içeren Öğrencilerin adlarını alın:

SELECT StudentName FROM Students WHERE StudentName LIKE '%n%';

Sonuç:

“GLOB” operatörü, LIKE operatörüne eşdeğerdir ancak LIKE operatörünün aksine büyük/küçük harf duyarlıdır. Örneğin, aşağıdaki iki komut farklı sonuçlar verecektir:

SELECT 'Jack' GLOB 'j%';
SELECT 'Jack' LIKE 'j%';

Bu size şunları sağlayacaktır:

GLOB operatörü büyük/küçük harfe duyarlı olduğundan ilk ifade 0(yanlış) değerini döndürür, dolayısıyla 'j', 'J'ye eşit değildir. Ancak, LIKE operatörü büyük/küçük harfe duyarlı olmadığından ikinci ifade 1 (doğru) değerini döndürecektir; dolayısıyla 'j', 'J'ye eşittir.

Diğer operatörler:

SQLite VE

Bir veya daha fazla ifadeyi birleştiren mantıksal bir operatör. Yalnızca tüm ifadelerin "true" değeri vermesi durumunda true değerini döndürür. Ancak yalnızca tüm ifadeler "false" değeri verirse false değerini döndürür.

Örnek:

Aşağıdaki sorgu, StudentId > 5 olan ve StudentName'i N harfiyle başlayan öğrencileri arayacaktır, döndürülen öğrencilerin iki koşulu karşılaması gerekir:

SELECT *
FROM Students
WHERE (StudentId > 5) AND (StudentName LIKE 'N%');

Çıktı olarak yukarıdaki ekran görüntüsünde bu size yalnızca “Nancy” değerini verecektir. Nancy her iki koşulu da karşılayan tek öğrencidir.

SQLite OR

Bir veya daha fazla ifadeyi birleştiren mantıksal bir operatör; böylece birleştirilen operatörlerden biri doğru sonucunu verirse, o zaman doğru değerini döndürür. Ancak tüm ifadeler false sonucunu verirse false değerini döndürür.

Örnek:

Aşağıdaki sorgu, StudentId > 5 olan veya StudentName'i N harfiyle başlayan öğrencileri arayacaktır, döndürülen öğrencilerin aşağıdaki koşullardan en az birini karşılaması gerekir:

SELECT *
FROM Students
WHERE (StudentId > 5) OR (StudentName LIKE 'N%');

Bu size şunları sağlayacaktır:

Çıktı olarak, yukarıdaki ekran görüntüsünde, adında “n” harfi bulunan bir öğrencinin adını ve öğrenci kimliğinin değeri>5 olan bir öğrencinin adını verecektir.

Gördüğünüz gibi sonuç AND operatörüyle yapılan sorgudan farklı.

SQLite ARASINDA

BETWEEN, iki değer aralığında bulunan değerleri seçmek için kullanılır. Örneğin, “X BETWEEN Y AND Z” ifadesi, X değeri Y ve Z değerleri arasında ise true (1), aksi takdirde false (0) döndürür. “X BETWEEN Y AND Z” ifadesi, “X >= Y AND X <= Z” ifadesine eşdeğerdir; X, Y'den büyük veya eşit ve X, Z'den küçük veya eşit olmalıdır.

Örnek:

Aşağıdaki örnek sorguda, Id değeri 5 ile 8 arasında olan öğrencileri bulmak için bir sorgu yazacağız:

SELECT *
FROM Students
WHERE StudentId BETWEEN 5 AND 8;

Bu yalnızca kimlikleri 5, 6, 7 ve 8 olan öğrencilere verecektir:

SQLite IN

Bir işlenen ve bir işlenen listesi alır. İlk işlenen değeri listedeki işlenenlerden birinin değerine eşitse true döndürür. IN operatörü, işlenen listesi değerleri arasında ilk işlenen değerini içeriyorsa true (1) döndürür. Aksi takdirde false (0) döndürür.

Şöyle: “col IN(x, y, z)“. Bu, ” (col=x) veya (col=y) veya (col=z) ” ifadesine eşdeğerdir.

Örnek:

Aşağıdaki sorgu yalnızca 2, 4, 6, 8 kimlikli öğrencileri seçecektir:

SELECT *
FROM Students
WHERE StudentId IN(2, 4, 6, 8);

Bunun gibi:

Önceki sorgu, eşdeğer oldukları için aşağıdaki sorgu ile aynı sonucu verecektir:

SELECT *
FROM Students
WHERE (StudentId = 2) OR (StudentId =  4) OR (StudentId =  6) OR (StudentId = 8);

Her iki sorgu da tam çıktıyı verir. Ancak iki sorgu arasındaki fark ilk sorguda “IN” operatörünü kullanmamızdır. İkinci sorguda birden fazla “OR” operatörü kullandık.

IN operatörü, birden fazla OR operatörünün kullanılmasına eşdeğerdir. “WHERE StudentId IN(2, 4, 6, 8)” ifadesi, “WHERE (StudentId = 2) OR (StudentId = 4) OR (StudentId = 6) OR (StudentId = 8);“ ifadesine eşdeğerdir.

Bunun gibi:

SQLite DEĞİL

“NOT IN” operatörü, “IN” operatörünün tersidir. Ancak aynı sözdizimine sahiptir; bir işlenen ve bir işlenen listesi alır. İlk işlenenin değeri listedeki işlenenlerden birinin değerine eşit değilse true (0) döndürür. Yani, işlenen listesi ilk işleneni içermiyorsa true (0) döndürür. Örneğin: “col NOT IN(x, y, z)”. Bu, “(col<>x) AND (col<>y) AND (col<>z)” ifadesine eşdeğerdir.

Örnek:

Aşağıdaki sorgu, 2, 4, 6, 8 kimliklerinden birine eşit olmayan kimliklere sahip öğrencileri seçecektir:

SELECT *
FROM Students
WHERE StudentId NOT IN(2, 4, 6, 8);

Böyle

Önceki sorguda aynı sonucu aşağıdaki sorgu olarak veririz çünkü eşdeğerdirler:

SELECT *
FROM Students
WHERE (StudentId <> 2) AND (StudentId <> 4) AND (StudentId <> 6) AND (StudentId <> 8);

Bunun gibi:

Yukarıdaki ekran görüntüsünde,

Aşağıdaki Id'lerden (2, 4, 6 veya 8) hiçbirine eşit olmayan öğrencilerin bir listesini almak için birden fazla eşit olmayan operatör "<>" kullandık. Bu sorgu, bu Id listelerinin dışındaki tüm diğer öğrencileri döndürecektir.

SQLite VAR

EXISTS operatörleri herhangi bir işlenen almaz; kendisinden sonra yalnızca bir SELECT cümleciği alır. EXISTS operatörü, SELECT yan tümcesinden döndürülen herhangi bir satır varsa doğru (1), SELECT yan tümcesinden döndürülen hiç satır yoksa yanlış (0) değerini döndürür.

Örnek:

Aşağıdaki örnekte, eğer bölüm id'si students tablosunda mevcutsa, bölümün adını seçeceğiz:

SELECT DepartmentName
FROM Departments AS d
WHERE EXISTS (SELECT DepartmentId FROM Students AS s WHERE d.DepartmentId = s.DepartmentId);

Bu size şunları sağlayacaktır:

Sadece "BT, Fizik ve Sanat" bölümleri döndürülecektir. "Matematik" bölümünün adı döndürülmeyecektir çünkü bu bölümde öğrenci bulunmamaktadır, bu nedenle bölüm kimliği öğrenci tablosunda mevcut değildir. Bu yüzden EXISTS operatörü "Matematik" bölümünü yok saymıştır.

SQLite DEĞİL

Reverses, kendisinden sonra gelen operatörün sonucudur. Örneğin:

• NOT BETWEEN – BETWEEN false değerini döndürürse true değerini döndürür; bunun tersi de geçerlidir.
• NOT LIKE – LIKE false değerini döndürürse true değerini döndürür; bunun tersi de geçerlidir.
• NOT GLOB – GLOB false değerini döndürürse true değerini döndürür (veya tersi).
• NOT EXISTS – EXISTS false değerini döndürürse true değerini döndürür; bunun tersi de geçerlidir.

Örnek:

Aşağıdaki örnekte, EXISTS operatörünün tersi olan Students tablosunda bulunmayan departmanların adlarını almak için NOT operatörünü EXISTS operatörüyle birlikte kullanacağız. Yani, arama departman tablosunda bulunmayan DepartmentId üzerinden yapılacak.

SELECT DepartmentName
FROM Departments AS d
WHERE NOT EXISTS (SELECT DepartmentId
                  FROM Students AS s
                  WHERE d.DepartmentId = s.DepartmentId);

Çıktı:

Sadece “Matematik” bölümü geri döndürülecektir. Çünkü “Matematik” bölümü, öğrenci tablosunda bulunmayan tek bölümdür.

Sınırlama ve Düzenleme

SQLite Sipariş Numarası

SQLite Sıralama, sonucunuzu bir veya daha fazla ifadeye göre sıralamaktır. Sonuç kümesini sıralamak için ORDER BY yan tümcesini aşağıdaki gibi kullanmanız gerekir:

• Öncelikle ORDER BY deyimini belirtmeniz gerekir.
• ORDER BY yan tümcesi sorgunun sonunda belirtilmelidir; ondan sonra yalnızca LIMIT yan tümcesi belirtilebilir.
• Verilerin sıralanacağı ifadeyi belirtin; bu ifade bir sütun adı veya bir ifade olabilir.
• İfadeden sonra isteğe bağlı bir sıralama yönü belirleyebilirsiniz. Verilerin azalan sırasını belirlemek için DESC veya verilerin artan sırasını sıralamak için ASC. Bunlardan herhangi birini belirtmediyseniz veriler artan şekilde sıralanır.
• Aralarındaki “,” işaretini kullanarak daha fazla ifade belirleyebilirsiniz.

Örnek E-posta

Aşağıdaki örnekte, tüm öğrencileri isimlerine göre azalan sırada, ardından bölüm adına göre artan sırada seçeceğiz:

SELECT s.StudentName, d.DepartmentName
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId
ORDER BY d.DepartmentName ASC , s.StudentName DESC;

Bu size şunları sağlayacaktır:

• SQLite ilk önce tüm öğrencileri bölüm adlarına göre artan sırada sıralayacak
• Daha sonra her bölüm adı için o bölüm adı altındaki tüm öğrenciler adlarına göre azalan sırada görüntülenecektir.

SQLite limit:

LIMIT yan tümcesini kullanarak SQL sorgunuzun döndürdüğü satır sayısını sınırlayabilirsiniz. Örneğin, LIMIT 10 size yalnızca 10 satır verecek ve diğer tüm satırları yok sayacaktır.

LIMIT yan tümcesinde, OFFSET yan tümcesini kullanarak belirli bir konumdan başlayarak belirli sayıda satır seçebilirsiniz. Örneğin, “LIMIT 4 OFFSET 4” ilk 4 satırı yok sayacak ve beşinci satırdan başlayarak 4 satır döndürecektir; yani 5, 6, 7 ve 8. satırları elde edeceksiniz.

OFFSET maddesinin isteğe bağlı olduğunu unutmayın, "LIMIT 4, 4" şeklinde de yazabilirsiniz ve bu size tam olarak aynı sonucu verecektir.

Örnek:

Aşağıdaki örnekte, sorguyu kullanarak öğrenci kimliği 3'ten başlayarak yalnızca 5 öğrenci döndüreceğiz:

SELECT * FROM Students LIMIT 4,3;

Bu size 5. sıradan başlayarak yalnızca üç öğrenci verecektir. Yani size Öğrenci Kimliği 5, 6 ve 7 olan satırları verecektir:

Yinelenenleri kaldırma

SQL sorgunuz yinelenen değerler döndürüyorsa, bu yinelenenleri kaldırmak ve yalnızca benzersiz değerler döndürmek için "DISTINCT" anahtar kelimesini kullanabilirsiniz. DISTINCT anahtar kelimesinden sonra birden fazla sütun belirtebilirsiniz.

Örnek:

Aşağıdaki sorgu, yinelenen "departman adı değerleri" döndürecektir: Burada BT, Fizik ve Sanatlar adlarına sahip yinelenen değerlerimiz var.

SELECT d.DepartmentName
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Bu size departman adı için yinelenen değerler verecektir:

Departman adı için yinelenen değerlerin nasıl olduğuna dikkat edin. Şimdi bu kopyaları kaldırmak ve yalnızca benzersiz değerler elde etmek için DISTINCT anahtar kelimesini aynı sorguyla kullanacağız. Bunun gibi:

SELECT DISTINCT d.DepartmentName
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Bu size departman adı sütunu için yalnızca üç benzersiz değer verecektir:

toplam

SQLite Toplamalar, içinde tanımlanan yerleşik işlevlerdir. SQLite bu, birden çok satırın birden çok değerini tek bir değerde gruplayacaktır.

İşte desteklenen agregalar SQLite:

SQLite AVG()

Tüm x değerlerinin ortalamasını döndürdü.

Örnek:

Aşağıdaki örnekte öğrencilerin tüm sınavlardan aldıkları notların ortalamasını alacağız:

SELECT AVG(Mark) FROM Marks;

Bu size “18.375” değerini verecektir:

Bu sonuçlar, tüm işaret değerlerinin toplamının sayıma bölünmesiyle elde edilir.

COUNT() – COUNT(X) veya COUNT(*)

X değerinin kaç kez göründüğünün toplam sayısını döndürür. COUNT ile kullanabileceğiniz bazı seçenekler şunlardır:

• COUNT(x): Yalnızca x değerlerini sayar; burada x bir sütun adıdır. NULL değerleri göz ardı edecektir.
• COUNT(*): Tüm sütunlardaki tüm satırları sayın.
• COUNT (DISTINCT x): x'in farklı değerlerinin sayısını alacak olan x'ten önce bir DISTINCT anahtar sözcüğü belirtebilirsiniz.

Örnek E-posta

Aşağıdaki örnekte, COUNT(DepartmentId), COUNT(*), ve COUNT(DISTINCT DepartmentId) ile Departmanların toplam sayısını ve bunların nasıl farklı olduğunu alacağız:

SELECT COUNT(DepartmentId), COUNT(DISTINCT DepartmentId), COUNT(*) FROM Students;

Bu size şunları sağlayacaktır:

Aşağıdaki gibi:

• COUNT(DepartmentId) size tüm departman kimliğinin sayısını verecektir ve boş değerleri göz ardı edecektir.
• COUNT(DISTINCT DepartmanKimliği) size Departman Kimliğinin farklı değerlerini verir; bunlar yalnızca 3'tür. Bunlar, departman adının üç farklı değeridir. Öğrenci adında bölüm adının 8 değeri olduğuna dikkat edin. Ancak yalnızca farklı üç değer olan Matematik, BT ve Fizik.
• COUNT(*), öğrenciler tablosundaki 10 öğrenci için 10 satır olan satır sayısını sayar.

GROUP_CONCAT() – GROUP_CONCAT(X) veya GROUP_CONCAT(X,Y)

GROUP_CONCAT toplama işlevi, birden fazla değeri virgülle ayırarak tek bir değere birleştirir. Aşağıdaki seçeneklere sahiptir:

• GROUP_CONCAT(X): Bu, x'in tüm değerini, değerler arasında ayırıcı olarak kullanılan virgül "" ile tek bir dizede birleştirecektir. NULL değerler göz ardı edilecek.
• GROUP_CONCAT(X, Y): Bu, x'in değerlerini tek bir dizede birleştirir; y değeri, varsayılan ayırıcı ',' yerine her değer arasında ayırıcı olarak kullanılır. NULL değerleri de dikkate alınmayacaktır.
• GROUP_CONCAT(DISTINCT X): Bu, x'in tüm farklı değerlerini, değerler arasında ayırıcı olarak kullanılan virgül "" ile tek bir dizede birleştirecektir. NULL değerler göz ardı edilecek.

GROUP_CONCAT(DepartmanAdı) Örnek

Aşağıdaki sorgu, students ve departments tablosundan gelen tüm departman adı değerlerini virgülle ayrılmış tek bir dizeye birleştirecektir. Yani bir değerler listesi döndürmek yerine, her satırda bir değer. Tüm değerler virgülle ayrılmış şekilde, yalnızca bir satırda bir değer döndürecektir:

SELECT GROUP_CONCAT(d.DepartmentName)
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Bu size şunları sağlayacaktır:

Bu size virgülle ayrılmış tek bir dize halinde birleştirilmiş 8 departmanın ad değerlerinin listesini verecektir.

GROUP_CONCAT(DISTINCT DepartmanAdı) Örnek

Aşağıdaki sorgu, students ve departments tablosundaki bölüm adının farklı değerlerini virgülle ayrılmış tek bir dizede birleştirecektir:

SELECT GROUP_CONCAT(DISTINCT d.DepartmentName)
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Bu size şunları sağlayacaktır:

Sonucun önceki sonuçtan ne kadar farklı olduğuna dikkat edin; yalnızca farklı departmanların adları olan üç değer döndürüldü ve yinelenen değerler kaldırıldı.

GROUP_CONCAT(DepartmanAdı ,'&') Örnek

Aşağıdaki sorgu, students ve departments tablosundaki departman adı sütununun tüm değerlerini tek bir dizede birleştirecektir, ancak ayırıcı olarak virgül yerine '&' karakteri kullanılacaktır:

SELECT GROUP_CONCAT(d.DepartmentName, '&')
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Bu size şunları sağlayacaktır:

Değerleri ayırmak için varsayılan karakter olan “,” yerine “&” karakterinin nasıl kullanıldığına dikkat edin.

SQLite MAX() ve MIN()

MAX(X), size X değerlerinden en yüksek değeri döndürür. MAX, x'in tüm değerleri boşsa NULL değerini döndürür. Oysa MIN(X) size X değerlerinden en küçük değeri döndürür. X'in tüm değerleri null ise MIN, NULL değerini döndürür.

Örnek E-posta

Aşağıdaki sorguda, "Notlar" tablosundan en yüksek ve en düşük notu almak için MIN ve MAX fonksiyonlarını kullanacağız:

SELECT MAX(Mark), MIN(Mark) FROM Marks;

Bu size şunları sağlayacaktır:

SQLite TOPLA(x), Toplam(x)

İkisi de tüm x değerlerinin toplamını döndürecektir. Ancak aşağıdakilerde farklıdırlar:

• Tüm değerler boşsa SUM null değerini döndürür, ancak Toplam 0 değerini döndürür.
• TOTAL her zaman kayan nokta değerlerini döndürür. SUM, tüm x değerleri tamsayıysa bir tamsayı değeri döndürür. Ancak değerler tam sayı değilse kayan noktalı bir değer döndürür.

Örnek E-posta

Aşağıdaki sorguda, "Notlar" tablosundaki tüm notların toplamını almak için SUM ve total fonksiyonlarını kullanacağız:

SELECT SUM(Mark), TOTAL(Mark) FROM Marks;

Bu size şunları sağlayacaktır:

Gördüğünüz gibi TOTAL her zaman bir kayan nokta döndürür. Ancak SUM, "İşaret" sütunundaki değerler tam sayı olabileceğinden bir tamsayı değeri döndürür.

SUM ve TOTAL örneği arasındaki fark:

Aşağıdaki sorguda, NULL değerlerinin SUM'ını aldıklarında SUM ve TOTAL arasındaki farkı göstereceğiz:

SELECT SUM(Mark), TOTAL(Mark) FROM Marks WHERE TestId = 4;

Bu size şunları sağlayacaktır:

TestId = 4 için herhangi bir işaret bulunmadığını, dolayısıyla bu test için boş değerlerin bulunduğunu unutmayın. SUM boş bir değer döndürürken TOTAL 0 değerini döndürür.

Gruplandırmaya Göre

GROUP BY deyimi, satırları gruplar halinde gruplamak için kullanılacak bir veya daha fazla sütunu belirtmek için kullanılır. Aynı değerlere sahip satırlar gruplar halinde toplanacak (düzenlenecektir).

Sütunlara göre gruplandırmaya dahil olmayan diğer herhangi bir sütun için, bunun için bir toplama işlevini kullanabilirsiniz.

Örnek:

Aşağıdaki sorgu size her bölümde bulunan toplam öğrenci sayısını verecektir.

SELECT d.DepartmentName, COUNT(s.StudentId) AS StudentsCount
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId
GROUP BY d. DepartmentName;

Bu size şunları sağlayacaktır:

GROUPBY DepartmanAdı deyimi, tüm öğrencileri her bölüm adı için birer grup halinde gruplandırır. Her bir “bölüm” grubu için içindeki öğrencileri sayacaktır.

HAVING cümleciği

GROUP BY cümleciğinin döndürdüğü grupları filtrelemek istiyorsanız GROUP BY ifadesinden sonra bir "HAVING" ifadesi belirtebilirsiniz. İfade bu grupları filtrelemek için kullanılacaktır.

Örnek E-posta

Aşağıdaki sorguda sadece iki öğrencisi olan bölümleri seçeceğiz:

SELECT d.DepartmentName, COUNT(s.StudentId) AS StudentsCount
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId
GROUP BY d. DepartmentName
HAVING COUNT(s.StudentId) = 2;

Bu size şunları sağlayacaktır:

HAVING COUNT(S.StudentId) = 2 ifadesi, döndürülen grupları filtreleyecek ve yalnızca üzerinde tam olarak iki öğrenci içeren grupları döndürecektir. Bizim durumumuzda Sanat bölümünün 2 öğrencisi var, dolayısıyla çıktıda gösteriliyor.

SQLite Sorgu ve Alt Sorgu

Herhangi bir sorgunun içinde, SELECT, INSERT, DELETE, UPDATE veya başka bir alt sorgunun içinde başka bir sorgu kullanabilirsiniz.

Bu iç içe geçmiş sorguya alt sorgu adı verilir. Şimdi SELECT yan tümcesinde alt sorguların kullanımına ilişkin bazı örnekler göreceğiz. Ancak Veri Değiştirme eğitiminde INSERT, DELETE ve UPDATE deyimiyle alt sorguları nasıl kullanabileceğimizi göreceğiz.

FROM yan tümcesi örneğinde alt sorgu kullanma

Aşağıdaki sorguda FROM ifadesinin içine bir alt sorgu ekleyeceğiz:

SELECT
  s.StudentName, t.Mark
FROM Students AS s
INNER JOIN
(
   SELECT StudentId, Mark
   FROM Tests AS t
   INNER JOIN Marks AS m ON t.TestId = m.TestId
)  ON s.StudentId = t.StudentId;

Sorgu:

   SELECT StudentId, Mark
   FROM Tests AS t
   INNER JOIN Marks AS m ON t.TestId = m.TestId

Yukarıdaki sorguya burada alt sorgu denir çünkü FROM yan tümcesinin içine yerleştirilmiştir. Sorguda döndürülen sütunlara başvurabilmemiz için ona "t" takma adını verdiğimize dikkat edin.

Bu sorgu size şunu verecektir:

Yani bizim durumumuzda,

• s.StudentName öğrencilerin isimlerini veren ana sorgudan seçilir ve
• t.Mark alt sorgudan seçilir; bu öğrencilerin her birinin aldığı notları veren

WHERE yan tümcesi örneğinde alt sorgu kullanma

Aşağıdaki sorguda WHERE ifadesine bir alt sorgu ekleyeceğiz:

SELECT DepartmentName
FROM Departments AS d
WHERE NOT EXISTS (SELECT DepartmentId
                  FROM Students AS s
                  WHERE d.DepartmentId = s.DepartmentId);

Sorgu:

SELECT DepartmentId
FROM Students AS s
WHERE d.DepartmentId = s.DepartmentId

Yukarıdaki sorgu WHERE cümleciğinin içinde yer aldığı için burada alt sorgu olarak adlandırılmaktadır. Alt sorgu, NOT EXISTS operatörü tarafından kullanılacak olan Departman Kimliği değerlerini döndürecektir.

Bu sorgu size şunu verecektir:

Yukarıdaki sorguda kayıtlı öğrencisi olmayan bölümü seçtik. Buradaki "Matematik" bölümü.

set Operations – UNION, Intersect

SQLite Aşağıdaki SET işlemlerini destekler:

BİRLİK & BİRLİK HEPSİ

Birden fazla SELECT ifadesinden döndürülen bir veya daha fazla sonuç kümesini (bir grup satır) tek bir sonuç kümesinde birleştirir.

UNION farklı değerler döndürecektir. Ancak UNION ALL kopyaları içermeyecek ve içermeyecektir.

Sütun adının ilk SELECT deyiminde belirtilen sütun adı olacağını unutmayın.

BİRLİK Örneği

Aşağıdaki örnekte students tablosundan DepartmentId listesini ve departments tablosundan DepartmentId listesini aynı sütunda alacağız:

SELECT DepartmentId AS DepartmentIdUnioned FROM Students
UNION
SELECT DepartmentId FROM Departments;

Bu size şunları sağlayacaktır:

Sorgu, farklı departman kimliği değerleri olan yalnızca 5 satırı döndürür. Boş değer olan ilk değere dikkat edin.

SQLite UNION ALL Örneği

Aşağıdaki örnekte students tablosundan DepartmentId listesini ve departments tablosundan DepartmentId listesini aynı sütunda alacağız:

SELECT DepartmentId AS DepartmentIdUnioned FROM Students
UNION ALL
SELECT DepartmentId FROM Departments;

Bu size şunları sağlayacaktır:

Sorgu, öğrenciler tablosundan 14 ve bölümler tablosundan 10 olmak üzere 4 satır döndürecektir. Döndürülen değerlerde kopyaların bulunduğunu unutmayın. Ayrıca sütun adının ilk SELECT deyiminde belirtilen ad olduğuna dikkat edin.

Şimdi UNION ALL yerine UNION koyarsak UNION all'ın nasıl farklı sonuçlar vereceğini görelim:

SQLite KESİŞİM

Her iki birleştirilmiş sonuç kümesinde bulunan değerleri döndürür. Birleştirilmiş sonuç kümelerinden birinde bulunan değerler göz ardı edilecektir.

Örnek E-posta

Aşağıdaki sorguda, DepartmentId sütununda Students ve Departments tablolarının her ikisinde de bulunan DepartmentId değerlerini seçeceğiz:

SELECT DepartmentId FROM Students
Intersect
SELECT DepartmentId FROM Departments;

Bu size şunları sağlayacaktır:

Sorgu yalnızca üç değeri (1, 2 ve 3) döndürür. Bunlar her iki tabloda da bulunan değerlerdir.

Ancak null ve 4 değerleri dahil edilmedi çünkü null değer bölümler tablosunda değil yalnızca öğrenciler tablosunda mevcuttu. Ve 4 değeri, öğrenciler tablosunda değil, bölümler tablosunda mevcuttur.

Bu nedenle hem NULL hem de 4 değerleri göz ardı edildi ve döndürülen değerlere dahil edilmedi.

DIŞINDA

İki satır listeniz olduğunu varsayalım, list1 ve list2 ve sadece list1'de bulunmayan list2'deki satırları istiyorsanız, "EXCEPT" ifadesini kullanabilirsiniz. EXCEPT ifadesi iki listeyi karşılaştırır ve list1'de bulunan ve list2'de bulunmayan satırları döndürür.

Örnek E-posta

Aşağıdaki sorguda departments tablosunda bulunan ve students tablosunda bulunmayan DepartmentId değerlerini seçeceğiz:

SELECT DepartmentId FROM Departments
EXCEPT
SELECT DepartmentId FROM Students;

Bu size şunları sağlayacaktır:

Sorgu yalnızca 4 değerini döndürür. Bu, bölümler tablosunda bulunan tek değerdir ve öğrenciler tablosunda mevcut değildir.

BOŞ işleme

"NULL" değeri özel bir değerdir. SQLiteBu, bilinmeyen veya eksik bir değeri temsil etmek için kullanılır. Null değerinin "0" veya boş "" değerinden tamamen farklı olduğuna dikkat edin. Çünkü 0 ve boş değer bilinen bir değerdir, ancak null değeri bilinmeyen bir değerdir.

NULL değerleri özel bir işlem gerektirir SQLiteŞimdi NULL değerlerinin nasıl ele alınacağını göreceğiz.

NULL değerleri ara

Boş değerleri aramak için normal eşitlik operatörünü (=) kullanamazsınız. Örneğin, aşağıdaki sorgu boş DepartmentId değerine sahip öğrencileri arar:

SELECT * FROM Students WHERE DepartmentId = NULL;

Bu sorgu herhangi bir sonuç vermeyecektir:

NULL değeri, kendisi de null değer içeren başka bir değere eşit olmadığından herhangi bir sonuç döndürmedi.

Ancak, sorgunun çalışması için, aşağıdaki gibi boş değerleri aramak üzere "IS NULL" operatörünü kullanmanız gerekir:

SELECT * FROM Students WHERE DepartmentId IS NULL;

Bu size şunları sağlayacaktır:

Sorgu, boş bir Departman Kimliği değerine sahip öğrencileri döndürecektir.

Boş olmayan (null olmayan) değerleri almak istiyorsanız, "IS NOT NULL" operatörünü şu şekilde kullanmanız gerekir:

SELECT * FROM Students WHERE DepartmentId IS NOT NULL;

Bu size şunları sağlayacaktır:

Sorgu, NULL Departman Kimliği değeri olmayan öğrencileri döndürecektir.

Koşullu sonuçlar

Bir değerler listeniz varsa ve bazı koşullara göre bunlardan herhangi birini seçmek istiyorsanız. Bunun için o değerin seçilebilmesi için koşulun doğru olması gerekir.

CASE ifadesi, tüm değerler için bu koşullar listesini değerlendirecektir. Koşul doğruysa bu değeri döndürür.

Örneğin, “Not” sütununuz varsa ve aşağıdaki gibi not değerine göre bir metin değeri seçmek istiyorsanız:

– Notun 85’ten yüksek olması durumunda “Mükemmel”.

– Notun 70 ile 85 arasında olması durumunda “Çok İyi”.

– Notun 60 ile 70 arasında olması durumunda “İyi”.

Daha sonra bunu yapmak için CASE ifadesini kullanabilirsiniz.

Bu, SELECT yan tümcesinde bir mantık tanımlamak için kullanılabilir, böylece örneğin if ifadesi gibi belirli koşullara bağlı olarak belirli sonuçları seçebilirsiniz.

CASE operatörü aşağıdaki gibi farklı sözdizimleriyle tanımlanabilir:

Farklı koşulları kullanabilirsiniz:

CASE
  WHEN condition1 THEN result1
  WHEN condition2 THEN result2
  WHEN condition3 THEN result3
  …
  ELSE resultn
END

Veya yalnızca bir ifade kullanabilir ve aralarından seçim yapabileceğiniz farklı olası değerler koyabilirsiniz:

CASE expression
  WHEN value1 THEN result1
  WHEN value2 THEN result2
  WHEN value3 THEN result3
  …
  ELSE restuln
END

ELSE yan tümcesinin isteğe bağlı olduğunu unutmayın.

Örnek E-posta

Aşağıdaki örnekte, Öğrenciler tablosundaki Bölüm Kimliği sütununda NULL değeriyle CASE ifadesini kullanarak 'Bölüm Yok' metnini şu şekilde görüntüleyeceğiz:

SELECT
  StudentName,
  CASE
    WHEN DepartmentId IS NULL THEN 'No Department'
    ELSE DepartmentId
  END AS DepartmentId
FROM Students;

• CASE operatörü, Departman Kimliğinin değerinin boş olup olmadığını kontrol edecektir.
• NULL bir değerse, Departman Kimliği değeri yerine 'Departman Yok' hazır değerini seçecektir.
• Boş bir değer değilse, Departman Kimliği sütununun değerini seçecektir.

Bu size aşağıda gösterildiği gibi çıktıyı verecektir:

Ortak tablo ifadesi

Ortak tablo ifadeleri (CTE'ler), SQL deyiminin içinde belirli bir adla tanımlanan alt sorgulardır.

Alt sorgulara göre bir avantajı vardır çünkü SQL ifadelerinden tanımlanır ve sorguların okunmasını, sürdürülmesini ve anlaşılmasını kolaylaştırır.

Ortak bir tablo ifadesi, SELECT ifadelerinin önüne WITH ifadesi konularak aşağıdaki gibi tanımlanabilir:

WITH CTEname
AS
(
   SELECT statement
)
SELECT, UPDATE, INSERT, or update statement here FROM CTE

"CTEname", CTE için verebileceğiniz herhangi bir isimdir ve daha sonra ona atıfta bulunmak için kullanabilirsiniz. CTE'ler üzerinde SELECT, UPDATE, INSERT veya DELETE ifadeleri tanımlayabileceğinizi unutmayın.

Şimdi SELECT yan tümcesinde CTE'nin nasıl kullanılacağına dair bir örnek görelim.

Örnek E-posta

Aşağıdaki örnekte, bir SELECT ifadesinden bir CTE tanımlayacağız ve daha sonra bunu başka bir sorguda kullanacağız:

WITH AllDepartments
AS
(
  SELECT DepartmentId, DepartmentName
  FROM Departments
)
SELECT
  s.StudentId,
  s.StudentName,
  a.DepartmentName
FROM Students AS s
INNER JOIN AllDepartments AS a ON s.DepartmentId = a.DepartmentId;

Bu sorguda, bir CTE tanımladık ve ona "AllDepartments" adını verdik. Bu CTE, bir SELECT sorgusundan tanımlandı:

SELECT DepartmentId, DepartmentName
  FROM Departments

Daha sonra CTE'yi tanımladıktan sonra kendisinden sonra gelen SELECT sorgusunda kullandık.

Ortak tablo ifadelerinin sorgunun çıktısını etkilemediğini unutmayın. Aynı sorguda yeniden kullanmak için mantıksal bir görünüm veya alt sorgu tanımlamanın bir yoludur. Yaygın tablo ifadeleri, bildirdiğiniz ve onu alt sorgu olarak yeniden kullandığınız bir değişken gibidir. Yalnızca SELECT ifadesi sorgunun çıktısını etkiler.

Bu sorgu size şunu verecektir:

Gelişmiş sorgular

Gelişmiş sorgular, karmaşık birleştirmeler, alt sorgular ve bazı toplamlar içeren sorgulardır. Aşağıdaki bölümde gelişmiş bir sorgunun bir örneğini göreceğiz:

Nereden alacağız,

• Her bölüm için tüm öğrencilerin yer aldığı bölüm adları
• Virgülle ayrılmış öğrenci adı ve
• En az üç öğrencinin bulunduğu bölümün gösterilmesi

SELECT
  d.DepartmentName,
  COUNT(s.StudentId) StudentsCount,
  GROUP_CONCAT(StudentName) AS Students
FROM Departments AS d
INNER JOIN Students AS s ON s.DepartmentId = d.DepartmentId
GROUP BY d.DepartmentName
HAVING COUNT(s.StudentId) >= 3;

Departments tablosundan DepartmentName alanını almak için bir JOIN yan tümcesi ekledik. Ardından, iki toplama fonksiyonu içeren bir GROUP BY yan tümcesi ekledik:

• Her bölüm grubundaki öğrencileri saymak için “COUNT”.
• GROUP_CONCAT, her gruptaki öğrencileri tek bir dizeyle ayrılmış virgülle birleştirmek için kullanılır.

GROUP BY'den sonra bölümleri filtrelemek ve yalnızca en az 3 öğrencisi olan bölümleri seçmek için HAVING deyimini kullandık.

Sonuç aşağıdaki gibi olacaktır:

SSS