Teknoloji Haberleri
Aşağı Git
Tüm Forumlar
Web Tasarım - Programlama
Yazılım Geliştirme
MsSQL / MySQL
türkçe php-mysql kaynaklarımızı burada toplayalım
Bu konudaki kullanıcılar: 1 misafir
8
Cevap 3804
Tıklama 0
Öne Çıkarma
Cevap 3804
Tıklama 0
Öne Çıkarma
1. sayfa
-
türkçe php-mysql kaynaklarımızı burada toplayalım
|
yeni bir site keşfettim. tasarım dersleri örneğin; photoshop-flash-php-html güzel ve anlaşılır bir şekilde anlatılmış. forumlarda sordum yeni derslerde çok yakında eklenecekmiş, tavsiye ederim. http://www.dersler.org |
|
Aritmetiksel ifade ve fonksiyonlar..... Bu fonksiyonlar SUM(TOPLAMA),AVG(aritmetiksel ORTALAMA),MAX(Alan içindeki en büyük değeri bulur),MİN(Alan içindeki en küçük değeri bulur) ... SELECET SUM(alan_adi) AS sanal_alan FROM tablo_adi ....... isterseniz işlemi SUM komutu içindede gerçekleştirebilirsiniz... alanlar arasında işlemlerde yapabilirsiniz... SELECT SUM(alan_adi1+alan_adi2) AS sanal_alan FROM tablo_adi...... size alan1 ve alan 2 deki bütün değerleri toplayacaktır...  |
|
peacewolfus arkadaşım çok sağol bayağı emek harcamışsın bunca emeğe teşekkür etmemek ayıp olur  |
Bu mesaja 1 cevap geldi.
Asıl ben tşkr ederim...  |
< Bu mesaj bu kişi tarafından değiştirildi peacewolfus -- 21 Aralık 2005 13:33:20 >
Arkadaslar gerçi yukarıda topicet actım fakat burdada belitmek istedim ..Arkadaslar Benim ms sqlde bir ödevim var da ufak bir veritabanı oluşturarak ... """arkadaşlar ms sql de ki bir veritabanı oluşturarak ve en önemlisi ödevde genel amaç bu zaten Trigger kullanarak bu veritabanında Update,insert,delete vs işlemleri yapacak 1- 2sayfa örnekler yazarsanız bana Sewinirim.. yardımlarınızı bekliooorum..çok önemli Ödev Arkadaşlar.. edit:yaw 1-2 sayfa söyle ufak bi veritabanında Yukarıda dedğim işllemleri yapacak örnek bekliyorum arkadaslar """ |
Bu mesaja 1 cevap geldi.
|
Teşekkürler bilgiler için peacewolfus kardeş. Fulltext arama hakkında da bilgi verir misin? nette araştırdıklarım ve öğrendiklerim ile bir türlü istediğimi bulduramıyorum. özetle, kelime grubu aramak istiyorum ancak istediğim sonuçları vermiyor. örneğin "ahmet efendi" aramak istediğimde, cümle içinde "... ahmet efendinin ..." şeklinde geçiyorsa buradaki ahmet efendiyi bulmuyor. cümle içince değişik yerlerde ahmet ve efendi geçiyorsa getirmesini istemiyorum ama. kaynaklarda kelime sonuna * (yıldız) koyarak ekli kelimeleri aratabilirsiniz diyor ama "ahmet efendi"* şeklini kabül etmiyor. yani bir türlü işin içinde çıkamadım. |
Php DE MYSQL KULLANIMINA İLİŞKİN BASİT BİR KOD ÖRNEĞİ: <?php |
Bu mesaja 1 cevap geldi.
sunucu adı-parolası v.s.. gibi bilgileri ayrı bir text halinde yazmak, daha kolaydır :EXAMPLE <? php |
1. sayfa
DH Mobil uygulaması ile devam edin.
Mobil tarayıcınız ile mümkün olanların yanı sıra, birçok yeni ve faydalı özelliğe erişin.
Gizle ve güncelleme çıkana kadar tekrar gösterme.
3 Özel MySQL Dersi
Bu bölüm, basit bir veritabanı oluşturmak ve kullanmak için mysql istemci programının nasıl kullanılacağını göstererek MySQL'e giriş tarzında bir özel ders vermektedir. (Bazen uçtaki monitör yada sadece monitör olarak anılan) mysql, bir MySQL sunucusuna bağlanmanıza, sorgu gerçekleştirmenize ve sonuçları görmenize olanak sağlayan, iki yönlü etkileşen bir programdır. mysql yığın modunda da kullanılabilir: sorgularınızı önceden bir dosyaya yerleştirirsiniz, sonra mysql'e dosyanın içindekileri çalıştırmasını söylersiniz. Burada mysql'i kullanmanın her iki yolundan da bahsedilmektedir.
mysql'in size sunduğu seçeneklerin bir listesini görmek için mysql'i --help seçeneğiyle çalıştırın:
kabuk> mysql --help
Bu bölüm, mysql'in makinanızda kurulu olduğunu ve kullanabileneceğiniz bir MySQL sunucusunun mevcut olduğunu farzetmektedir. Eğer bağlanabileceğiniz bir sunucu yoksa MySQL yöneticinizle temasa geçin (eğer yönetici siz iseniz, bu kılavuzun diğer bölümlerine bakmanız gerekecektir).
Bu bölüm, bir veritabanının oluşturulması ve kullanılması işleminin tamamını anlatmaktadır. Eğer siz sadece önceden var olan bir veritabanına ulaşmakla ilgileniyorsanız, veritabanı ve içindeki tabloların nasıl oluşturulacağını anlatan kısımları es geçmek isteyebilirsiniz.
Bu bölüm, içerik itibariyle özel bir ders niteliğinde olduğundan zorunlu olarak birçok ayrıntının üzerinde durulmadı. Burada bahsi geçen konular hakkında daha fazla bilgi için kılavuzun diğer bölümlerine göz atın.
3.1 Sunucuya Bağlanma ve Sunucuyla Bağlantının Kesilmesi
Sunucuya bağlanmak için mysql'i çalıştırdığınız zaman genellikle bir MySQL kullanıcı adı ve, büyük bir ihtimalle, bir de şifre vermeniz gerekecektir. Eğer sunucu, sizin bağlandığınız makina dışında bir makinada çalışıyorsa, bir sunucu makina adı da belirtmeniz gerekecektir. Sunucuya bağlanmak amacıyla hangi bağlantı parametrelerini kullanmanız gerektiğini öğrenmek (yani hangi sunucu makina adı, kullanıcı adı ve şifreyi kullanmak) için yöneticinizle temasa geçin. Uygun parametreleri öğrendikten sonra şu şekilde bağlanabilmeniz gerekir:
kabuk> mysql -h sunucu_makina_adı -u kullanıcı_adı -p
Enter Password: ********
******** sizin şifrenizi temsil eder; mysql, Enter password: promptunu gösterdiği zaman şifrenizi girin.
Eğer bu çalışırsa, mysql> promptundan önce giriş niteliğinde biraz bilgi görmeniz gerekmektedir:
kabuk> mysql -h sunucu_makina_adı -u kullanıcı_adı -p
Enter password: ********
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 459 to server version: 3.22.20a-log
Type 'help' for help.
mysql>
Bazı MySQL kurulumları, kullanıcıların yerel bilgisayarda çalışan sunucuya anonim (isimsiz) kullanıcı olarak bağlanmasına izin vermektedir. Eğer sizin makinanızda da durum böyleyse, mysql'i herhangi bir seçenek (parametre) vermeksizin çalıştırarak sunucuya bağlanabilmeniz gerekmektedir:
kabuk> mysql
Başarılı bir şekilde bağlantıyı sağladıktan sonra, herhangi bir zamanda mysql> promptunda QUIT tuşlayarak bağlantıyı kesebilirsiniz:
mysql>QUIT
Bye
Control-D tuşuna basarak ta bağlantıyı kesebilirsiniz.
İlerleyen bölümlerdeki örneklerin çoğu bir sunucuya bağlı olduğunuzu farzetmektedir. Örneklerde bu, mysql> promptuyla gösterilmiştir.
3.2 Sorguların Girilmesi
Önceki bölümde anlatıldığı şekilde sunucuya bağlandığınızdan emin olun. Bu şekilde bağlanmış olmanız üzerinde çalışabileceğiniz herhangi bir veritabanını seçmeyecektir ancak şimdilik tamamdır. Şu an için nasıl sorgu yapılacağına dair birşeyler öğrenmek, direkt atlayıp tablolar oluşturmak; içlerinde veri depolamak ve tablolardan veri çekmekten daha önemlidir. Bü bölüm mysql'e komut girmenin temel prensiplerini anlatmaktadır. Çeşitli sorguları kullanarak kendinizi mysql'in nasıl çalıştığına alıştırmayı deneyebilirsiniz.
İşte size sunucudan sürüm numarasını ve o anki tarihi söylemesini isteyen basit bir komut. Komutu aşağıda gösterildiği gibi mysql promptundan sonra yazın ve ENTER tuşuna basın:
mysql> SELECT VERSION(), CURRENT_DATE;
+--------------+--------------+
| version() | CURRENT_DATE |
+--------------+--------------+
| 3.22.20a-log | 1999-03-19 |
+--------------+--------------+
1 row in set (0.01 sec)
mysql>
Bu sorgu mysql hakkında birkaç şeyi açıklamaktadır:
Bir komut, normal olarak, noktalı virgülün izlediği bir SQL cümleciğinden oluşmaktadır. (Noktalı virgülün gerekmediği birkaç istisna komut vardır. Daha önce bahsi geçen QUIT bunlardan biridir. Diğerlerine sonra geleceğiz.)
Bir komutu girdiğinizde, mysql, komutu çalıştırması için sunucuya yollar ve sonucu görüntüler; sonra başka bir komutun girilebilmesi için hazır olduğınu belirtmek amacıyla ekrana başka bir mysql> yazar.
mysql, sorgu sonucunu tablo olarak görüntüler (satır ve sütunlarla). İlk satır sütunlar için etiketleri içerir. Takip eden satırlarda sorgu sonuçları yer alır. Normalde sütun etiketleri (adları), veritabanı tablolarından çektiğiniz sütunların isimleridir. Eğer (az önceki örnekte olduğu gibi) bir tablo sütunu yerine bir ifadenin değerini alıyorsanız, mysql, ifadenin kendisini kullanarak sütunu etiketler.
mysql, kaç tane satırın dönderildiğini ve sunucu performansı hakkında kabaca bir fikir veren sorgunun gerçekleştirilme süresini de gösterir. Bu değerler kesin değildir çünkü duvar saati zamanını (wall clock time) gösterirler (CPU yada makine zamanını göstermezler) ve sunucudaki yük ile ağdaki belirsizlik gibi faktörlerden etkilenirler. (Gereksiz uzatmadan kaçınmak için bu bölümdeki geri kalan örneklerde "rows in set" (gruptaki satir sayısı) satırı gösterilmemektedir.)
Anahtar sözcükler büyük-küçük harf sırası gösterilmeksizin girilebilmektedir. Aşağıdaki sorguların hepsi birbiriyle denktir:
mysql> SELECT VERSION(), CURRENT_DATE;
mysql> select version(), current_date;
mysql> SeLeCt vErSiOn(), current_DATE;
mysql'i basit bir hesap makinesi olarak kullanabileceğiniz başka bir sorgu:
mysql> SELECT SIN(PI()/4), (4+1)*5;
+-------------+---------+
| SIN(PI()/4) | (4+1)*5 |
+-------------+---------+
| 0.707107 | 25 |
+-------------+---------+
Buraya kadar gösterilen komutlar göreceli olarak kısa, tek-satırlı cümleciklerdi. Birden fazla cümleciği tek satırda da girebilirsiniz. Her cümleciğin sonuna bir noktalı virgül eklemeniz yeterlidir:
mysql> SELECT VERSION(); SELECT NOW();
+--------------+
| version() |
+--------------+
| 3.22.20a-log |
+--------------+
+---------------------+
| NOW() |
+---------------------+
| 1999-03-19 00:15:33 |
+---------------------+
Bir komutun tamamiyle tek bir satırda girilmesi zorunlu değildir; bu sayede birkaç satırda girilmesi gereken uzun komutlar herhangi bir sorun oluşturmazlar. mysql, cümleciğinizin nerede bittiğini girdi satırının sonuna bakarak değil de, cümleciği sonlandıran noktalı virgüle bakarak belirler. (Başka bir deyişle mysql, girdiyi biçimden bağımsız bir şekilde kabul eder: girdi satırlarını biriktirir ancak noktalı virgülü görene kadar onları çalıştırmaz.)
İşte size çoklu-satırdan oluşan basit bir sorgu:
mysql> SELECT
-> USER()
-> ,
-> CURRENT_DATE;
+--------------------+--------------+
| USER() | CURRENT_DATE |
+--------------------+--------------+
| joesmith@localhost | 1999-03-18 |
+--------------------+--------------+
Bu örnekte çoklu-satırdan oluşan bir sorgunun ilk satırını girdikten sonra promptun nasıl mysql'den ->'ine dönüştüğüne dikkat edin. Bu, tamamlanmış bir cümlecik bulamayıp devamını beklerken, mysql'in bunu nasıl gösterdiğini anlatmaktadır. Prompt sizin yardımcınızdır çünkü size değerli bir geribildirim sunar. Bu geribildirimi kullanırsanız her zaman için mysql'in neyi beklediğinin farkında olursunuz.
Eğer yazmakta olduğunuz komutu çalıştırmak istemediğinize karar verirseniz \c tuşlayarak cümleciği iptal edin:
mysql> SELECT
-> USER()
-> \c
mysql>
Burada, yine, prompta dikkat edin. Prompt, siz \c tuşladıktan sonra, mysql'in yeni bir komut için hazır olduğunu belirtmek amacıyla, geribildirim sağlayacak şekilde, mysql>'ne geri dönmektedir.
Aşağıdaki tablo görebileceğiniz promptların her birini göstermekte ve mysql'in bulunduğu durum hakkında ne anlama geldiklerini özetlemektedir:
Prompt Anlamı
mysql> Yeni bir komut için hazır
-> Çoklu-satırdan oluşan bir komutun sonraki satırını bekliyor
'> Sonraki satırı bekliyor ancak tek tırnakla başlamış bir karakter dizisini okuyor
"> Sonraki satırı bekliyor ancak çift tırnakla başlamış bir karakter dizisini okuyor
Çoklu-satırdan oluşan cümlecikler çoğunlukla tek bir satırda komutu çalıştırmaya niyetlenip, kazara sondaki noktalı virgülü unuttuğunuz zamanlarda ortaya çıkar. Bu durumda mysql daha fazla girdi için bekleyecektir:
mysql> SELECT USER()
->
Eğer bu başınıza gelirse (cümleciği girdiğinizi sanmanıza karşın yanıt sadece -> promptu ise), büyük bir ihtimalle mysql noktalı virgülü beklemektedir. Eğer promptun size ne söylediğine dikkat etmezseniz, ne yapmanız gerektiğini farketmeden önce bir müddet öylece oturmaya devam edebilirsiniz. Cümleciği tamamlamak için bir noktalı virgül ekleyip ENTER tuşuna basın; mysql komutu çalıştıracaktır:
mysql> SELECT USER()
-> ;
+--------------------+
| USER() |
+--------------------+
| joesmith@localhost |
+--------------------+
'> ve "> promptları karakter dizisi okunurken ortaya çıkmaktadır. MySQL'de karakter dizilerini (') ve (") karakterleri arasında girebilirsiniz (örneğin 'merhaba' veya "hoşçakal") ve mysql, birden fazla satıra yayılan karakter dizilerini girmenize izin vermektedir. Bir '> veya "> promptunu gördüğünüz zaman bu, (') veya (") karakteri ile başlayan bir karakter dizisini içeren bir satır girdiğinizi, ancak karakter dizisini bitirecek olan uygun tırnak işaretini henüz girmediğinizi gösterir. Eğer gerçekten çoklu-satırdan oluşan bir karakter dizisi giriyorsanız bu iyi bişeydir; fakat ne kadar sık böylesi birşey girersiniz? Çok değil. Çoğunlukla '> ve "> promptları, farkında olmaksızın tek veya çift tırnak işaretini unuttuğunuzun göstergesidir. Örneğin:
mysql> SELECT * FROM my_table WHERE name = "Smith AND age < 30;
">
Eğer bu SELECT cümleciğini girer ve ENTER tuşuna basıp sonucu beklerseniz hiçbir şey olmayacaktır. Bu sorgunun neden bu kadar uzun sürdüğünü merak etmek yerine "> promptunun verdiği ipucuna dikkat edin. Prompt size mysql'in, sonlandırılmamış (bitirilmemiş) bir karakter dizisinin kalan kısmını görmek için beklediğini söylemektedir. (Cümlecikteki hatayı görebiliyor musunuz? "Smith karakter dizisinin ikinci çift tırnağı yok.)
Bu noktada ne yaparsınız? Yapılacak en basit şey komutu iptal etmektir. Ancak bu durumda sadece \c tuşlayamazsınız çünkü mysql bunu okumakta olduğu karakter dizisinin bir parçası olarak yorumlayacaktır. Bunun yerine uygun tırnak işaretiyle diziyi sonlandırın (böylece mysql karakter dizisini bitirdiğinizi bilecektir), sonra da \c tuşlayın:
mysql> SELECT * FROM my_table WHERE name = "Smith AND age < 30;
"> "\c
mysql>
Prompt, mysql'in yeni bir komut için hazır olduğunu gösteren mysql>'ne geri dönecektir. '> ve "> promptlarının ne anlama geldiğini bilmek önemlidir çünkü yanlışlıkla sonlandırılmamış bir karakter dizisi girdiğinizde, sonradan gireceğiniz herhangi bir satır, QUIT anahtar sözcüğünü içeren bir satır da dahil, mysql tarafından dikkate alınmıyormuş gibi görünecektir. Bu hayli kafa karıştırıcı olabilir; özellikle de halihazırdaki komutu (cümleciği) iptal edebilmek için önce diziyi sonlandıracak uygun tırnak işaretini girmeniz gerektiğini bilmediğinizde
3.3 Bir Veritabanının Oluşturulması ve Kullanılması
Artık nasıl komut gireceğinizi bildiğinize göre bir veritabanına ulaşmanın zamanı geldi.
Farzedin ki evinizde (hayvan topluluğunuzda (menagerie de)) birçok evcil hayvanınız var ve siz onlarla ilgili çeşitli türde bilginin kaydını tutmak istiyorsunuz. Bu işi, verilerinizi tutacak tablolar oluşturup, tablolara arzu ettiğiniz bilgiyi yükleyerek gerçekleştirebilirsiniz. Sonra tablolardan veri çekerek hayvanlarınız hakkında çeşitli türde soruları yanıtlayabilirsiniz. Bu bölüm size:
Bir veritabanı oluşturma
Bir tablo oluşturma
Bir tabloya veri yükleme
Bir tablodan çeşitli şekillerde veri çekme
Çok sayıda tabloyu kullanma
işinin nasıl yapılacağını göstermektedir.
hayvan topluluğu (menagerie) veritabanı (kasten, bilerek) basit olacak ancak benzer türde bir veritabanının kullanılabileceği gerçek durumları düşünmek zor olmayacaktır. Örneğin, bunun gibi bir veritabanı bir çiftçi tarafından çiftlik hayvanlarının yada bir veteriner tarafından hasta hayvan kayıtlarının hesabını tutmak için kullanılabilir. İlerleyen bölümlerde kullanılan bazı sorguları ve örnek verileri içeren bir hayvan topluluğu dağıtımı MySQLin web sayfasından tenim edilebilir. Dağıtım, sıkıştırılmış olarak 'tar' (http://www.mysql.com/Downloads/Cont...enagerie.tar.gz) veya 'Zip' (http://www.mysql.com/Downloads/Cont...s/menagerie.zip) formatında mevcuttur.
Sunucuda halihazırda hangi veritabanlarının bulunduğunu öğrenmek için SHOW cümleciğini kullanın:
mysql> SHOW DATABASES;
+----------+
| Database|
+----------+
| mysql |
| test |
| tmp |
+----------+
Mevcut veritabanlarının listesi, büyük ihtimalle, sizin makinanızda farklılık gösterecektir ancak mysql ve test veritabanları muhtemelen listede yer alacaktır. mysql veritabanı gereklidir çünkü kullanıcı erişim haklarını anlatmaktadır. test veritabanı ise çoğunlukla kullanıcıların birşeyler deneyebilecekleri bir çalışma alanı olarak önceden hazırlanmaktadır.
Eğer test veritabanı mevcut ise ona bağlanmaya çalışın:
mysql> USE test
Database changed
USE'ın da QUIT gibi noktalı virgüle ihtiyaç duymadığına dikkat edin. (isterseniz bu tip cümlecikleri noktalı virgülle sonlandırabilirsiniz, bir sakıncası olmaz.) USE cümleciği başka bir yönüyle de istisnadır: tek bir satırda verilmasi gerekir.
(Erişim hakkınız varsa) izleyen örnekler için test veritabanını kullanabilirsiniz; ancak bu veritabanında oluşturacağınız herhangi birşey, bu veritabanına erişim hakkı olan bir başkası tarafından silinebilir. Bu sebepten dolayı muhtemelen MySQL yöneticinizden kendinize ait bir veritabanını kullanabilmek için izin istemeniz gerekecektir. Farzedelim kendi veritabanınızın adının "hayvan_toplulugu" olmasını istiyorsunuz. Bu durumda yöneticinin aşağıdaki gibi bir komutu çalıştırması gerekir:
mysql> GRANT ALL ON hayvan_toplulugu.* TO sizin_mysql_adınız;
Burada sizin_mysql_adınız size atanan MySQL kullanıcı adınızdır.
3.3.1 Bir Veritabanının Oluşturulması ve Seçilmesi
Eğer yöneticiniz izinlerinizi ayarlarken sizin için veritabanınızı oluşturduysa onu kullanmaya başlayabilirsiniz. Aksi takdirde veritabanınızı kendiniz oluşturmalısınız:
mysql> CREATE DATABASE hayvan_toplulugu;
Unix altında (SQL anahtar sözcüklerinin aksine) veritabanı isimleri büyük-küçük harf duyarlıdır. Bundan dolayı veritabanınızı her zaman hayvan_toplulugu diye belirtmelisiniz; Hayvan_Toplulugu, HAYVAN_TOPLULUGU yada başka bir çeşitlemeyi kullanmamalısınız. Bu tablo isimleri için de doğrudur. (Her ne kadar verilen bir sorgu içinde vertabanlari ve tablolardan bahsederken harfleri aynı şekilde kullanmanız gerekse de, Windows altında bu sınırlama geçerli değildir.)
Bir veritabanını oluşturmak, onu kullanmak için seçmez; bunu açık bir şekilde sizin yapmanız gerekmektedir. hayvan_toplulugu'nu geçerli veritabanı yapmak için şu komutu kullanın:
mysql> USE hayvan_toplulugu
Database changed
Veritabanınızın sadece bir defa oluşturulması gerekir; ancak mysql oturumuna her başlayışınızda veritabanını kullanabilmek için seçmeniz gerekmektedir. Bunu yukarıda gösterildiği gibi USE cümleciğini çalıştırarak yapabilirsiniz. İkinci bir yol olarak, mysql'i çalıştırıken komut satırında veritabanını seçebilirsiniz. Vermeniz gerekn bağlantı parametrelerinden hemen sonra veritabanının adını belirtin. Örneğin:
kabuk> mysql -h sunucu_makina_adı -u kullanıcı_adı -p hayvan_toplulugu
Enter password: ********
Hemen yukardaki gösterilen komuttaki hayvan_toplulugu'nun sizin şifreniz olmadığına dikkat edin. Eğer şifrenizi komut satırında hemen -p seçeneğinden sonra vermek istiyorsanız, bunu arada boşluk bırakmaksızın yapmalısınız (mesela, -pbenim_sifrem şeklinde; -p benim_sifrem şeklinde değil). Bununla beraber şifrenizi komut satırına yazmamanız tavsiye edilir, çünkü bunu yapmanız, şifrenizi makinanıza bağlanan diğer kullanıcılar tarafından görülebilir hale getirir.
3.3.2 Bir Tablonun Oluşturulması
Bir veritabanı oluşturma işin kolay kısmıdır. SHOW TABLES komutunun da göstereceği gibi veritabanınız henüz boştur:
mysql> SHOW TABLES;
Empty set (0.00 sec)
İşin zor kısmı veritabanınızın yapısının nasıl olacağına karar vermektir: hangi tablolara ihtiyacınız olacak ve tabloların her birinde hangi sütunlar bulunacak.
Her bir hayvanınız için bir kayıt tutacak bir tablo isteyeceksiniz. Bu tabloya hayvanlar tablosu denebilir ve tablo, olabilecek en küçük haliyle, her hayvanın ismini içermelidir. İsim tek başına pek te ilgi çekici olmadığından tabloda başka bilgiler de olmalıdır. Mesela ailede birden fazla insanın hayvanı varsa, her hayvan sahibinin adını da listelemek isteyebilirsiniz. tür ve cinsiyet gibi bazı temel tasvir edici bilgileri de kaydetmek isteyebilirsiniz.
Yada hayvanların yaşları? İlginizi çekebilir, ancak yaş, bir veritabanında saklanacak iyi birşey değildir. Bunun yerine doğum tarihi gibi değişmeyen (sabit) bir değeri saklamak daha iyidir. Sonrasında ne zaman bir yaşa ihtiyaç duyarsanız, bunu, o günün tarihiyle doğum tarihi arasındaki fark olarak hesaplayabilirsiniz. MySQL , tarih işlemlerinde kullanılmak üzere fonksiyonlar sunar, dolayısıyla bu hesaplama zor bir iş değildir. Yaş yerine doğum tarihini saklamanın başka avantajları da vardır:
Veritabanını, hayvanların yaklaşan doğum günlerini hatırlatacak notları oluşturmak gibi işleri yapmada kullanabilirsiniz. (Bu tarz bir sorguyu gerçekleştirmenin biraz aptalca olduğunu düşünüyorsanız, bunun, bilgisayar yardımıyla kişiye özel ilgi göstermek amacıyla yakında doğum günü tebriği yollamanız gereken kullanıcıların kimliklerini belirleyeceğiniz iş dünyasındaki bir veritabanı gibi bir durumda sorma ihtimaliniz bulunan soruyla aynı olduğuna dikkat edin.)
Yaşı, o günün tarihi dışında başka zamanlara göre hesaplayabilirsiniz. Mesela, veritabanında ölüm tarihlerini de tutarsanız, öldüğü zaman bir hayvanın kaç yaşında olduğunu kolayca hesaplayabilirsiniz.
Hayvan tablosunda faydalı olabilecek başka bilgi tiplerini de düşünebilirsiniz ancak şu ana dek bahsettiklerimiz şimdilik yeterlidir: isim, sahibi, tür, cinsiyet, doğum ve ölüm.
Tablonuzun düzenini belirtmek için CREATE TABLE cümleciğini kullanın:
mysql> CREATE TABLE hayvanlar (isim VARCHAR(20), sahibi VARCHAR(20),
-> tur VARCHAR(20), cinsiyet CHAR(1), dogum DATE, olum DATE);
isim, sahibi ve tur sütünları için VARCHAR iyi bir seçimdir çünkü sütunlara kaydedilecek olan değerlerin uzunlukları değişken olacaktır. Bu sütunların tümünün uzunlukları aynı yada 20 olmak zorunda değildir. 1'den 255'e kadar herhangi bir sayıyı kullanabilirsiniz; hangisi sizin için en makul görünüyorsa. (Eğer kötü bir seçim yaparsanız ve ilerde daha uzun bir alana ihtiyaç duyduğunuz ortaya çıkarsa, MySQL size ALTER TABLE cümleciğini de sunmaktadır.)
Hayvanlarin cinsiyeti birden fazla şekilde gösterilebilir; örneğin: "e" ve "d", veya belki de "erkek" ve "dişi" şeklinde. En kolayı "e" ve "d" tek karakterlerini kullanmaktır.
DATE veri tipinin dogum ve olum sütunları için kullanılması oldukça belirgin (açık, aşikar) bir seçimdir.
Şimdi tabloyu oluşturduğunuza göre SHOW TABLES biraz çıktı üretmelidir:
mysql> SHOW TABLES;
+----------------------------+
| Tables in hayvan_toplulugu |
+----------------------------+
| hayvanlar |
+----------------------------+
Tablonuzun tahmin ettiğiniz şekilde oluşturulduğunu sınamak için bir DESCRIBE cümleciği kullanın:
mysql> DESCRIBE hayvanlar;
+----------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+-------+
| isim | varchar(20) | YES | | NULL | |
| sahibi | varchar(20) | YES | | NULL | |
| tur | varchar(20) | YES | | NULL | |
| cinsiyet | char(1) | YES | | NULL | |
| dogum | date | YES | | NULL | |
| olum | date | YES | | NULL | |
+----------+-------------+------+-----+---------+-------+
DESCRIBE cümleciğini her zaman, mesela tablonuzdaki sütunların adlarını yada sütunlardaki veri tiplerini unuttuğunuz zaman, kullanabilirsiniz.
3.3.3 Bir Tabloya Verinin Yüklenmesi
Tablonuzu oluşturduktan sonra içine birşeyler doldurmanız gerekecektir. LOAD DATA ve INSERT cümlecikleri bu işte faydalıdır.
Farzedelim ki, hayvanlarınıza ait kayıtlar aşağıdaki gibi gösterilebiliyor. (MySQLin tarihleri YYYY-AA-GG biçiminde beklediğine dikkat edin; bu alışkın olduğunuzdan farklı olabilir.)
isim sahibi tur cinsiyet dogum olum
Fluffy Harold kedi d 1993-02-04
Claws Gwen kedi e 1994-03-17
Bufy Harold köpek d 1989-05-13
Fang Benny köpek e 1990-08-27
Bowser Diane köpek e 1989-08-31 1995-07-29
Chirpy Gwen kuş d 1998-09-11
Whistler Gwen kuş 1997-12-09
Slim Benny yılan e 1996-04-29
Boş bir tabloyla işe başladığınızdan, bu tabloya veri eklemenin en kolay yolu, önce her hayvanınız için bir satır içeren bir düzyazı dosyası oluşturup, sonra bu dosyanın içeriğini tabloya tek bir cümlecikle yüklemektir.
Her satırda bir kayıt içeren, değerlerin tab karakterleriyle ayrıldığı ve sütunlardaki değerlerin CREATE TABLE cümleciğinde belirtilen sırayla verildiği 'hayvanlar.txt' gibi bir düzyazı dosyası oluşturabilirsiniz. Olmayan değerler için (cinsiyeti bilinmeyen hayvanlar yada yaşamakta olan hayvanların ölüm tarihleri gibi) NULL değerlerini kullanabilirsiniz. Bu değerleri dosyanızda göstermek için '/N'yi kullanın. Örneğin Whistler adlı kuş için kaydınız şöyle gözükecektir (değerler arasındaki boşluğun tek bir tab karakteri olduğunu unutmayın):
Whistler Gwen kuş \N 1997-12-09 \N
'hayvanlar.txt' düzyazı dosyasını hayvanlar tablosuna yüklemek için şu komutu kullanın:
mysql> LOAD DATA LOCAL INFILE "hayvanlar.txt" INTO TABLE hayvanlar;
Dilerseniz 'sütün değeri ayıracı' ve 'satır sonu işaretçisi'ni LOAD DATA cümleciğinde açıkça belirtebilirsiniz ancak siz belirtmediğiniz sürece varsayılan değerler 'tab' ve 'satır sonu'dur. Bu ikisi, cümleciğin 'hayvanlar.txt' dosyasını uygun bir şekilde okuması için yeterlidir.
Her defasında bir kayıt eklemek istediğiniz durumlarda INSERT cümleciği daha yararlıdır. INSERT cümleciğinin en basit kullanılış şeklinde, her sütün için, CREATE TABLE cümleciğinde sütunların belirtildiği sırayla değerleri verirsiniz. Farzedelim ki Diane Puffball adında yeni bir hamster satın aldı. Yeni bir kaydı bir INSERT cümleciğiyle şu şekilde ekleyebilirsiniz:
mysql> INSERT INTO hayvanlar
-> VALUES ('Puffball','Diane','hamster','d','1999-03-30',NULL);
Burada karakter dizisi ve tarih değerlerinin 'tırnaklı karakter dizileri' (quoted strings) şeklinde belirtildiğine dikkat edin. Ayrıca, olmayan bir değeri göstermek amacıyla, direkt olarak INSERT'le NULL değerini girebildiğinize de dikkat edin. LOAD DATA'yla yaptığınız gibi '\N'yi kullanmamaktasınız.
Bu örnek sayesinde, kayıtlarınızı, başlangıçta tek bir LOAD DATA cümleciği kullanmak yerine birçok INSERT cümleciği kullanarak bir tabloya girdiğinizde, tuşlamanız gereken çok daha fazla şeyin olduğunu görebilmelisiniz
3.3.4 Bir Tablodan Bilgi Çekilmesi
Bir tablodan bilgi çekmek için SELECT cümleciği kullanılır. Cümleciğin genel yapısı şöyledir:
SELECT ne_seçilecek
FROM hangi_tablo
WHERE sağlanacak_koşullar
ne_seçilecek görmek istediğiniz şeyleri gösterir. Bu, tablodaki sütunların isimlerinden oluşan bir liste yada tüm sütunlar anlamına gelen * olabilir. hangi_tablo, içinden veriyi çekmek istediğiniz tabloyu gösterir. WHERE cümleciği ise isteğe bağlıdır. sağlanacak_koşullar, verildiği takdirde, sütünların tablodan çekilebilmek için sağlamaları gereken şartları belirler.
3.3.4.1 Tüm Verinin Seçilmesi
SELECT cümleciğinin en basit hali bir tablodaki herşeyi çeker:
mysql> SELECT * FROM hayvanlar;
+----------+--------+---------+----------+------------+------------+
| isim | sahibi | tur | cinsiyet | dogum | olum |
+----------+--------+---------+----------+------------+------------+
| Fluffy | Harold | kedi | d | 1993-02-04 | NULL |
| Claws | Gwen | kedi | e | 1994-03-17 | NULL |
| Buffy | Harold | köpek | d | 1989-05-13 | NULL |
| Fang | Benny | köpek | e | 1990-08-27 | NULL |
| Bowser | Diane | köpek | e | 1998-08-31 | 1995-07-29 |
| Chirpy | Gwen | kuş | d | 1998-09-11 | NULL |
| Whistler | Gwen | kuş | NULL | 1997-12-09 | NULL |
| Slim | Benny | yılan | e | 1996-04-29 | NULL |
| Puffball | Diane | hamster | d | 1999-03-30 | NULL |
+----------+--------+---------+----------+------------+------------+
SELECT'in bu hali, tüm tabloyu gözden geçirmek istediğiniz zamanlarda faydalıdır; mesela tabloya başlangıçtaki veri kümesini yükledikten hemen sonra. Bu arada, yukarıdaki çıktı veri dosyanızdaki bir hatayı ortaya çıkardı: Bowser öldükten sonra doğmuş gibi gözükmekte! Orjinal dökümanlarınıza baktığınızda gördünüz ki Bowser'ın doğru doğum yılı 1989'muş, 1998 değil.
Bu hatayı düzeltmnin en az birkaç yolu vardır:
Hatayı düzeltmek için 'hayvanlar.txt' dosyasını düzeltin; sonra DELETE ve LOAD DATA komutlarını kullanarak tabloyu boşaltıp tekrar doldurun:
mysql> SET AUTOCOMMIT=1; # Tablonun hızlı bir şekilde yeniden oluşturulması için kullanılır
mysql> DELETE FROM hayvanlar;
mysql> LOAD DATA LOCAL INFILE "hayvanlar.txt" INTO TABLE hayvanlar;
Bunu yapmakla beraber, Puffball'ın kaydını tekrar girmeniz gerekecektir. (Puffball'ı daha önce INSERT'le girmştiniz.)
Sadece hatalı kaydı, bir UPDATE cümleciğiyle düzeltin:
mysql> UPDATE hayvanlar SET dogum = "1989-08-31" WHERE isim = "Bowser";
Yukarıda gösterildiği gibi, bir tablonun tamamını çekmek kolaydır. Ancak her zaman bunu yapmak istemeyeceğiniz yeterince açıktır; özellikle de tablonuz çok büyüdüğünde. Bunun yerine genellikle istediğiniz bilgi üzerinde belirli sınırlamalar belirleyeceğiniz durumlarla, bazı soruların yanıtlarıyla ilgileneceksiniz. Hayvanlarınız hakkında yanıtladıkları bazı sorulara göre birkaç seçim sorgusuna göz atalım.
3.3.4.2 Belirli Satırların Seçilmesi
Tablodan sadece belirli satırları seçebilirsiniz. Örneğin; Bowser'ın doğum tarihinde yaptığınız değişikliği sınamak istiyorsanız Bawser'ın kaydını şu şekilde seçin:
mysql> SELECT * FROM hayvanlar WHERE isim = "Bowser";
+--------+-------+-------+----------+------------+------------+
| isim | sahibi| tur | cinsiyet | dogum | olum |
+--------+-------+-------+----------+------------+------------+
| Bowser | Diane | köpek | e | 1989-08-31 | 1995-07-29 |
+--------+-------+-------+----------+------------+------------+
Aldığımız çıktı, yılın şimdi doğru bir şekilde, 1989 değil de 1998 olarak, kaydedildiğini onaylıyor.
Karakter dizilerinin karşılaştırılması normalde büyük-küçük harften bağımsızdır; yani siz ismi "BOWSER", "bowser" v.s olarak ta verebilirsiniz. Sorgunun sonucu yine aynı oacaktır.
Sadece isim sütunu için değil, tüm sütunlar için şartlar belirtebilirsiniz. Mesela; hangi hayvanların 1998'den sonra dığduğunu öğrenmek istiyorsanız dogum sütununu test edin:
mysql> SELECT * FROM hayvanlar WHERE dogum >= "1998-1-1";
+----------+--------+---------+----------+------------+------+
| isim | sahibi | tur | cinsiyet | dogum | olum |
+----------+--------+---------+----------+------------+------+
| Chirpy | Gwen | kuş | d | 1998-09-11 | NULL |
| Puffball | Diane | hamster | d | 1999-03-30 | NULL |
+----------+--------+---------+----------+------------+------+
Mesela, dişi köpekleri bulmak için şartları birleştirebilirsiniz:
mysql> SELECT * FROM hayvanlar WHERE tur = "köpek" AND cinsiyet = "d";
+-------+--------+-------+----------+------------+------+
| isim | sahibi | tur | cinsiyet | dogum | olum |
+-------+--------+-------+----------+------------+------+
| Buffy | Harold | köpek | d | 1989-05-13 | NULL |
+-------+--------+-------+----------+------------+------+
Önceki sorgu AND (VE) mantıksal işlemcisini kullandı. Benzer şekilde OR (VEYA) işlemcisi de vardır:
mysql> SELECT * FROM hayvanlar WHERE tur = "yılan" OR tur = "kuş";
+----------+--------+-------+----------+------------+------+
| isim | sahibi | tur | cinsiyet | dogum | olum |
+----------+--------+-------+----------+------------+------+
| Chirpy | Gwen | kuş | d | 1998-09-11 | NULL |
| Whistler | Gwen | kuş | NULL | 1997-12-09 | NULL |
| Slim | Benny | yılan | e | 1996-04-29 | NULL |
+----------+--------+-------+----------+------------+------+
AND ve OR işlemcileri birbirleriyle karıştırılabilirler. Bunu yaptığınız zaman hangi şartların gruplandırılacağını belirtmek için parantezleri kullanmak iyi bir fikirdir.
mysql> SELECT * FROM hayvanlar WHERE (tur = "kedi" AND cinsiyet = "e")
-> OR (tur = "köpek" AND cinsiyet = "d");
+-------+--------+-------+-----------+------------+------+
| isim | sahibi | tur | cinsiyet | dogum | olum |
+-------+--------+-------+-----------+------------+------+
| Claws | Gwen | kedi | e | 1994-03-17 | NULL |
| Buffy | Harold | köpek | d | 1989-05-13 | NULL |
+-------+--------+-------+-----------+------------+------+
3.3.4.3 Belirli Sütunların Seçilmesi
Eğer tablonuzdaki tüm sütunları görmek istemiyorsanız, sadece ilgilendiğiniz sütünların isimlerini birbirlerinden virgülle ayırarak verin. Örneğin; hayvanlarınızın doğduğu zamanı öğrenmek için isim ve dogum sütunlarını seçin:
mysql> SELECT isim, dogum FROM hayvanlar;
+----------+------------+
| isim | dogum |
+----------+------------+
| Fluffy | 1993-02-04 |
| Claws | 1994-03-17 |
| Buffy | 1989-05-13 |
| Fang | 1990-08-27 |
| Bowser | 1989-08-31 |
| Chirpy | 1998-09-11 |
| Whistler | 1997-12-09 |
| Slim | 1996-04-29 |
| Puffball | 1999-03-30 |
+----------+------------+
Hayvan sahiplerinin isimlerini öğrenmek için şu sorguyu kullanın:
mysql> SELECT sahibi FROM hayvanlar;
+--------+
| sahibi |
+--------+
| Harold |
| Gwen |
| Harold |
| Benny |
| Diane |
| Gwen |
| Gwen |
| Benny |
| Diane |
+--------+
Ancak bu sorgunun basitçe her kayıttan sahibi alanını çektiğine ve isimlerden bazısının bir defadan fazla ortaya çıktığına dikkat edin. Çıktıyı en aza indirmek için DISTINCT anahtar sözcüğünü ekleyerek benzeri olan kayıtları sadece bir defa tablodan çekin:
mysql> SELECT DISTINCT sahibi FROM hayvanlar;
+--------+
| sahibi |
+--------+
| Benny |
| Diane |
| Gwen |
| Harold |
+--------+
Satır seçimini sütun seçimiyle birleştirmek amacıyla bir WHERE cümleciği kullanabilirsiniz. Örneğin; sadece kedi veya köpeklerin doğum tarihlerini öğrenmek için aşağıdaki sorguyu kullanın:
mysql> SELECT isim, tur, dogum FROM hayvanlar
-> WHERE tur = "köpek" OR tur = "kedi";
+--------+-------+------------+
| isim | tur | dogum |
+--------+-------+------------+
| Fluffy | kedi | 1993-02-04 |
| Claws | kedi | 1994-03-17 |
| Buffy | köpek | 1989-05-13 |
| Fang | köpek | 1990-08-27 |
| Bowser | köpek | 1989-08-31 |
+--------+-------+------------+
3.3.4.4 Satırların Sıralanması
Önceki örneklerde sonuçların herhangi bir sıraya göre dizilmediklerini farketmiş olabilirsiniz. Bununla beraber satırların anlamlı bir şekilde sıralandığı sorgu çıktılarını incelemek çoğunlukla daha kolaydır. Bir çıktının sıralı olmasını sağlamak için ORDER BY cümleciğini kullanın.
İşte size hayvanların tarihe göre sıralanmış doğum tarihler:
mysql> SELECT isim, dogum FROM hayvanlar ORDER BY dogum;
+----------+------------+
| isim | dogum |
+----------+------------+
| Buffy | 1989-05-13 |
| Bowser | 1989-08-31 |
| Fang | 1990-08-27 |
| Fluffy | 1993-02-04 |
| Claws | 1994-03-17 |
| Slim | 1996-04-29 |
| Whistler | 1997-12-09 |
| Chirpy | 1998-09-11 |
| Puffball | 1999-03-30 |
+----------+------------+
Sıralamayı tersine çevirmek için sıralamayı gerçekleştirmek amacıyla kullandığınız sütunun adına DESC (azalan) anahtar sözcüğünü ekleyin:
mysql> SELECT isim, dogum FROM hayvanlar ORDER BY dogum DESC;
+----------+------------+
| isim | dogum |
+----------+------------+
| Puffball | 1999-03-30 |
| Chirpy | 1998-09-11 |
| Whistler | 1997-12-09 |
| Slim | 1996-04-29 |
| Claws | 1994-03-17 |
| Fluffy | 1993-02-04 |
| Fang | 1990-08-27 |
| Bowser | 1989-08-31 |
| Buffy | 1989-05-13 |
+----------+------------+
Birden fazla sütuna göre sıralama yapabilirsiniz. Mesela; hayvanların türüne göre sıralama yapmak, sonra da bir tür içerisinde, genç hayvanlar önce gelecek şekilde doğum tarihine göre sıralama yapmak için aşağıdaki sorguyu kullanın:
mysql> SELECT isim, tur, dogum FROM hayvanlar ORDER BY tur, dogum DESC;
+----------+---------+------------+
| isim | tur | dogum |
+----------+---------+------------+
| Chirpy | kuş | 1998-09-11 |
| Whistler | kuş | 1997-12-09 |
| Claws | kedi | 1994-03-17 |
| Fluffy | kedi | 1993-02-04 |
| Fang | köpek | 1990-08-27 |
| Bowser | köpek | 1989-08-31 |
| Buffy | köpek | 1989-05-13 |
| Puffball | hamster | 1999-03-30 |
| Slim | yılan | 1996-04-29 |
+----------+---------+------------+
DESC anahtar sözcüğünün sadece kendisinden hemen önce gelen sütun adı için (dogum) geçerli olduğuna; tur değerlerinin hala artacak şekilde sıralandığına dikkat edin.
3.3.4.5 Tarih Hesaplamaları
MySQL, mesela, yaş hesaplamak yada tarihlerin bazı kısımlarını (ay,dakika, v.s.) kullanmak gibi işler için tarihler üzerinde hesaplamalar yapmak amacıyla kullanabileceğiniz çeşitli fonksiyonlar sunar.
Hayvanların her birinin kaç yaşında olduğunu belirlemek için yaşı, o günün tarih ile doğum tarihi arasındaki fark olarak hesaplayın. Bunu, iki tarihi güne çevirip, aradaki farkı alıp 365'e (bir yıldaki gün sayısına) bölerek yapın:
mysql> SELECT isim, (TO_DAYS(NOW())-TO_DAYS(dogum))/365 FROM hayvanlar;
+----------+-------------------------------------+
| isim | (TO_DAYS(NOW())-TO_DAYS(dogum))/365 |
+----------+-------------------------------------+
| Fluffy | 6.15 |
| Claws | 5.04 |
| Buffy | 9.88 |
| Fang | 8.59 |
| Bowser | 9.58 |
| Chirpy | 0.55 |
| Whistler | 1.30 |
| Slim | 2.92 |
| Puffball | 0.00 |
+----------+-------------------------------------+
Sorgu çalışmasına karşın iyileştirilebilecek bazı yönleri bulunmaktadır. Öncelikle satırlar herhangi bir şekilde sıralandığı takdirde sonuç daha iyi incelebilecektir. Sonrasında, yaşın bulunduğu sütunun başlığı pek te anlamlı değil.
Çıktıyı isme göre sıralamak için bir ORDER BY isim cümleciği eklenerek ilk sorunun üstesinden gelinebilir. Sütun başlığını halletmek içinse, sütuna, çıktıda farklı bir etiket görünecek şekilde bir isim verilebilir (buna 'sütun takma adı)' denir):
mysql> SELECT isim, (TO_DAYS(NOW())-TO_DAYS(dogum))/365 AS yas
-> FROM hayvanlar ORDER BY isim;
+----------+------+
| isim | yas |
+----------+------+
| Bowser | 9.58 |
| Buffy | 9.88 |
| Chirpy | 0.55 |
| Claws | 5.04 |
| Fang | 8.59 |
| Fluffy | 6.15 |
| Puffball | 0.00 |
| Slim | 2.92 |
| Whistler | 1.30 |
+----------+------+
Çıktıyı isim yerine yaş'a göre sıralamak için sadece farklı bir ORDER BY cümleciği kullanın:
mysql> SELECT isim, (TO_DAYS(NOW())-TO_DAYS(dogum))/365 AS yas
-> FROM hayvanlar ORDER BY yas;
+----------+------+
| isim | yas |
+----------+------+
| Puffball | 0.00 |
| Chirpy | 0.55 |
| Whistler | 1.30 |
| Slim | 2.92 |
| Claws | 5.04 |
| Fluffy | 6.15 |
| Fang | 8.59 |
| Bowser | 9.58 |
| Buffy | 9.88 |
+----------+------+
Benzer bir sorgu, ölen hayvanların kaç yaşındayken öldüklerini bulmak için de kullanılabilir. Hangi hayvanların öldüğünü olum sütunundaki değerin NULL olup olmadığını kontrol ederek bulabilirsiniz. Daha sonra da bu sütundaki değerin NULL olmadığı hayvanlar için olum ve dogum değerleri arasındaki farkı hesaplayın:
mysql> SELECT isim, dogum, olum, (TO_DAYS(olum)-TO_DAYS(dogum))/365 AS yas
-> FROM hayvanlar WHERE olum IS NOT NULL ORDER BY yas;
+--------+------------+------------+------+
| isim | dogum | olum | yas |
+--------+------------+------------+------+
| Bowser | 1989-08-31 | 1995-07-29 | 5.91 |
+--------+------------+------------+------+
Önceki sorgu olum != NULL yerine olum IS NOT NULL'ı kullanıyor çünkü NULL özel bir değerdir. Bu ilerde açıklanmaktadır. Bölüm 9.3.4.6 [NULL Değerleriyle Çalışılması] kısmına göz atın.
Gelecek ay doğum günü olan hayvanları bilmek isterseniz ne olacak? Bu tip bir hesaplama için yıl ve gün anlamsızdır çünkü yapmak istediğiniz şey, basitçe dogum sütununun ay kısmını almaktır. MySQL, tarih değerlerinin bazı kısımlarını alabilmek için YEAR(), MONTH() ve DAYOFMONTH() gibi çeşitli tarih bölümlerini çıkarma fonksiyonları sunmaktadır. Burda bizim için uygun olan fonksiyon MONTH()'tur. Nasıl çalıştığını görmek için dogum ve MONTH(dogum) değerlerinin ikisini birden göstereck olan basit bir sorgu çalıştırın:
mysql> SELECT isim, dogum, MONTH(dogum) FROM hayvanlar;
+----------+------------+--------------+
| isim | dogum | MONTH(dogum) |
+----------+------------+--------------+
| Fluffy | 1993-02-04 | 2 |
| Claws | 1994-03-17 | 3 |
| Buffy | 1989-05-13 | 5 |
| Fang | 1990-08-27 | 8 |
| Bowser | 1989-08-31 | 8 |
| Chirpy | 1998-09-11 | 9 |
| Whistler | 1997-12-09 | 12 |
| Slim | 1996-04-29 | 4 |
| Puffball | 1999-03-30 | 3 |
+----------+------------+--------------+
Gelecek ay doğum günü olan hayvanları bulmak ta kolaydır. Şimdi Nisan ayında olduğumuzu farzedelim. Öyleyse üçüncü aydayız ve siz Mayıs ayında (5. ay) doğan hayvanları şu şekilde ararsınız:
mysql> SELECT isim, dogum FROM hayvanlar WHERE MONTH(dogum) = 5;
+-------+------------+
| isim | dogum |
+-------+------------+
| Buffy | 1989-05-13 |
+-------+------------+
Şüphesiz bulunduğunuz ay Aralık ise biraz karışıklık olacaktır. Kolayca ay numarasına (12) bir ekleyip 13'üncü ayda doğan hayvanları aramazsınız çünkü böyle bir ay yok! Bunun yerine Ocak ayında (1 numaralı ay) doğan hayvanları ararsınız.
Sorguyu, bulunduğunuz ay ne olursa olsun, yine de çalışabilecek bir şekilde bile yazabilirsiniz. Bu şekilde sorgunuzda belli bir ayın numarasını kullanmak zorunda kalmazsınız. DATE_ADD() fonksiyonu, verilen bir tarihe bir zaman aralığını eklemenizi sağlar. MONTH() fonksiyonuyla, NOW() fonksiyonun değerine 'bir ay' eklediğinizde elde ettiğiniz değerin ay kısmını aldığınızda, sonuç, içinde doğum günlerini arayacağınız ayı verir:
mysql> SELECT isim, dogum FROM hayvanlar
-> WHERE MONTH(dogum) = MONTH(DATE_ADD(NOW(), INTERVAL 1 MONTH));
Aynı işi başarmanın farklı bir yolu da sonraki ayı bulmak için bulunduğunuz aya 1 eklemektir. (Bulunduğunuz ay 12 ise ay değerinin 0'a dönmesini sağlamak amacıyla modulo (MOD) fonksiyonunu kullandıktan sonra.)
mysql> SELECT isim, dogum FROM hayvanlar
-> WHERE MONTH(dogum) = MOD(MONTH(NOW()), 12) + 1;
MONTH()'nun 1 ile 12 arasında bir sayı döndürdüğüne ve MOD(herhangi_bir_sayı,12)'nın de 0 ile 11 arasında bir sayı döndürdüğüne dikkat edin. Dolayısıyla toplama işlemi MOD()'dan sonra olmalıdır, aksi takdirde Kasım (11) ayından sonra Ocak (1) ayına geçeriz.
3.3.4.6 NULL Değerleriyle Çalışılması
NULL değeri, siz alışıncaya dek hayli şaşırtıcı olabilir. Kavram olarak NULL, olmayan veya bilinmeyen değer anlamına gelir ve diğer değerlerden farklı bir şekilde değerlendirilir. NULL'ı test ederken =, < veya != gibi aritmetik karşılaştırma işlemcilerini kullanamazsınız. Bunu görebilmek için aşağıdaki sorguyu deneyin:
mysql> SELECT 1 = NULL, 1 != NULL, 1 < NULL, 1 > NULL;
+----------+-----------+----------+----------+
| 1 = NULL | 1 != NULL | 1 < NULL | 1 > NULL |
+----------+-----------+----------+----------+
| NULL | NULL | NULL | NULL |
+----------+-----------+----------+----------+
Açık bir şekilde yukarıdaki karşılaştırmalardan anlamlı sonuçlar çıkaramazsınız. Bunun yerine IS NULL ve IS NOT NULL işlemcilerini kullanın:
mysql> SELECT 1 IS NULL, 1 IS NOT NULL;
+-----------+---------------+
| 1 IS NULL | 1 IS NOT NULL |
+-----------+---------------+
| 0 | 1 |
+-----------+---------------+
MySQLde 0 veya NULL yanlış, bunlar dışında herşey doğru demektir. Mantıksal bir işlemin öntanımlı değeri 1'dir.
NULL'ın bu özel davranışı, artık yaşamayan hayvanları bulurken neden olum != NULL yerine olum IS NOT NULL'ı kullanmamız gerektiğini göstermektedir.
3.3.4.7 Kalıpların Eşleştirilmesi
MySQL, vi, grep ve sed gibi Unix yardımcı programları tarafından kullanılanlara benzeyen, geliştirilmiş düzenli ifadeler üzerine bina edilmiş bir kalıp eşleştirme şekli kadar, standart SQL kalıp eşleştirmesini de kullanmanızı sağlar.
SQL'in kalıp eşleştirmesi, "_" (alt çizgi)yi herhangi bir karakteri, "%" (yüzde işareti)ni de herhangi bir sayıda karakteri (0 sayıda karakter de dahil) eşleştirmek için kullanmanıza izin verir. MySQL'de öntanımlı olarak SQL kalıpları büyük-küçük harften bağımsızdır. Bazı örnekler aşağıda gosterilmiştir. SQL kalıplarını kullandığınız zaman = ve != işlemcilerini kullanmadığınıza dikkat edin. Bunun yerine LIKE ve NOT LIKE karşılaştırma işlemcilerini kullanın.
'b' ile başlayan isimleri bulmak için:
mysql> SELECT * FROM hayvanlar WHERE isim LIKE "b%";
+--------+--------+---------+----------+------------+------------+
| isim | sahibi | tur | cinsiyet | dogum | olum |
+--------+--------+---------+----------+------------+------------+
| Buffy | Harold | köpek | d | 1989-05-13 | NULL |
| Bowser | Diane | köpek | e | 1989-08-31 | 1995-07-29 |
+--------+--------+---------+----------+------------+------------+
'fy' ile biten isimleri bulmak için:
mysql> SELECT * FROM hayvanlar WHERE isim LIKE "%fy";
+--------+--------+-------+----------+------------+------+
| isim | sahibi | tur | cinsiyet | dogum | olum |
+--------+--------+-------+----------+------------+------+
| Fluffy | Harold | kedi | d | 1993-02-04 | NULL |
| Buffy | Harold | köpek | d | 1989-05-13 | NULL |
+--------+--------+-------+----------+------------+------+
İçinde 'w' olan isimleri bulmak için:
mysql> SELECT * FROM hayvanlar WHERE isim LIKE "%w%";
+----------+--------+---------+----------+------------+------------+
| isim | sahibi | tur | cinsiyet | dogum | olum |
+----------+--------+---------+----------+------------+------------+
| Claws | Gwen | kedi | e | 1994-03-17 | NULL |
| Bowser | Diane | köpek | e | 1989-08-31 | 1995-07-29 |
| Whistler | Gwen | kuş | NULL | 1997-12-09 | NULL |
+----------+--------+---------+----------+------------+------------+
Tam beş karakterden oluşan isimleri bulmak için, '_' kalıp karakterini kullanın:
mysql> SELECT * FROM hayvanlar WHERE isim LIKE "_____";
+-------+--------+---------+----------+------------+-------+
| isim | sahibi | tur | cinsiyet | dogum | olum |
+-------+--------+---------+----------+------------+-------+
| Claws | Gwen | kedi | e | 1994-03-17 | NULL |
| Buffy | Harold | köpek | d | 1989-05-13 | NULL |
+-------+--------+---------+----------+------------+-------+
MySQLin sunduğu diğer kalıp eşleştirme tipi geliştirilmiş düzenli ifadeleri kullanır. Bu tip bir kalıpla eşleştirilen bir şeyi test ederken REGEXP ve NOT REGEXP işlemcilerini (veya eş anlamlıları olan RLIKE ve NOT RLIKE'ı) kullanın.
Geliştirilmiş düzenli ifadelerin bazı özellikleri şunlardır:
'.' (nokta) herhangi bir karaktere karşılık gelir.
Bir karakter sınıfı '[...]', köşeli parantezler içindeki herhangi bir karakterle eşleştirilebilir. Örneğin '[abc]', 'a', 'b' veya 'c' ye denk gelir. Bir karakter aralığını belirtmek için tire (yada eksi) işaretini kullanın. '[0-9]' herhangi bir rakama karşılık gelirken '[a-z]' herhangi bir küçük harfle eşleştirilir.
'*' (yıldız) karakteri kendisinden önce gelen karakterin sıfır veya daha fazla sayıda tekrarıyla eşleştirilir. Örneğin; 'x*', herhangi bir sayıda 'x' karakterine; '[0-9]*', herhangi bir sayıda rakama, '.*' ise herhangi bir sayıda herhangi bir karaktere karşılık gelir.
Düzenli ifadeler büyük-küçük harfe duyarlıdır ancak isterseniz iki durumda da eşleştirilebilen bir karakter sınıfı kullanabilirsiniz. Mesela '[aA]' hem büyük hem de küçük 'a'ya denk gelirken '[a-zA-Z]' iki durumda da herhangi bir harfe karşılık gelir.
Kalıbımız, test ettiğimiz değerin herhangi bir yerinde bile geçse eşleştirme gerçekleşir. (SQL kalıpları, sadece değerin tamamıyla eşleştirilebiliyorlarsa eşleştirme gerçekleşir.)
Bir kalıbı, test edilecek değerin başlangıcı veya sonuyla eşleştirilebilecek şekilde sınırlamak için kalıbın başında '^' veya sonunda '$' karakterini kullanın.
Geliştirilmiş düzenli ifadelerin nasıl çalıştıklarını göstermek için yukarıdaki LIKE sorguları, REGEXP kullanacak şekilde tekrar yazıldı.
'b' ile başlayan isimleri bulmak için ismin başlangıcıyla eşleştirmek amacıyla '^' karakterini kullanın:
mysql> SELECT * FROM hayvanlar WHERE isim REGEXP "^b";
+--------+--------+-------+----------+------------+------------+
| isim | sahibi | tur | cinsiyet | dogum | olum |
+--------+--------+-------+----------+------------+------------+
| Buffy | Harold | köpek | d | 1989-05-13 | NULL |
| Bowser | Diane | köpek | e | 1989-08-31 | 1995-07-29 |
+--------+--------+-------+----------+------------+------------+
MySQL Sürüm 3.23.4'ten önce REGEXP büyük-küçük harf duyarlıdır ve yukarıdaki sorgu hiçbir satır döndürmeyecektir. Küçük veya büyük 'b' harfiyle eşleştirmek için önceki sorgu yerine bunu kullanın:
mysql> SELECT * FROM hayvanlar WHERE isim REGEXP "^[bB]";
MySQL Sürüm 3.23.4'ten sonra bir REGEXP karşılaştırmasının büyük-küçük harf duyarlı olması için, karakter dizilerinden birisini ikili karakter dizisi (binary string) yapmak amacıyla BINARY anahtar sözcüğünü kullanın. Aşağıdaki sorgu, sadece ismin başındaki küçük 'b' harfiyle eşleştirecektir:
mysql> SELECT * FROM hayvanlar WHERE isim REGEXP BINARY "^b";
'fy' ile biten isimleri bulmak için, ismin sonuyla eşleştirmek amacıyla '$' karakterini kullanın:
mysql> SELECT * FROM hayvanlar WHERE isim REGEXP "fy$";
+--------+--------+-------+----------+------------+------+
| isim | sahibi | tur | cinsiyet | dogum | olum |
+--------+--------+---------+--------+------------+------+
| Fluffy | Harold | kedi | d | 1993-02-04 | NULL |
| Buffy | Harold | köpek | d | 1989-05-13 | NULL |
+--------+--------+-------+----------+------------+------+
Büyük veya küçük 'w' harfini içeren isimleri bulmak için şu sorguyu kullanın:
mysql> SELECT * FROM hayvanlar WHERE isim REGEXP "w";
+----------+--------+-------+----------+------------+------------+
| isim | sahibi | tur | cinsiyet | dogum | olum |
+----------+--------+-------+----------+------------+------------+
| Claws | Gwen | kedi | e | 1994-03-17 | NULL |
| Bowser | Diane | köpek | e | 1989-08-31 | 1995-07-29 |
| Whistler | Gwen | kuş | NULL | 1997-12-09 | NULL |
+----------+--------+-------+----------+------------+------------+
Bir düzenli ifade kalıbı, verilen değerin içinde herhangi bir yerde bile geçse eşleştirildiğinden, önceki sorguda SQL kalıpları kullandığımız zaman gerekecekken, verilen değerin tamamıyla eşleştirilebilmesi için kalıbın iki yanına joker karakteri koymamız gerekmemektedir.
Tam beş karakterden oluşan isimleri bulmak için, ismin başı ve sonuyla eşleştirmek için '^' ve '$' karakterlerini, ikisi arasında da beş tane '.' karakterini kullanın:
mysql> SELECT * FROM hayvanlar WHERE isim REGEXP "^.....$";
+-------+--------+-------+----------+------------+------+
| isim | sahibi | tur | cinsiyet | dogum | olum |
+-------+--------+-------+----------+------------+------+
| Claws | Gwen | kedi | e | 1994-03-17 | NULL |
| Buffy | Harold | köpek | d | 1989-05-13 | NULL |
+-------+--------+-------+----------+------------+------+
Önceki sorguyu '{n}' yani "n-defa-tekrar-et" işlemcisini kullanarak ta yazabilirdiniz:
mysql> SELECT * FROM hayvanlar WHERE isim REGEXP "^.{5}$";
+-------+--------+-------+----------+------------+------+
| isim | sahibi | tur | cinsiyet | dogum | olum |
+-------+--------+-------+----------+------------+------+
| Claws | Gwen | kedi | e | 1994-03-17 | NULL |
| Buffy | Harold | köpek | d | 1989-05-13 | NULL |
+-------+--------+-------+----------+------------+------+
3.3.4.8 Satırların Sayılması
Veritabanları çoğu kez "Belirli tipte bir veri ne kadar sıklıkla tabloda bulunur?" sorusunu yanıtlamak için kullanılırlar. Mesela; kaç tane hayvanınızın olduğunu, veya her hayvan sahibinin kaç tane hayvanının olduğunu bilmek isteyebilir, yada hayvanlarınız üzerinde çeşitli sayımlar gerçekleştirmek isteyebilirsiniz.
Sahip olduğunuz toplam hayvan sayısını hesaplamak, "hayvanlar tablosunda kaç tane satır var?" sorusunu yanıtlamakla aynıdır çünkü tabloda her bir hayvan için bir kayıt vardır. COUNT() fonksiyonu NULL olmayan sonuçların sayısını sayar, o yüzden hayvanlarınızı sayacak olan sorgu şuna benzer:
mysql> SELECT COUNT(*) FROM hayvanlar;
+----------+
| COUNT(*) |
+----------+
| 9 |
+----------+
Daha önce hayvan sahiplerinin isimlerini almıştınız. Her hayvan sahibinin kaç tane hayvana sahip olduğunu bulmak isterseniz COUNT()'u kullanabilirsiniz:
mysql> SELECT sahibi, COUNT(*) FROM hayvanlar GROUP BY sahibi;
+--------+----------+
| sahibi | COUNT(*) |
+--------+----------+
| Benny | 2 |
| Diane | 2 |
| Gwen | 3 |
| Harold | 2 |
+--------+----------+
Her sahibi için tüm kayıtları bir arada gruplamak amacıyla GROUP BY'ın kullanımına dikkat edin. GROUP BY olmaksızın alacağınız tek şey bir hata mesajı olacaktır:
mysql> SELECT sahibi, COUNT(sahibi) FROM hayvanlar;
ERROR 1140 at line 1: Mixing of GROUP columns (MIN(),MAX(),COUNT()...)
with no GROUP columns is illegal if there is no GROUP BY clause
(Satır 1 de HATA 1140: GROUP BY cümleciği olmaksızın GROUP sütunlarının (MIN(), MAX(), COUNT(),...) GROUP olmayan sütünlarla beraber kullanılması illegaldir)
COUNT() ve GROUP BY, verinizi çeşitli şekillerde sınıflandırmak için hayli yararlıdır. Sıradaki örnekler hayvanları sayma işlemlerini gerçekleştirmenin farklı yollarını göstermektedir.
Bir türdeki hayvan sayısı:
mysql> SELECT tur, COUNT(*) FROM hayvanlar GROUP BY tur;
+---------+----------+
| tur | COUNT(*) |
+---------+----------+
| kuş | 2 |
| kedi | 2 |
| köpek | 3 |
| hamster | 1 |
| yılan | 1 |
+---------+----------+
Bir cinsiyetteki hayvan sayısı:
mysql> SELECT cinsiyet, COUNT(*) FROM hayvanlar GROUP BY cinsiyet;
+----------+----------+
| cinsiyet | COUNT(*) |
+----------+----------+
| NULL | 1 |
| d | 4 |
| e | 4 |
+----------+----------+
(Bu çıktıdaki NULL cinsiyetin bilinmediğini göstermektedir.)
Belli bir tür ve cinsiyetteki hayvan sayısı:
mysql> SELECT tur, cinsiyet, COUNT(*) FROM hayvanlar GROUP BY tur, cinsiyet;
+---------+----------+----------+
| tur | cinsiyet | COUNT(*) |
+---------+----------+----------+
| kuş | NULL | 1 |
| kuş | d | 1 |
| kedi | d | 1 |
| kedi | e | 1 |
| köpek | d | 1 |
| köpek | e | 2 |
| hamster | d | 1 |
| yılan | e | 1 |
+---------+----------+----------+
COUNT() kullanırken bir tablonun tamamını çekmeniz gerekmez. Mesela; önceki sorgu, sadece kediler ve köpekler üzerinde gerçekleştirilse şöyle görünür:
mysql> SELECT tur, cinsiyet, COUNT(*) FROM hayvanlar
-> WHERE tur = "köpek" OR tur = "kedi"
-> GROUP BY tur, cinsiyet;
+---------+----------+----------+
| tur | cinsiyet | COUNT(*) |
+---------+----------+----------+
| kedi | d | 1 |
| kedi | e | 1 |
| köpek | d | 1 |
| köpek | e | 2 |
+---------+----------+----------+
Veya cinsiyetini bildiğiniz hayvanlar arasında, bir cinsiyetteki hayvan sayısını bilmek isterseniz:
mysql> SELECT tur, cinsiyet, COUNT(*) FROM hayvanlar
-> WHERE cinsiyet IS NOT NULL
-> GROUP BY tur, cinsiyet;
+---------+----------+----------+
| tur | cinsiyet | COUNT(*) |
+---------+----------+----------+
| kuş | d | 1 |
| kedi | d | 1 |
| kedi | e | 1 |
| köpek | d | 1 |
| köpek | e | 2 |
| hamster | d | 1 |
| yılan | e | 1 |
+---------+----------+----------+
3.3.4.9 Birden Fazla Tablonun Kullanılması
hayvanlar tablosu sahip olduğunuz hayvanların listesini tutar. Eğer hayvanlarınız hakkında veterinere gidiş tarihleri yada yavrularının dünyaya gelmesi gibi başka bilgileri de kaydetmek isterseniz başka bir tabloya ihtiyacınız olacaktır. Peki bu tablo neye benzemeli? Bu tabloda olması gerekenler:
Hayvan isimleri; böylece her olayın hangi hayvanla ilgili olduğunu bilirsiniz,
Olayın gerçekleştiği zamanı bilmenizi sağlayacak bir tarih,
Olayı anlatacak bir alan (field),
Olayları sınıflandırabilmeyi isterseniz, bir olay tipi alanıdır.
Yukardaki sebeplere dayanarak, olay tablosu için CREATE TABLE cümleciği bunun gibi bir şey olabilir:
mysql> CREATE TABLE olay (isim VARCHAR(20), tarih DATE,
-> tip VARCHAR(15), hatirlatma VARCHAR(255));
hayvanlar tablosunda olduğu gibi, ilk kayıtları tabloya yüklemenin en kolay yolu, verilerin tab tuşuyla birbirinden ayrıldığı, aşağıdaki bilgileri içeren bir düzyazı dosyası oluşturmaktadır:
Fluffy 1995-05-15 yavrulama 4 yavru kedi, 3 dişi, 1 erkek
Buffy 1993-06-23 yavrulama 5 yavru köpek, 2 dişi, 1 erkek
Buffy 1994-06-19 yavrulama 3 yavru köpek, 3 dişi
Chirpy 1999-03-21 veteriner tedavisi gagasının güçlendirilmesi gerekiyordu
Slim 1997-08-03 veteriner tedavisi kırık kabuga kemiği
Bowser 1991-10-12 köpek klübesi
Fang 1991-10-12 köpek klübesi
Fang 1998-08-28 doğum günü çiğneyebileceği yeni bir oyuncak verildi
Claws 1998-03-17 doğum günü yeni bir pire tasması verildi
Whistler 1998-12-09 doğum günü ilk doğum günü
Kayıtları şu şekilde tabloya yükleyin :
mysql> LOAD DATA LOCAL INFILE "olay.txt" INTO TABLE olay;
hayvanlar tablosu üzerinde çalıştırdığınız sorgulardan öğrendiklerinize dayanarak, olay tablosundaki kayıtlar üzerinde seçme işlemleri gerçekleştirebilirsiniz; temel kuralar aynıdır. Peki ne zaman olay tablosu, tek başına, sorabileceğiniz soruları yanıtlamakta yetersiz kalır?
Farzedelim ki her hayvanın yavruladığı zaman kaç yaşında olduğunu bulmak istiyorsunuz. olay tablosu bunun ne zaman gerçekleştiğini söyler ancak annenin yaşını hesaplayabilmek için doğum tarihine ihtiyacınız var. Doğum tarihi hayvanlar tablosunda tutulduğundan bu sorgu için iki tabloya da ihtiyacınız var:
mysql> SELECT hayvanlar.isim, (TO_DAYS(tarih) - TO_DAYS(dogum))/365 AS yas, hatirlatma
-> FROM hayvanlar, olay
-> WHERE hayvanlar.isim = olay.isim AND tip = "yavrulama";
+--------+------+--------------------------------+
| isim | yas | hatirlatma |
+--------+------+--------------------------------+
| Fluffy | 2.27 | 4 yavru kedi, 3 dişi, 1 erkek |
| Buffy | 4.12 | 5 yavru köpek, 2 dişi, 3 erkek |
| Buffy | 5.10 | 3 yavru köpek, 3 dişi |
+--------+------+--------------------------------+
Bu sorgu hakkında not edilmesi gereken birkaç şey bulunmaktadır:
FROM cümleciği iki tabloyu da içermektedir, çünkü her iki tablodan da bilgi çekmesi gerekmektedir.
Çok sayıda tablodan alınacak bilgiyi birleştirirken (joining), bir tablodaki kayıtların diğer tablodaki kayıtlarla nasıl eşleştirilebileceğini belirtmeniz gerekir. İki tablo da isim sütununa sahip olduğundan bu kolaydır. Sorgu, isim değerlerine dayanarak iki tablodaki kayıtları eşleştirmek için WHERE cümleciğini kullanmaktadır.
isim sütunu iki tabloda da bulunduğundan, bu sütunu kullandığınız zaman hangi tabloyu kastettiğinizde net (açık) olmalısınız. Bu da tablo adını sütun adının önüne ekleyerek yapılmaktadır.
Birleştirme (join) işlemi için iki farklı tablonun olması gerekmez. Bazen bir tabloyu kendisiyle birleştirmek faydalı olabilir; eğer o tablodaki değerleri aynı tablodaki başka değerlerle karşılaştırmak istiyorsanız. Mesela; hayvanlarınızın içinde yavrulayabilecek çiftleri bulmak için aynı türden erkek ve dişilerle çiftler oluşturmak amacıyla hayvanlar tablosunu kendisiyle birleştirebilirsiniz:
mysql> SELECT p1.isim, p1.cinsiyet, p2.isim, p2.cinsiyet, p1.tur
-> FROM hayvanlar AS p1, hayvanlar AS p2
-> WHERE p1.tur = p2.tur AND p1.cinsiyet = "d" AND p2.cinsiyet = "e";
+--------+----------+--------+----------+-------+
| isim | cinsiyet | isim | cinsiyet | tur |
+--------+----------+--------+----------+-------+
| Fluffy | d | Claws | e | kedi |
| Buffy | d | Fang | e | köpek |
| Buffy | d | Bowser | e | köpek |
+--------+----------+--------+----------+-------+
Bu sorguda, her sütun referansının tablonun hangi haline (instance) karşılık geldiğini açıkça belirtmek ve sütunlara atıfta bulunmak amacıyla tablo adı için takma adlar belirttik.
3.4 Veritabanları ve Tablolar Hakkında Bilgi Alınması
Bir veritabanı veya tablo adını ya da verilen bir tablonun yapısını (örneğin sütun isimlerinin ne olduğunu) unutursanız ne olur? MySQL, desteklediği veritabanları ve tablolar hakkında bilgi veren çeşitli cümlecikleri sayesinde bu sorunu çözer.
Sunucu tarafından kullanılan veritabanlarının listesini veren SHOW DATABASES komutunu zaten gördünüz. Halihazırda hangi veritabanının seçildiğini öğrenmek için de DATABASE() fonksiyonunu kullanın:
mysql> SELECT DATABASE();
+------------------+
| DATABASE() |
+------------------+
| hayvan_toplulugu |
+------------------+
Eğer henüz herhangi bir veritabanını seçmediyseniz yanıt "boş" tur.
Seçtiğiniz veritabanının hangi tabloları içerdiğini bulmak için (mesela; bir tablonun adından emin olmadığınız durumda) şu komutu kullanın :
mysql> SHOW TABLES;
+----------------------------+
| Tables in hayvan_toplulugu |
+----------------------------+
| olay |
| hayvanlar |
+----------------------------+
Bir tablonun yapısı hakkında bilgi almak isterseniz DESCRIBE komutu faydalıdır; tablonun her sütunu hakkında bilgi verir:
mysql> DESCRIBE hayvanlar;
+----------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+-------+
| isim | varchar(20) | YES | | NULL | |
| sahibi | varchar(20) | YES | | NULL | |
| tur | varchar(20) | YES | | NULL | |
| cinsiyet | char(1) | YES | | NULL | |
| dogum | date | YES | | NULL | |
| olum | date | YES | | NULL | |
+----------+-------------+------+------+--------+-------+
Field sütun adını; Type, sütunun veri tipini; Null, sütunun NULL değeri alıp almayacağını; Key, sütunun indekslenip indekslenmediğini ve Default'ta sütunun öntanımlı değerini göstermektedir.
Eğer bir tabloda indeksleriniz varsa, SHOW INDEX FROM tablo_adı indeksler hakkında bilgi verir.
3.5 Sık Karşılaşılan Sorgu Örnekleri
Buradakiler sık karşılaşılan bazı problemlerin MySQL ile nasıl çözüleceğine dair örneklerdir.
Örneklerin bazıları, belirli satıcıları için her eşyanın fiyatını (eşya numarası) tutan magaza tablosunu kullanmaktadır. Her satıcının eşya başına (tek ve) sabit bir fiyat verdiğini farzedersek, (eşya, tüccar) kayıtlar için ana anahtar olacaktır.
Komut satırı aracı olan mysql'i başlatıp bir veritabanı seçin:
kabuk>mysql veritabanınızın_adı
(MySQL kurulumlarının çoğunda 'test' veritabanı adını kullanabilirsiniz).
Örnek tabloyu şu şekilde oluşturabilirsiniz:
CREATE TABLE magaza (
esya INT(4) UNSIGNED ZEROFILL DEFAULT '0000' NOT NULL,
satici CHAR(20) DEFAULT '' NOT NULL,
fiyat DOUBLE(16,2) DEFAULT '0.00' NOT NULL,
PRIMARY KEY(esya, satici));
INSERT INTO magaza VALUES
(1,'A',3.45),(1,'B',3.99),(2,'A',10.99),(3,'B',1.4 5),(3,'C',1.69),
(3,'D',1.25),(4,'D',19.95);
Bu işlemden sonra örnek verimiz şöyledir:
mysql> SELECT * FROM magaza;
+---------+--------+-------+
| esya | satici | fiyat |
+---------+--------+-------+
| 0001 | A | 3.45 |
| 0001 | B | 3.99 |
| 0002 | A | 10.99 |
| 0003 | B | 1.45 |
| 0003 | C | 1.69 |
| 0003 | D | 1.25 |
| 0004 | D | 19.95 |
+---------+--------+-------+
3.5.1 Bir Sütundaki En Büyük Değer
"En büyük eşya numarası nedir?"
SELECT MAX(esya) AS esya FROM magaza
+---------+
| esya |
+---------+
| 4 |
+---------+
3.5.2 Belirli Bir Sütunun En Büyük Değerini Bulunduran Satırlar
"En pahalı eşyanın numarasını, satıcısını ve fiyatını bulun."
ANSI SQL' de bu bir alt-sorgu (sub-query) ile kolayca yapılmaktadır:
SELECT esya, satici, fiyat
FROM magaza
WHERE fiyat=(SELECT MAX(fiyat) FROM magaza)
(Henüz alt-seçim (sub-select)'i olmayan) MySQLde bunu iki adımda yapın:
1. Bir SELECT cümleciğiyle tablodan en yüksek fiyatın değerini alın.
2. Bu değeri kullanarak asıl sorguyu hazırlayın:
SELECT esya, satici, fiyat
FROM magaza
WHERE fiyat=19.95
Başka bir çözüm de tüm satırları fiyata göre azalacak şekilde sıralayıp MySQL'e özgü LIMIT cümleciğiyle ilk satırı almaktır:
SELECT esya, satici, fiyat
FROM magaza
ORDER BY fiyat DESC
LIMIT 1
NOT: Eğer en pahalı eşyadan bir taneden fazla varsa (örneğin; birkaç 19.95) LIMIT çözümü içlerinden sadece bir tanesini görüntüler!
3.5.3 Grup İçinde Belirli Bir Alanın En Büyük Değerini Bulunduran Satırlar
"Her bir eşya için en yüksek fiyat nedir?"
SELECT esya, MAX(fiyat) AS fiyat
FROM magaza
GROUP BY esya
+---------+-------+
| esya | fiyat |
+---------+-------+
| 0001 | 3.99; |
| 0002 | 10.99 |
| 0003 | 1.69 |
| 0004 | 19.95 |
+---------+-------+
3.5.4 Bir Grupta Belli Bir Alanın En Büyük Değerini Bulunduran Satırlar
"Her eşya için, en yüksek fiyatı veren satıcıyı (satıcıları) bulun."
ANSI SQL' de şuna benzer bir alt-sorguyla yapardım :
SELECT esya, satici, fiyat
FROM magaza s1
WHERE fiyat=(SELECT MAX(s2.fiyat)
FROM magaza s2
WHERE s1.esya = s2.esya);
MySQLde bu, en iyi şekilde birkaç adımla yapılır:
1. (esya, maxfiyat) listesini alın.
2. Her eşya için en yüksek fiyatı bulunduran satırları alın.
Bu, geçici bir tabloyla kolayca yapılabilir:
CREATE TEMPORARY TABLE tmp (
esya INT(4) UNSIGNED ZEROFILL DEFAULT '0000' NOT NULL,
fiyat DOUBLE(16,2) DEFAULT '0.00' NOT NULL);
LOCK TABLES magaza read;
INSERT INTO tmp SELECT esya, MAX(fiyat) FROM magaza GROUP BY esya;
SELECT magaza.esya, satici, magaza.fiyat FROM magaza, tmp
WHERE magaza.esya=tmp.esya AND magaza.fiyat=tmp.fiyat;
UNLOCK TABLES;
DROP TABLE tmp;
Eğer TEMPORARY (geçici) bir tablo kullanmazsanız, 'tmp' tablosunu da kilitlemeniz gerekir.
"Bu tek bir sorguyla yapılabilir mi?"
Evet, ancak sadece "MAX-CONCAT hilesi" dediğim, oldukça verimsiz bir hileyle:
SELECT esya,
SUBSTRING( MAX( CONCAT(LPAD(fiyat,6,'0'),satici) ), 7) AS satici,
0.00+LEFT( MAX( CONCAT(LPAD(fiyat,6,'0'),satici) ), 6) AS fiyat
FROM magaza
GROUP BY esya;
+------+--------+-------+
| esya | satici | fiyat |
+------+--------+-------+
| 0001 | B | 3.99 |
| 0002 | A | 10.99 |
| 0003 | C | 1.69 |
| 0004 | D | 19.95 |
+------+--------+-------+
Son örnek, şüphesiz, birleştirilen sütunun kullanıcıda parçalanmasıyla biraz daha verimli hale getirilebilir.
3.5.5 Kullanıcı Değişkenlerinin Kullanılması
Sonuçları hatırlamak için, değerleri istemcide geçici değişkenlerde saklamak zorunda kalmaksızın, MySQLin kullanıcı değişkenlerini kullanabilirsiniz. Bölüm 7.2 [Kullanıcı Değişkenleri]'ne göz atın.
Mesela en düşük ve en yüksek fiyata sahip eşyaları bulmak için şunu yapabilirsiniz:
select @min_fiyat:=min(fiyat),@max_fiyat:=max(fiyat) from magaza;
select * from magaza where fiyat=@min_fiyat or fiyat=@max_fiyat;
+---------+--------+-------+
| esya | satici | fiyat |
+---------+--------+-------+
| 0003 | D | 1.25 |
| 0004 | D | 19.95 |
+---------+--------+-------+
3.5.6 Yabancı Anahtarların Kullanılması
İki tabloyu da birleştirmek (join) için yabancı anahtarlara ihtiyacınız yoktur.
MySQLin yapmadığı tek şey, kullandığınız anahtarların gerçekten atıfta bulunduğunuz (belirttiğiniz) tablolarda bulunduğundan emin olmak için KONTROL'dür ve MySQL yabancı anahtar tanımı olan satırları tablodan otomatik olarak silmez. Eğer anahtarlarınızı normal anahtarlar gibi kullanırsanız gerçekten iyi çalışacaktır:
CREATE TABLE persons (
no SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT,
isim CHAR(60) NOT NULL,
PRIMARY KEY (no)
);
CREATE TABLE shirts (
no SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT,
stil ENUM('t-shirt', 'polo', 'dress') NOT NULL,
renk ENUM('kırmızı', 'mavi', 'turuncu', 'beyaz', 'siyah') NOT NULL,
sahibi SMALLINT UNSIGNED NOT NULL REFERENCES persons,
PRIMARY KEY (no)
);
INSERT INTO persons VALUES (NULL, 'Antonio Paz');
INSERT INTO shirts VALUES
(NULL, 'polo', 'mavi', LAST_INSERT_ID()),
(NULL, 'dress', 'beyaz', LAST_INSERT_ID()),
(NULL, 't-shirt', 'mavi', LAST_INSERT_ID());
INSERT INTO persons VALUES (NULL, 'Lilliana Angelovska');
INSERT INTO shirts VALUES
(NULL, 'dress', 'turuncu', LAST_INSERT_ID()),
(NULL, 'polo', 'kırmızı', LAST_INSERT_ID()),
(NULL, 'dress', 'mavi', LAST_INSERT_ID()),
(NULL, 't-shirt', 'beyaz', LAST_INSERT_ID());
SELECT * FROM persons;
+----+---------------------+
| no | isim |
+----+---------------------+
| 1 | Antonio Paz |
| 2 | Lilliana Angelovska |
+----+---------------------+
SELECT * FROM shirts;
+----+---------+---------+--------+
| no | stil | renk | sahibi |
+----+---------+---------+--------+
| 1 | polo | mavi | 1 |
| 2 | dress | beyaz | 1 |
| 3 | t-shirt | mavi | 1 |
| 4 | dress | turuncu | 2 |
| 5 | polo | kırmızı | 2 |
| 6 | dress | mavi | 2 |
| 7 | t-shirt | beyaz | 2 |
+----+---------+---------+--------+
SELECT s.* FROM persons p, shirts s
WHERE p.isim LIKE 'Lilliana%'
AND s.sahibi = p.no
AND s.renk <> 'beyaz';
+----+-------+---------+--------+
| no | stil | renk | sahibi |
+----+-------+---------+--------+
| 4 | dress | turuncu | 2 |
| 5 | polo | kırmızı | 2 |
| 6 | dress | mavi | 2 |
+----+-------+---------+--------+
3.5.7 İki Anahtar Kullanarak Arama Yapılması
MySQL henüz OR ile birleştirilmiş iki anahtarı kullanarak arama yaptığınızda, arama işlemini iyileştirmemektedir (farklı OR kısımları olan bir anahtarı kullanarak yapılan aramalar hayli iyileştirilmiştir):
SELECT field1_index, field2_index FROM test_table WHERE field1_index = '1'
OR field2_index = '1'
Sebebi ise, bunu genel durumlarda çalıştırabilecek verimli bir metot geliştirmeye henüz zamanımız olmadı. (Buna kıyasla AND işlemcisinin ele alınışı şimdilik tamamıyla geneldir ve çok iyi çalışmaktadır.)
Halihazırda bu sorunu TEMPORARY tablo kullanarak oldukça verimli bir şekilde çözebilirsiniz. Bu tip bir iyileştirme, SQL sunucusunun iyileştirmeleri yanlış sırayla yaptığı aşırı karmaşık sorguları kullandığınızda da hayli iyi olacaktır.
CREATE TEMPORARY TABLE tmp
SELECT field1_index, field2_index FROM test_table WHERE field1_index = '1';
INSERT INTO tmp
SELECT field1_index, field2_index FROM test_table WHERE field2_index = '1';
SELECT * from tmp;
DROP TABLE tmp;
Bu sorgunun yukarıdaki şekilde halledilmesi, iki sorgunun UNION'ı (birleştirilmesi) şeklinde kullanılmaktadır.
3.5.8 Günlük Ziyaret Edilme Sayısının Hesaplanması
Aşağıdakiler, bir kullanıcının bir web sayfasını ayda kaç defa ziyaret ettiğini hesaplamak amacıyla nasıl grup bit fonksiyonlarını kullanabileceğinize dair fikir vermektedir.
CREATE TABLE t1 (year YEAR(4), month INT(2) UNSIGNED ZEROFILL, day INT(2) UNSIGNED ZEROFILL);
INSERT INTO t1 VALUES(2000,1,1),(2000,1,20),(2000,1,30),(2000,2,2 ),(2000,2,23),(2000,2,23);
SELECT year,month,BIT_COUNT(BIT_OR(1<<day)) AS days FROM t1 GROUP BY year,month;
sorgusu yanıt olarak:
+------+-------+------+
| year | month | days |
+------+-------+------+
| 2000 | 01 | 3 |
| 2000 | 02 | 2 |
+------+-------+------+
sonucunu dönderir.
Yukarıdaki sorgu, tekrar eden girdileri kaldırarak verilen bir yıl/ay kombinasyonu için kaç faklı günün kullanıldığını hesaplar.
3.6 mysql'in Yığın Modunda Kullanılması
Önceki bölümlerde mysql'i , sorgu girmek ve sonuçları görmek için karşılıklı etkileşimli oarak kullandınız.
mysql'i yığın modunda da kullanabilirsiniz. Bunu yapmak için çalıştırmak istediğiniz komutları bir dosyaya yerleştirin, sonra mysql'e girdileri dosyadan okumasını söyleyin:
kabuk> mysql < yığın_dosyası
Eğer komut satırında bağlantı parametrelerini vermeniz gerekiyorsa, komut şuna benzeyebilir:
kabuk> mysql -h sunucu_makina_adı -u kullanıcı_adı -p < yığın_dosyası
Enter password: ********
mysql'i bu şekilde kullandığınız zaman önce bir script dosyası oluşturmakta, sonra da scripti çalıştırmaktasınız.
Neden script kulanalım? İşte size kullanmak için birkaç sebep:
Eğer bir sorguyu defalarca çalıştırmanız gerekiyorsa (diyelim ki hergün veya her hafta), sorguyu bir script haline getirmek, onu her çalıştırışınızda aynı şeyleri tekrar tuşlamaktan kaçınmanızı sağlar.
Script dosyalarını kopyalayıp düzenleyerek eski sorgularınızdan onlara benzeyen yeni sorgular oluşturabilirsiniz.
Yığın modu bir sorguyu hazırlarken de size yardımcı olabilir; özellikle de çoklu-satırlardan oluşan komutlar yada çok sayıda cümleden oluşan komut dizileri için. Eğer sorguyu hazırlarken bir hata yaparsanız herşeyi tekrar yazmak zorunda kalmazsınız. Hatayı düzeltmek için sadece scripti düzeltin ve mysql'e scripti tekrar çaluıştırmasını söyleyin.
Eğer çok fazla çıktı üreten bir sorgunuz varsa, sonuçları ekranın üst köşesinden kayıp giderken seyretmek yerine, girdiyi sayfalara bölen bir program (pager) yardımıyla çıktıyı gözden geçirebilirsiniz:
kabuk> mysql < yığın_dosyası | more
("more", Unix/Linux'ta kendisine verilen girdiyi sayfa sayfa görmenizi sağlayan bir komuttur.)
Scriptlerinizi diğer insanlara dağıtabilirsiniz; böylece onlar da komutları çalıştırabilirler.
kabuk> mysql < yığın_dosyası > mysql.out
Bazı durumlar karşılıklı etkileşebileceğiniz şekilde kullanıma izin vermezler; örneğin; sorguyu bir cron işiyle çalıştırdığınızda. ( Unix/Linux'ta komutların belli aralıklarla çalıştırılması cron işleriyle yapılmaktadır.) Bu durumda yığın modunu kullanmak zorundasınız.
Öntanımlı çıktı düzeni , mysql'i yığın modunda çalıştırdığınızda karşılıklı etkileşecek şekilde çalıştırdığınızdan daha farklıdır (daha kısadır). Mesela; karşılıklı etkileşecek şekilde çalıştırdığınız zaman SELECT DISTINCT tur FROM hayvanlar sorgusunun çıktısı şuna benzer:
+---------+
| tur |
+---------+
| kuş |
| kedi |
| köpek |
| hamster |
| yılan |
+---------+
Fakat yığın modunda bunun gibidir:
tur
kuş
kedi
köpek
hamster
yılan
Yığın modunda karşılıklı etkileşen moddaki çıktı düzenini almak istiyorsanız mysql -t'yi kullanın. Çalıştırılan komutların çıktıya yansıması için mysql -vvv'yi kullanın.
3.7 İkiz Projesinden Sorgular
Analytikerna ve Lentus'ta büyük bir araştırma projesi için "sistem ve alan" işlerini yürütmekteyiz. Bu proje Karolinska Institutet Stockholm'daki Çevresel Tıp Enstitüsü ve Güney Kaliforniya Üniversitesi'ndeki Yaşlanma ve Psikoloji Üzerine Klinik Araştırma Bölümü'nun işbirliğinin sonucudur.
Proje İsveç'teki 65 yaş üzeri tüm ikizlerin telefonla görüşüldüğü bir eleme kısmını içermektedir. Belirli kriterlere uyan ikizler sonraki aşamaya geçmektedirler. Sonraki kısımda katılmak isteyen tüm ikizler bir doktor/hemşire takımı tarafından ziyaret edilmektedirler. İncelemelerin bir kısmı fiziksel ve nörofiziksel muayene, laboratuar testleri, nöroimajing, psikolojik durum değerlendirmesi ve aile geçmişi hakkında bilgi toplanmasını içermektedir. Bunlara ek olarak tıbbi ve çevresel risk faktörleri hakkında da veri toplanmaktadır.
İkizar aştırmaları hakkında daha fazla bilgiye bu adresten ulaşılabilir:
http://www.imm.ki.se/TWIN/TWINUKW.HTM
Projenin sonraki kısmı Perl ve MySQL kullanarak yazılan bir Web arayüzüyle yönetilmektedir.
Her gece görüşmelerden elde edilen tüm veriler bir MySQL veritabanına taşınmaktadır
3.7.1 Dağılmamış Tüm İkizlerin Bulunması
Projenin ikinci kısmına geçenleri belirlemek için aşağıdaki sorgu kullanılmaktadır:
select
concat(p1.id, p1.tvab) + 0 as tvid,
concat(p1.christian_name, " ", p1.surname) as Name,
p1.postal_code as Code,
p1.city as City,
pg.abrev as Area,
if(td.participation = "Aborted", "A", " ") as A,
p1.dead as dead1,
l.event as event1,
td.suspect as tsuspect1,
id.suspect as isuspect1,
td.severe as tsevere1,
id.severe as isevere1,
p2.dead as dead2,
l2.event as event2,
h2.nurse as nurse2,
h2.doctor as doctor2,
td2.suspect as tsuspect2,
id2.suspect as isuspect2,
td2.severe as tsevere2,
id2.severe as isevere2,
l.finish_date
from
twin_project as tp
/* For Twin 1 */
left join twin_data as td on tp.id = td.id and tp.tvab = td.tvab
left join informant_data as id on tp.id = id.id and tp.tvab = id.tvab
left join harmony as h on tp.id = h.id and tp.tvab = h.tvab
left join lentus as l on tp.id = l.id and tp.tvab = l.tvab
/* For Twin 2 */
left join twin_data as td2 on p2.id = td2.id and p2.tvab = td2.tvab
left join informant_data as id2 on p2.id = id2.id and p2.tvab = id2.tvab
left join harmony as h2 on p2.id = h2.id and p2.tvab = h2.tvab
left join lentus as l2 on p2.id = l2.id and p2.tvab = l2.tvab,
person_data as p1,
person_data as p2,
postal_groups as pg
where
/* p1 gets main twin and p2 gets his/her twin. */
/* ptvab is a field inverted from tvab */
p1.id = tp.id and p1.tvab = tp.tvab and
p2.id = p1.id and p2.ptvab = p1.tvab and
/* Just the sceening survey */
tp.survey_no = 5 and
/* Skip if partner died before 65 but allow emigration (dead=9) */
(p2.dead = 0 or p2.dead = 9 or
(p2.dead = 1 and
(p2.death_date = 0 or
(((to_days(p2.death_date) - to_days(p2.birthday)) / 365) >= 65))))
and
(
/* Twin is suspect */
(td.future_contact = 'Yes' and td.suspect = 2) or
/* Twin is suspect - Informant is Blessed */
(td.future_contact = 'Yes' and td.suspect = 1 and id.suspect = 1) or
/* No twin - Informant is Blessed */
(ISNULL(td.suspect) and id.suspect = 1 and id.future_contact = 'Yes') or
/* Twin broken off - Informant is Blessed */
(td.participation = 'Aborted'
and id.suspect = 1 and id.future_contact = 'Yes') or
/* Twin broken off - No inform - Have partner */
(td.participation = 'Aborted' and ISNULL(id.suspect) and p2.dead = 0))
and
l.event = 'Finished'
/* Get at area code */
and substring(p1.postal_code, 1, 2) = pg.code
/* Not already distributed */
and (h.nurse is NULL or h.nurse=00 or h.doctor=00)
/* Has not refused or been aborted */
and not (h.status = 'Refused' or h.status = 'Aborted'
or h.status = 'Died' or h.status = 'Other')
order by
tvid;
Bazı açıklamalar:
concat(p1.id,p1.tvab)+0 as tvid
id ve tvab'ın birleştirilmiş halini sayısal sıraya göre sıralamak istiyoruz. sonuca 0 eklememiz MySQL'in sonuca sayı gözüyle bakmasını sağlar.
id sütunu
Bu sütun bir ikiz çiftini belirler. Tüm tablolardam bir anahtar olarak bulunmaktadır.
tvab sütunu
Bu sütun bir çift içerisindeki ikizleri belirler. 1 veya 2 değerini alır.
ptvab sütunu
Bu tvab'ın tersidir. tvab 1 iken bu 2'dir ve tersi... Yazımdan kaçınmak ve MySQL'in sorguyu iyileştirme işini kolaylaştırmak amacıyla vardır.
Bu sorgu, diğer şeylerle beraber, bir tablo üzerinde yine aynı tablodan bir birleştirmeyle (p1 ve p2) nasıl arama yapılacağını göstermektedir. Örnekteki sorgu ikizlerden birinin 65 yaşından önce ölüp ölmediğini kontrol etmek için kullanılmaktadır. Eğer öldüyse satır dönderilmemektedir.
Yukarıdakilerin tamamı ikizlerle ilgili bilgilerle beraber tüm tablolarda bulunmaktadır. Sorguları daha hızlı bir hale getirmek için id,tvab (tüm tablolarda) ve id,ptvab(person_data tablosunda)'ın her ikisinde de anahtarımız vardır.
Üretim için kullandığımız makinamızda (200 MHz'lik UltraSPARC) bu sorgu yaklaşık 150-200 satır döndermektedir ve işlem bir saniyeden az bir zaman almaktadır.
Yukarıda kullanılan tablolardaki mevcut kayıtların sayısı aşağıdadır:
Tablo Satırlar
person_data 71074
lentus 5291
twin_project 5286
twin_data 2012
informant_data 663
harmony 381
postal_groups 100
< Bu mesaj bu kişi tarafından değiştirildi peacewolfus -- 22 Mart 2006; 15:25:21 >