Doğru veri yönetimi olmadan iş dünyasında sürdürülebilirlik zordur. İyi tanımlanmış bir sistem kurmak, iç ve dış operasyonları yönetmek için gereklidir. İş verilerine ilişkin ayrıntılı içgörü, genel iş akışını anlamaya ve performansı ölçmeye yardımcı olur. Dahası, veritabanı kullanmak zaman kazandırır ve bilgilere zahmetsizce erişmeyi sağlar.
Veritabanı nedir?
Bir veritabanı, bilgileri güvenli bir şekilde depolamak için kullanılan düzenli bir sistemdir. Kategorizasyon sunar ve benzer türdeki öğeleri tek bir grup altında sıralamak için tablolar oluşturulmasına olanak tanır. Tablolar, bilgileri birden fazla satır ve sütunda listeleme seçenekleri sunar. Sonuç olarak, verilerin kalitesi ve tutarlılığı artar. Depolama ve kolay erişim özelliklerinin yanı sıra veritabanları, gizliliğin korunmasında ve sistemlerin güvenliğinin sağlanmasında önemli bir rol oynar. İster geçici ister bir uygulamaya kodlanmış bir sürecin parçası olsun, verileri geri çağırmak veritabanı yönetiminin en kritik yönlerinden biridir.
Bir sorgu, ilişkisel DMS'de bir tablodan veri çekmek için kullanılan herhangi bir komuttur. SELECT ifadeleri neredeyse her zaman Yapılandırılmış Sorgu Dili (SQL) sorgularında kullanılır. Bir veritabanından bilgi çekmek için birkaç yöntem vardır. Genellikle geliştiriciler, hızlı ve etkili olduğu için komut satırı seçeneğini tercih ederler. Sorguların sorunsuz bir şekilde gönderilmesini sağlar.
Bu kılavuzda, sizi MySQL ile tanıştıracağız ve MySQL'de sorgularla nasıl çalışılacağını tartışacağız. Başlayalım!
Gereksinimler
Bu eğitimi takip etmek için aşağıdakilere ihtiyacınız olacak:
-
Sisteminizde en son Ubuntu sürümünün kurulu olması gerekir.
-
Sistem kullanıcılarının sudo yetkilerine sahip olması gerekir.
-
Sudo hesabınıza erişmekte zorluk yaşıyorsanız, MySQL root şifresini değiştirmeyi düşünün.
-
-
MySQL'in sunucunuzda kurulu olması gerekir.
Adım 1 — Bir Veritabanı Oluşturma ve Kurma
Başlamadan ve ilk SQL sorgumuzu yazmadan önce, bir veritabanı oluşturmamız ve buna tablolar eklememiz gerekir. Ardından, örnek verileri kullanarak tabloları dolduracağız. Veritabanlarıyla çalışmak, temel kurulumu anlamanıza yardımcı olacak ve sorgularla çalışma konusunda güven aşılayacaktır.
Pratik deneyim, kavramları oluşturmanın ve veritabanlarının önemini anlamanın en etkili yoludur. Bu kılavuzda, gerçek dünya sorunlarını çözmek için veritabanlarının kullanımını ve önemini size aktaracağız. Veritabanlarının kayıtları yapılandırılmış bir şekilde düzenlemeye nasıl yardımcı olabileceğini anlamak için bir senaryoyu inceleyelim.
Senaryo: Bir grup üniversite öğrencisinin doğum günlerini kutlamak için tatile gittiği bir veritabanı oluşturacağız. Tatile gitmeden önce, dostane bir yüzme yarışmasına katılmayı planlıyorlar. Ayrıca, gruptaki her arkadaş, seyahatlerini heyecan verici ve keyifli hale getirmek için yapılacaklar listesi planlıyor.
İlk olarak, MySQL'i root kullanıcısı olarak açın:
|
1 |
$ sudo mysql |
Ardından, aşağıdaki komutu çalıştırarak bir veritabanı oluşturun:
|
1 2 3 |
mysql> CREATE DATABASE `vacation`; Sorgu Tamam, 1 satır etkilendi (0.52 sn) |
Ardından, aşağıdaki komutu kullanarak veritabanımızı kullanalım:
|
1 |
mysql> USE vacation; |
Ondan sonra veritabanımızda tablolar oluşturacağız. İlk tabloyu şu şekilde adlandırın: celebration. Tablomuzda arkadaşlarımızın isimleri için (name), kazandıkları turnuvalar için (wins) ve ayrıca en iyi en iyi süreleri için (time):
|
1 2 3 4 5 6 7 |
mysql> CREATE TABLE celebration ( -> name varchar(50), -> wins real, -> time real -> ); Sorgu Tamam, 0 satır etkilendi (2.03 sn) |
Daha sonra tablomuzu verilerle dolduracağız:
|
1 2 3 4 5 6 7 8 9 |
mysql> INSERT INTO celebration (name, wins, time) VALUES('Austin', '4', '15.5'), ('Ivan','7','9'), ('Aisha','10','5'), ('Zane','13','7.5'); Sorgu Tamam, 4 satır etkilendi (0.29 sn) Kayıtlar: 4 Yinelenenler: 0 Uyarılar: 0 |
Ardından, en sevdikleri doğum günü etkinlikleri hakkındaki bilgileri depolamak için veritabanımızda başka bir tablo oluşturun. Adı olan bir tablo oluşturacağızvacation ve şu sütunlara sahip olacak:
|
List |
Detail |
|
name: |
Her arkadaşın adını depolar. |
|
birthdate: |
Her bireyin doğum tarihini takip eder. |
|
activity: |
En sevdikleri etkinliğin kaydını tutar. |
|
Destination: |
Her bireyin en sevdiği hedef hakkındaki bilgileri depolar. |
|
meal: |
Bir bireyin sevdiği en sevdiği yemeği takip eder. |
|
1 2 3 4 5 6 7 8 |
mysql> CREATE TABLE vacation ( name varchar(50), birthdate date, activity varchar(50), destination varchar(50), meal varchar(50) ); Query OK, 0 rows affected (0.09 sec) |
Tabloyu verilerle doldurun:
|
1 2 3 4 5 6 7 8 9 10 |
mysql> CREATE TABLE vacation ( name varchar(50), birthdate date, activity varchar(50), destination varchar(50), meal varchar(50) ); Query OK, 0 rows affected (0.09 sec) Records: 4 Duplicates: 0 Warnings: 0 |
Artık veritabanınızı kurmayı tamamladınız.
Adım 2 — SELECT İfadeleri ile Başlayın
SQL'deki sorgular normalde ile başlarSELECT. Sorgularda, bir tablodaki hangi sütunların sonuçlarla birlikte döndürüleceğini belirtmek için kullanılır. Bir sorgu her zaman ifadesini de içermelidirFROM, bu da ifadenin sorgulayacağı tabloyu belirtmek için kullanılır.
Sorgular aşağıdaki sözdizimini takip eder:
|
1 |
mysql> SELECT column_to_select FROM table_to_select WHERE certain_conditions_apply; |
Sorgu sözdizimini kullanarak meal sütununu vacation tablosundan döndüreceğiz:
|
1 |
mysql> SELECT meal FROM vacation; |
Çıktımız aşağıdaki gibi olacaktır:
|
1 2 3 4 5 6 7 8 9 10 |
+-------+ | meal | +-------+ | Steak | | Sushi | | Fries | | Tofu | +-------+ 4 rows in set (0.00 sec) |
Sütunları ayırmak için bir sütun kullanarak birden fazla sütun da seçebilirsiniz:
|
1 |
mysql> SELECT name, destination FROM vacation; |
Çıktı:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+-------------+ | name | destination | +--------+-------------+ | Austin | Maldives | | Ivan | Mauritius | | Aisha | Colorado | | Zane | Bora Bora | +--------+-------------+ 4 rows in set (0.00 sec) |
Tablodaki tüm sütunları temsil etmek istiyorsanız bir asterisk (*) de kullanabilirsiniz:
|
1 |
mysql> SELECT * FROM celebration; |
Çıktı:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+------+ | name | wins | time | +--------+------+------+ | Austin | 4 | 15.5 | | Ivan | 7 | 9 | | Aisha | 10 | 5 | | Zane | 13 | 7.5 | +--------+------+------+ 4 rows in set (0.00 sec) |
Belirtilen bir koşulu karşılayan kayıtları filtrelemek istiyorsanız, WHERE kullanırsınız. Belirtilen koşulu karşılamayan satırlar sonuçlardan elenir. WHERE tümcesi aşağıdaki sözdizimini kullanır:
|
1 |
mysql> . . . WHERE column_name comparison_operator value |
Belirtilen sütunun değerle nasıl karşılaştırılması gerektiğini tanımlayan bir karşılaştırma operatörüdür. Yaygın SQL karşılaştırma operatörleri şunları içerir:
|
Operatör |
Kullanım |
|
= |
Eşitlik |
|
!= |
Eşitsizlik |
|
< |
Küçüktür |
|
> |
Büyüktür |
|
<= |
Küçük veya eşittir |
|
>= |
Büyük veya eşittir |
|
BETWEEN |
Değerin verilen aralıkta olup olmadığını test eder. |
|
IN |
Bir satırın değerinin belirtilen değerler kümesinde yer alıp almadığını test eder. |
|
EXISTS |
Bir satırın var olup olmadığını test eder |
|
LIKE |
Bir değerin belirtilen dizeyle eşleşip eşleşmediğini test eder |
|
IS NULL |
Null değerleri test eder |
|
IS NOT NULL |
NULL dışındaki tüm değerleri test eder |
Aisha'nın en sevdiği hedefi bulmak isteseydiniz aşağıdaki sorguyu kullanabilirdiniz:
|
1 |
mysql> SELECT destination FROM vacation WHERE name ='Aisha'; |
Sorgu ardından şunları döndürecektir:
|
1 2 3 4 5 6 7 |
+-------------+ | destination | +-------------+ | Colorado | +-------------+ 1 row in set (0.03 sec) |
SQL, özellikle WHERE yan tümcelerinde son derece yararlı olan joker karakterlerin kullanımını destekler. Yüzde işaretleri ( %) sıfır veya daha fazla bilinmeyen karakteri belirtirken, alt çizgiler ( _) tek bir bilinmeyen karakteri belirtir. Bunlar, bir tablodaki belirli bir girdiyi bulmak istediğinizde ancak girdi hakkında emin olmadığınızda yardımcı olur.
Örneğin, bir arkadaşınızın en sevdiği tatil yerini unuttuysanız ve sadece başladığı harfi biliyorsanız (örneğin “m”), aşağıdaki sorguyu kullanarak hedef adını bulabilirsiniz:
|
1 |
mysql> SELECT destination FROM vacation WHERE destination LIKE 'm%'; |
Sorgu şunları döndürecektir:
|
1 2 3 4 5 6 7 8 |
+-------------+ | destination | +-------------+ | Maldives | | Mauritius | +-------------+ 2 rows in set (0.04 sec) |
Veritabanlarıyla çalışırken, nispeten uzun veya okunması zor adlara sahip sütunlarla veya tablolarla karşılaşabilirsiniz. Bu durumlarda, AS anahtar sözcüğünü kullanarak bir takma ad (alias) oluşturup adları daha okunabilir hale getirebilirsiniz. AS ile oluşturulan takma adlar yalnızca oluşturuldukları sorgunun süresi boyunca geçerlidir:
|
1 2 3 4 5 6 7 8 9 10 11 |
mysql> SELECT name AS E, destination as D, activity as A FROM vacation; +--------+-----------+-------------------+ | E | D | A | +--------+-----------+-------------------+ | Austin | Maldives | skiing | | Ivan | Mauritius | paragliding | | Aisha | Colorado | mountain climbing | | Zane | Bora Bora | fishing | +--------+-----------+-------------------+ 4 rows in set (0.00 sec) |
Adım 3 — Toplama (Aggregate) Fonksiyonlarına Giriş
Verilerle çalışırken her zaman verinin kendisini görmek istemeyebilirsiniz. Bunun yerine veri hakkında bilgi edinmeyi tercih edebilirsiniz. Bir SELECT sorgusu göndererek, SQL sözdizimini kullanarak verileriniz üzerinde yorum yapabilir veya hesaplamalar çalıştırabilirsiniz. Bunlar toplama (aggregate) fonksiyonları olarak adlandırılır.
The COUNT fonksiyonu, belirli bir kriter kümesini karşılayan satırların sayısını sayar ve döndürür. Örneğin, kaç arkadaşınızın Maldives gitmeyi tercih ettiğini bilmek istiyorsanız aşağıdaki sorguyu kullanabilirsiniz:
|
1 |
mysql> SELECT COUNT(destination) FROM vacation WHERE destination = 'Maldives'; |
Aşağıdaki sonuçlar döndürülecektir:
|
1 2 3 4 5 6 7 |
+--------------------+ | COUNT(destination) | +--------------------+ | 1 | +--------------------+ 1 row in set (0.06 sec) |
MIN belirtilen bir sütundaki en küçük değeri bulmak için kullanılır:
|
1 |
mysql> SELECT MIN(wins) FROM celebration; |
Sorgu şu çıktıyı verecektir:
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(wins) | +-----------+ | 4 | +-----------+ 1 row in set (0.02 sec) |
MAX belirli bir sütundaki en büyük sayısal değeri bulmak için kullanılır:
|
1 |
mysql> SELECT MAX(wins) FROM celebration; |
Beklenen çıktı şu şekildedir:
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(wins) | +-----------+ | 13 | +-----------+ 1 row in set (0.03 sec) |
Hem MIN hem de MAX fonksiyonları sayısal ve alfabetik veriler üzerinde kullanılabilir. Bir dize (string) değerleri sütununa uygulandığında, MIN fonksiyonu alfabetik olarak ilk değeri döndürür.
The MIN fonksiyonu alfabetik olarak ilk değeri döndürür:
|
1 |
mysql> SELECT MIN(name) FROM celebration; |
Çıktı şu şekilde olacaktır:
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(name) | +-----------+ | Aisha | +-----------+ 1 row in set (0.00 sec) |
The MAX fonksiyonu alfabetik olarak son değeri döndürür:
|
1 |
mysql> SELECT MAX(name) FROM celebration; |
Çıktı şu şekilde olacaktır:
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(name) | +-----------+ | Zane | +-----------+ 1 satır içinde küme (0.00 sn) |
Adım 4 — Sorgu Çıktılarını Düzenleme
Kullanılan bir diğer popüler ifade de GROUP BY ifadesidir. Bir sütun üzerinde toplama işlevi gerçekleştirirken, bu işlevi başka bir sütundaki eşleşen değerlerle ilişkilendirmek için kullanılır:
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity; |
Çıktı şu şekilde olacaktır:
|
1 2 3 4 5 6 7 8 9 10 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | kayak | | 1 | yamaç paraşütü | | 1 | dağ tırmanışı | | 1 | balık tutma | +-------------+-------------------+ 4 satır içinde küme (0.04 sn) |
Sorgu sonuçlarını sıralamak için ORDER BY ifadesini kullanın. Sayısal değerler varsayılan olarak artan düzende sıralanırken, metin değerleri alfabetik olarak sıralanır. Aşağıdaki sorgu name ve birthdate sütunlarını listeler, ancak sonuçları birthdate:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate; |
Çıktı aşağıdaki gibi olacaktır:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------------+ | name | birthdate | +--------+------------+ | Zane | 1996-01-01 | | Aisha | 1999-07-24 | | Austin | 2002-01-07 | | Ivan | 2010-12-18 | +--------+------------+ 4 satır içinde küme (0.04 sn) |
Çıktı artan düzendedir; azalan düzende sıralamak için sorguyu şu kelimeyle sonlandırın: DESC:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate DESC; |
Çıktıya göz atın:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------------+ | name | birthdate | +--------+------------+ | Ivan | 2010-12-18 | | Austin | 2002-01-07 | | Aisha | 1999-07-24 | | Zane | 1996-01-01 | +--------+------------+ 4 satır içinde küme (0.00 sn) |
The HAVING ifadesi, WHERE ifadesine benzer bir işlevsellik sağlamak ve aynı zamanda toplama işlevleriyle uyumlu olmak amacıyla SQL'e eklenmiştir. Bu iki ifade arasındaki fark, WHERE ifadesinin tekil kayıtlara başvurması, HAVING ifadesinin ise grup kayıtlarına başvurmasıdır. Bu amaçla, bir HAVING ifadesi kullanıldığında her zaman bir GROUP BY ifadesi de bulunmalıdır:
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity HAVING COUNT(name) >= 1; |
Sorgu şu çıktıyı verecektir:
|
1 2 3 4 5 6 7 8 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | kayak | | 1 | yamaç paraşütü | | 1 | dağ tırmanışı | | 1 | balık tutma | +-------------+-------------------+ |
The COUNT değeri, hiçbir iki arkadaş aynı aktiviteden hoşlanmadığı için hepsinde 1'dir.
Adım 5 — Birden Çok Tabloyu Sorgulama
The JOIN ifadesi, iki veya daha fazla tablodan satırları birleştirmek için bir sorgu sonucunda kullanılabilir. Bunu, tablolar arasında ilişkili bir sütun bularak ve çıktıyı uygun şekilde sıralayarak gerçekleştirir.
SELECT ifadesi içeren JOIN deyimleri aşağıdaki sözdizimini takip eder:
|
1 2 3 |
mysql> SELECT table1.column1, table2.column2 mysql> FROM table1 mysql> JOIN table2 ON table1.related_column=table2.related_column; |
Arkadaşlarınızın her birine, wins ve swimming aktiviteleri için birthdays birer kupa almak isteseydiniz, tek bir sorguyla istediğiniz tüm bilgileri bulmanıza yardımcı olması için her iki tabloyu birleştiren bir sorgu oluşturabilirdiniz:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration JOIN vacation ON celebration.name=vacation.name; |
Çıktı şu şekilde olacaktır:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | +--------+------+------------+ 4 satır içinde küme (0.00 sn) |
Bu bir iç JOIN ifadesidir. Bunun nedeni, her iki tabloda da eşleşen değerlere sahip tüm kayıtları seçmesi ve bunları bir sonuç kümesine yazdırmasıdır. Sorguyla eşleşmeyen kayıtlar dahil edilmez. Tablolarımıza herhangi bir girdiyle eşleşmeyen yeni bir satır ekleyebiliriz:
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Sorgu OK, 1 satır etkilendi (0.01 sn) |
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Sorgu OK, 1 satır etkilendi (0.01 sn) |
Ardından, SELECT ifadesini JOIN ifadesiyle yeniden çalıştırın:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate -> FROM celebration -> JOIN vacation ON celebration.name=vacation.name; +--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | +--------+------+------------+ 4 satır içinde küme (0.00 sn) |
celebration tablosunda Peter için bir girdi bulunmadığından ve vacation tablosunda Ella için bir girdi bulunmadığından, bu kayıtlar mevcut değildir.
Dış bir JOIN ifadesi kullanarak tablolardan birindeki tüm kayıtları döndürebiliriz. Bu bir LEFT JOIN veya bir RIGHT JOIN olabilir. Bir LEFT JOIN sol tablodaki tüm kayıtları ve sağ tablodan yalnızca eşleşen kayıtları döndürür. Dış birleştirmeler bağlamında sol tablo, FROM ifadesi tarafından başvurulan tablodur ve sağ tablo ise JOIN ifadesinden sonra başvurulan herhangi bir tablodur.
Sorguyu bir LEFT JOIN ifadesi kullanarak tekrar çalıştırın:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration LEFT JOIN vacation ON celebration.name=vacation.name; |
Komut, sağ tabloda karşılık gelen bir kayıt olmasa bile sol tablodaki ( celebration) tüm kayıtları döndürecektir. Sağ tabloda eşleşen bir kayıt olmadığında, NULL:
|
1 2 3 4 5 6 7 8 9 10 11 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | | Ella | 1 | NULL | +--------+------+------------+ 5 satır içinde küme (0.00 sn) |
Bu da RIGHT JOIN ifadesidir:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration RIGHT JOIN vacation ON celebration.name=vacation.name; |
Sağ tablodaki (vacation) tüm değerler döndürülecektir. Peter'ın birthdate bilgisi sağ tabloda kayıtlı olup sol tabloda kayıtlı olmadığından, name ve wins sütunları bu satırlarda NULL değerlerini döndürecektir:
|
1 2 3 4 5 6 7 8 9 10 11 |
+--------+------+------------+ | ad | galibiyetler | doğum tarihi | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | | NULL | NULL | 1991-05-03 | +--------+------+------------+ 5 satır içinde küme (0.01 sn) |
Birden fazla tablodan kayıtları sorgulamak için UNION ifadesi yerine JOIN kullanabilirsiniz. UNION operatörü, sonuçları tek bir SELECT ifadesi kullanarak birden fazla tablodan benzersiz sütunlar olarak yazdırmak yerine iki SELECT ifadesinin sonuçlarını tek bir sütunda birleştirmesi bakımından JOIN ifadesinden farklıdır.
Bunu göstermek için bu sorguyu çalıştırabilirsiniz:
|
1 |
mysql> SELECT name FROM celebration UNION SELECT name FROM vacation; |
Sorgu, yinelenen kayıtları kaldırır. Bu, UNION operatörünün varsayılan davranışıdır:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
+--------+ | name | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Peter | +--------+ 6 satır içinde küme (0.00 sn) |
Tüm kayıtları (ve yinelenenleri) döndürmek için UNION ALL operatörünü kullanın:
|
1 |
mysql> SELECT name FROM celebration UNION ALL SELECT name FROM vacation; |
Çıktı:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
+--------+ | name | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Austin | | Ivan | | Aisha | | Zane | | Peter | +--------+ 10 satır içinde küme (0.00 sn) |
Alt sorgular, birden fazla tabloyu sorgulamak için başka bir yöntemdir. Alt sorgular, başka bir sorgunun içine yerleştirilmiş sorgulardır (iç veya iç içe geçmiş sorgular olarak da bilinir). Bunlar, bir sorgunun sonuçlarını ayrı bir toplama işlevinin sonuçlarıyla karşılaştırmak istediğinizde kullanışlıdır.
Ella'dan daha fazla yüzme turnuvası kazanan arkadaşın hangisi olduğunu bulma örneğini kullanacağız. Ella'nın kaç maç kazandığını sorgulayıp ardından bundan daha fazla oyun kazananları görmek için başka bir sorgu çalıştırmak yerine, her ikisini de tek bir sorguyla hesaplayabilirsiniz:
|
1 2 3 4 |
mysql> SELECT name, wins FROM celebration -> WHERE wins > ( -> SELECT wins FROM celebration WHERE name = 'Ella' -> ); |
Sorgu şunları döndürecektir:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+ | name | wins | +--------+------+ | Austin | 4 | | Ivan | 7 | | Aisha | 10 | | Zane | 13 | +--------+------+ 4 satır içinde küme (0.06 sn) |
Arkadaşlarınızı sürpriz bir tatile götürmek isteseydiniz, en çok galibiyete kimin sahip olduğunu görmek ve gidecekleri yeri döndürmek için bir sorgu kullanabilirdiniz:
|
1 2 3 4 |
mysql> SELECT name, destination, activity, meal -> FROM vacation -> WHERE name = ( SELECT name FROM celebration -> WHERE wins = (SELECT MAX(wins) FROM celebration)); |
Sorgu şunları döndürecektir:
|
1 2 3 4 5 6 7 |
+------+-------------+----------+------+ | name | destination | activity | meal | +------+-------------+----------+------+ | Zane | Bora Bora | fishing | Tofu | +------+-------------+----------+------+ 1 satır içinde küme (0.00 sn) |
Bu ifade, bir alt sorgu içinde başka bir alt sorgu içerir.
Sonuç
Sorgu oluşturma, veritabanı yönetimindeki en yaygın görevlerden biridir. Sorgularla çalışmak ve sonuçlarını görselleştirmek için kullanabileceğiniz phpMyAdmin ve pgAdmin gibi çeşitli veritabanı yönetim araçları vardır. Ancak, kullanım kolaylığı ve mükemmel kontrolü nedeniyle komut satırından SELECT ifadesi en çok tercih edilen seçenektir.
Ayrıca, veritabanları hakkında keşfedebileceğiniz birçok öğreticiye blogumuzdan ulaşabilirsiniz:
- SQLite vs. MySQL vs. PostgreSQL: İlişkisel Veritabanı Yönetim Sistemleri Karşılaştırması
- MySQL'de Bozuk Tabloları Onarmak İçin Hızlı Çözümler: Bir Rehber
- Centos 7 Üzerine MySQL Nasıl Kurulur
- MySQL Kullanıcısı — İzinleri Oluşturma ve Yetkilendirme
- Ubuntu Üzerinde MySQL'de Replikasyon Kurulumu
Keyifli Bilişimler!
Yorumlar
Henüz yorum yapılmamış. İlk siz olun.