SQL - Hızlı Kılavuz

SQL, veritabanlarını çalıştırmak için kullanılan bir dildir; veritabanı oluşturmayı, silmeyi, satırları getirmeyi, satırları değiştirmeyi vb. içerir. SQL birANSI (Amerikan Ulusal Standartlar Enstitüsü) standart dili, ancak SQL dilinin birçok farklı sürümü vardır.

SQL nedir?

SQL, ilişkisel bir veritabanında depolanan verileri depolamak, değiştirmek ve almak için kullanılan bir bilgisayar dili olan Yapılandırılmış Sorgu Dili'dir.

SQL, İlişkisel Veritabanı Sistemi için standart dildir. MySQL, MS Access, Oracle, Sybase, Informix, Postgres ve SQL Server gibi tüm İlişkisel Veritabanı Yönetim Sistemleri (RDMS) standart veritabanı dili olarak SQL'i kullanır.

Ayrıca, farklı lehçeler kullanıyorlar, örneğin -

T-SQL kullanan MS SQL Server,
PL / SQL kullanarak Oracle,
SQL'in MS Access sürümüne JET SQL (yerel format) vb. Denir.

Neden SQL?

SQL, aşağıdaki avantajları sunduğu için oldukça popülerdir -

Kullanıcıların ilişkisel veritabanı yönetim sistemlerindeki verilere erişmesine izin verir.
Kullanıcıların verileri açıklamasına izin verir.
Kullanıcıların bir veritabanındaki verileri tanımlamasına ve bu verileri işlemesine izin verir.
SQL modülleri, kitaplıkları ve ön derleyicileri kullanarak diğer dillere gömülmesine izin verir.
Kullanıcıların veritabanları ve tablolar oluşturmasına ve bırakmasına izin verir.
Kullanıcıların bir veritabanında görünüm, saklı prosedür ve işlevler oluşturmasına izin verir.
Kullanıcıların tablolar, prosedürler ve görünümler üzerinde izinler ayarlamasına izin verir.

SQL'in Kısa Tarihi

1970- IBM'den Dr. Edgar F. "Ted" Codd, ilişkisel veritabanlarının babası olarak bilinir. Veritabanları için ilişkisel bir model tanımladı.
1974 - Yapılandırılmış Sorgu Dili ortaya çıktı.
1978 - IBM, Codd'un fikirlerini geliştirmek için çalıştı ve System / R adlı bir ürün yayınladı.
1986- IBM, ilişkisel veritabanının ilk prototipini geliştirdi ve ANSI tarafından standartlaştırıldı. İlk ilişkisel veritabanı, daha sonra Oracle olarak bilinen İlişkisel Yazılım tarafından yayınlandı.

SQL Süreci

Herhangi bir RDBMS için bir SQL komutu yürütürken, sistem isteğinizi yerine getirmenin en iyi yolunu belirler ve SQL motoru görevin nasıl yorumlanacağını belirler.

Bu sürece dahil olan çeşitli bileşenler vardır.

Bu bileşenler -

Sorgu Dağıtıcı
Optimizasyon Motorları
Klasik Sorgu Motoru
SQL Sorgu Motoru vb.

Klasik bir sorgu motoru tüm SQL dışı sorguları işler, ancak bir SQL sorgu motoru mantıksal dosyaları işlemez.

Aşağıda, SQL Mimarisini gösteren basit bir şema yer almaktadır -

SQL Komutları

İlişkisel veritabanları ile etkileşim için standart SQL komutları CREATE, SELECT, INSERT, UPDATE, DELETE ve DROP'tur. Bu komutlar, doğalarına göre aşağıdaki gruplara ayrılabilir -

DDL - Veri Tanımlama Dili

Sr.No.	Komut ve Açıklama
1	CREATE Veritabanında yeni bir tablo, tablo görünümü veya başka bir nesne oluşturur.
2	ALTER Tablo gibi var olan bir veritabanı nesnesini değiştirir.
3	DROP Bir tablonun tamamını, bir tablonun görünümünü veya veritabanındaki diğer nesneleri siler.

DML - Veri Manipülasyon Dili

Sr.No.	Komut ve Açıklama
1	SELECT Bir veya daha fazla tablodan belirli kayıtları alır.
2	INSERT Bir kayıt oluşturur.
3	UPDATE Kayıtları değiştirir.
4	DELETE Kayıtları siler.

DCL - Veri Kontrol Dili

Sr.No.	Komut ve Açıklama
1	GRANT Kullanıcıya bir ayrıcalık verir.
2	REVOKE Kullanıcıdan verilen ayrıcalıkları geri alır.

RDBMS nedir?

RDBMS'nin açılımı Rneşeli Databaz Management System. RDBMS, SQL'in ve MS SQL Server, IBM DB2, Oracle, MySQL ve Microsoft Access gibi tüm modern veritabanı sistemlerinin temelidir.

İlişkisel veritabanı yönetim sistemi (RDBMS), EF Codd tarafından tanıtılan ilişkisel modeli temel alan bir veritabanı yönetim sistemidir (DBMS).

Masa nedir?

Bir RDBMS'deki veriler, veri tabanı nesnelerinde saklanır. tables. Bu tablo temelde ilgili veri girişlerinin bir koleksiyonudur ve çok sayıda sütun ve satırdan oluşur.

Bir tablo, ilişkisel bir veritabanında en yaygın ve en basit veri depolama biçimidir. Aşağıdaki program bir MÜŞTERİLER tablosu örneğidir -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Alan nedir?

Her tablo, alan adı verilen daha küçük varlıklara bölünmüştür. MÜŞTERİLER tablosundaki alanlar ID, AD, YAŞ, ADRES ve MAAŞ'tan oluşur.

Alan, tablodaki her kayıtla ilgili belirli bilgileri korumak için tasarlanmış, tablodaki bir sütundur.

Kayıt veya Satır nedir?

Bir kayıt, veri satırı olarak da adlandırılır, bir tabloda bulunan her bir giriştir. Örneğin, yukarıdaki MÜŞTERİLER tablosunda 7 kayıt vardır. Aşağıda, MÜŞTERİLER tablosundaki tek bir veri satırı veya kayıt bulunmaktadır -

+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Kayıt, tablodaki yatay bir varlıktır.

Sütun nedir?

Bir sütun, bir tablodaki belirli bir alanla ilişkili tüm bilgileri içeren bir tablodaki dikey bir varlıktır.

Örneğin, MÜŞTERİLER tablosundaki bir sütun, konum açıklamasını temsil eden ve aşağıda gösterildiği gibi olan ADDRESS sütunudur -

+-----------+
| ADDRESS   |
+-----------+
| Ahmedabad |
| Delhi     |
| Kota      |
| Mumbai    |
| Bhopal    |
| MP        |
| Indore    |
+----+------+

NULL değer nedir?

Bir tablodaki bir NULL değeri, boş görünen bir alandaki değerdir; bu, NULL değeri olan bir alanın değeri olmayan bir alandır.

Bir NULL değerinin sıfır değerinden veya boşluklar içeren bir alandan farklı olduğunu anlamak çok önemlidir. NULL değeri olan bir alan, kayıt oluşturma sırasında boş bırakılan alandır.

SQL Kısıtlamaları

Kısıtlamalar, bir tablodaki veri sütunlarına uygulanan kurallardır. Bunlar, bir tabloya girebilecek veri türünü sınırlamak için kullanılır. Bu, veri tabanındaki verilerin doğruluğunu ve güvenilirliğini sağlar.

Kısıtlamalar sütun düzeyinde veya tablo düzeyinde olabilir. Sütun düzeyi kısıtlamaları yalnızca bir sütuna uygulanır, oysa tablo düzeyi sınırlamaları tüm tabloya uygulanır.

Aşağıda, SQL'de bulunan en yaygın kullanılan kısıtlamalardan bazıları verilmiştir -

NOT NULL Kısıtlama - Bir sütunun NULL değerine sahip olmamasını sağlar.
VARSAYILAN Kısıtlama - Hiçbiri belirtilmediğinde bir sütun için varsayılan bir değer sağlar.
UNIQUE Constraint - Bir sütundaki tüm değerlerin farklı olmasını sağlar.
BİRİNCİL Anahtar - Bir veritabanı tablosundaki her satırı / kaydı benzersiz şekilde tanımlar.
YABANCI Anahtar - Başka bir veritabanı tablosundaki bir satırı / kaydı benzersiz şekilde tanımlar.
CHECK Kısıtlaması - CHECK kısıtlaması bir sütundaki tüm değerlerin belirli koşulları karşılamasını sağlar.
INDEX - Veritabanından çok hızlı bir şekilde veri oluşturmak ve almak için kullanılır.

Veri bütünlüğü

Her RDBMS'de aşağıdaki veri bütünlüğü kategorileri mevcuttur -

Entity Integrity − Tabloda yinelenen satır yok.
Domain Integrity − Değerlerin türünü, biçimini veya aralığını kısıtlayarak belirli bir sütun için geçerli girişleri zorunlu kılar.
Referential integrity − Diğer kayıtlar tarafından kullanılan satırlar silinemez.
User-Defined Integrity − Varlık, etki alanı veya bilgi bütünlüğüne girmeyen bazı özel iş kurallarını uygular.

Veritabanı Normalleştirme

Veritabanı normalleştirme, bir veritabanındaki verileri verimli bir şekilde düzenleme işlemidir. Bu normalleşme sürecinin iki nedeni vardır -

Gereksiz verileri ortadan kaldırmak, örneğin aynı verileri birden fazla tabloda depolamak.
Veri bağımlılıklarının sağlanması mantıklı.

Bu iki neden de, bir veritabanının kullandığı alan miktarını azalttığı ve verilerin mantıksal olarak depolanmasını sağladığı için değerli hedeflerdir. Normalleştirme, iyi bir veritabanı yapısı oluşturmanıza yardımcı olan bir dizi kılavuzdan oluşur.

Normalleştirme yönergeleri normal formlara bölünmüştür; Bir formu, format veya veritabanı yapısının düzenlenme şekli olarak düşünün. Normal formların amacı, veritabanı yapısını ilk normal form, ardından ikinci normal form ve son olarak üçüncü normal form kurallarına uyacak şekilde organize etmektir.

Bunu daha ileri götürmek ve dördüncü normal forma, beşinci normal forma vb. Gitmek sizin seçiminizdir, ancak genel olarak üçüncü normal form fazlasıyla yeterlidir.

İlk Normal Form (1NF)
İkinci Normal Form (2NF)
Üçüncü Normal Form (3NF)

Çalışılabilecek birçok popüler RDBMS vardır. Bu eğitim, en popüler RDBMS'lerden bazılarına kısa bir genel bakış sunar. Bu, temel özelliklerini karşılaştırmanıza yardımcı olur.

MySQL

MySQL, İsveçli bir şirket olan MySQL AB tarafından geliştirilen açık kaynaklı bir SQL veritabanıdır. MySQL, "netice" olarak telaffuz edilen SQL'in aksine "es-que-ell" olarak telaffuz edilir.

MySQL, Microsoft Windows, başlıca Linux dağıtımları, UNIX ve Mac OS X dahil olmak üzere birçok farklı platformu desteklemektedir.

MySQL, kullanımına (ticari olmayan / ticari) ve özelliklerine bağlı olarak ücretsiz ve ücretli sürümlere sahiptir. MySQL, çok hızlı, çok iş parçacıklı, çok kullanıcılı ve sağlam bir SQL veritabanı sunucusuyla birlikte gelir.

Tarih

MySQL'in geliştirilmesinin Michael Widenius ve David Axmark tarafından 1994'te başladı.
23 ilk iç bırakma ^rd May 1995.
Windows Sürümü 8 serbest bırakıldı ^inci Windows 95 ve NT için Ocak 1998.
Sürüm 3.23: beta, Haziran 2000, üretim sürümü Ocak 2001.
Sürüm 4.0: Ağustos 2002'den itibaren beta, Mart 2003 üretim sürümü (sendikalar).
Sürüm 4.1: Haziran 2004 beta, üretim sürümü Ekim 2004.
Sürüm 5.0: Mart 2005 beta, üretim sürümü Ekim 2005.
Sun Microsystems 26 MySQL AB edinilen ^inci Şubat 2008'de.
Sürüm 5.1: Üretim serbest bırakma 27 ^inci Kasım 2008'de.

Özellikleri

Yüksek performans.
Yüksek kullanılabilirlik.
Ölçeklenebilirlik ve Esneklik Her şeyi çalıştırın.
Güçlü İşlem Desteği.
Web ve Veri Ambarı Güçlü Yönleri.
Güçlü Veri Koruması.
Kapsamlı Uygulama Geliştirme.
Yönetim Kolaylığı.
Açık Kaynak Özgürlüğü ve 24 x 7 Desteği.
En Düşük Toplam Sahip Olma Maliyeti.

MS SQL Sunucusu

MS SQL Server, Microsoft Inc. tarafından geliştirilmiş bir İlişkisel Veritabanı Yönetim Sistemidir. Ana sorgu dilleri şunlardır:

T-SQL
ANSI SQL

Tarih

1987 - Sybase, UNIX için SQL Server'ı piyasaya sürdü.
1988 - Microsoft, Sybase ve Aston-Tate SQL Server'ı OS / 2'ye taşıdı.
1989 - Microsoft, Sybase ve Aston-Tate, OS / 2 için SQL Server 1.0'ı yayınladı.
1990 - SQL Server 1.1, Windows 3.0 istemcileri desteği ile piyasaya sürüldü.
Aston - Tate, SQL Server geliştirmeden çıkar.
2000 - Microsoft, SQL Server 2000'i yayınladı.
2001 - Microsoft, SQL Server Web Sürümü 1 (indirme) için XML yayınladı.
2002 - Microsoft, SQLXML 2.0'ı yayınladı (SQL Server için XML'den yeniden adlandırıldı).
2002 - Microsoft, SQLXML 3.0'ı yayınladı.
2005 - Microsoft, 7 Kasım 2005'te SQL Server 2005'i yayınladı.

Özellikleri

Yüksek performans
Yüksek kullanılabilirlik
Veritabanı aynalama
Veritabanı anlık görüntüleri
CLR entegrasyonu
Hizmet komisyoncusu
DDL tetikleyicileri
Sıralama fonksiyonları
Satır sürüm tabanlı izolasyon seviyeleri
XML entegrasyonu
TRY...CATCH
Veritabanı Postası

ORACLE

Çok büyük, çok kullanıcılı bir veritabanı yönetim sistemidir. Oracle, 'Oracle Corporation' tarafından geliştirilen ilişkisel bir veritabanı yönetim sistemidir.

Oracle, ağda veri isteyen ve gönderen birden çok müşteri arasında bir bilgi veritabanı olan kaynaklarını verimli bir şekilde yönetmek için çalışır.

İstemci / sunucu bilgi işlem için mükemmel bir veritabanı sunucusu seçimidir. Oracle, MSDOS, NetWare, UnixWare, OS / 2 ve çoğu UNIX çeşidi dahil olmak üzere hem istemciler hem de sunucular için tüm büyük işletim sistemlerini destekler.

Tarih

Oracle, 1977'de başladı ve sektördeki 32 harika yılını kutladı (1977'den 2009'a kadar).

1977 - Larry Ellison, Bob Miner ve Ed Oates, geliştirme çalışmalarını üstlenmek için Yazılım Geliştirme Laboratuvarlarını kurdu.
1979 - Oracle'ın 2.0 Versiyonu yayınlandı ve ilk ticari ilişkisel veritabanı ve ilk SQL veritabanı oldu. Şirket adını Relational Software Inc. (RSI) olarak değiştirdi.
1981 - RSI, Oracle için araçlar geliştirmeye başladı.
1982 - RSI, Oracle Corporation olarak yeniden adlandırıldı.
1983 - Oracle, C dilinde yeniden yazılan 3.0 sürümünü yayınladı ve birden çok platformda çalıştı.
1984 - Oracle 4.0 sürümü yayınlandı. Eşzamanlılık kontrolü - çok sürümlü okuma tutarlılığı vb. Gibi özellikler içeriyordu.
1985 - Oracle 4.0 sürümü yayınlandı. Eşzamanlılık kontrolü - çok sürümlü okuma tutarlılığı vb. Gibi özellikler içeriyordu.
2007 - Oracle, Oracle11g'yi piyasaya sürdü. Yeni sürüm, daha iyi bölümleme, kolay geçiş vb. Konulara odaklandı.

Özellikleri

Concurrency
Tutarlılığı Okuyun
Kilitleme Mekanizmaları
Quiesce Veritabanı
Portability
Kendi kendini yöneten veritabanı
SQL*Plus
ASM
Scheduler
Kaynak Yöneticisi
Veri depolama
Gerçekleştirilmiş görünümler
Bitmap dizinleri
Tablo sıkıştırma
Paralel Yürütme
Analitik SQL
Veri madenciliği
Partitioning

MS ERİŞİMİ

Bu, en popüler Microsoft ürünlerinden biridir. Microsoft Access, giriş düzeyinde bir veritabanı yönetim yazılımıdır. MS Access veritabanı hem ucuz hem de küçük ölçekli projeler için güçlü bir veritabanıdır.

MS Access, belirli bir SQL dili lehçesini (bazen Jet SQL olarak anılır) kullanan Jet veritabanı motorunu kullanır.

MS Access, MS Office paketinin profesyonel sürümü ile birlikte gelir. MS Access, kullanımı kolay sezgisel grafik arayüze sahiptir.

1992 - Access sürüm 1.0 yayınlandı.
1993 - Access Basic programlama dilinin eklenmesiyle uyumluluğu geliştirmek için Access 1.1 yayınlandı.
En önemli geçiş Access 97'den Access 2000'e olmuştur.
2007 - Access 2007, çok değerli ve ekli alanlar gibi karmaşık veri türlerini destekleyen yeni bir veritabanı biçimi olan ACCDB tanıtıldı.

Özellikleri

Kullanıcılar tablolar, sorgular, formlar ve raporlar oluşturabilir ve bunları makrolarla birbirine bağlayabilir.
Verileri Excel, Outlook, ASCII, dBase, Paradox, FoxPro, SQL Server, Oracle, ODBC vb. Dahil birçok formatta içe ve dışa aktarma seçeneği.
Ayrıca, uygulamayı ve verileri tek bir dosyada içerebilen Jet Veritabanı biçimi (Access 2007'de MDB veya ACCDB) vardır. Bu, tüm uygulamayı, bağlantısız ortamlarda çalıştırabilecek başka bir kullanıcıya dağıtmayı çok kolaylaştırır.
Microsoft Access, parametreli sorgular sunar. Bu sorgular ve Erişim tabloları, DAO veya ADO aracılığıyla VB6 ve .NET gibi diğer programlardan referans alınabilir.
Microsoft SQL Server'ın masaüstü sürümleri, Jet Veritabanı Motoruna alternatif olarak Access ile birlikte kullanılabilir.
Microsoft Access, dosya sunucusu tabanlı bir veritabanıdır. İstemci-sunucu ilişkisel veritabanı yönetim sistemlerinin (RDBMS) aksine, Microsoft Access veritabanı tetikleyicileri, depolanan prosedürler veya işlem günlüğü uygulamaz.

SQL - Sözdizimi

SQL'in ardından sözdizimi adı verilen benzersiz bir kurallar ve yönergeler dizisi gelir. Bu öğretici, tüm temel SQL Sözdizimini listeleyerek SQL ile hızlı bir başlangıç yapmanızı sağlar.

Tüm SQL ifadeleri SELECT, INSERT, UPDATE, DELETE, ALTER, DROP, CREATE, USE, SHOW gibi anahtar kelimelerden herhangi biriyle başlar ve tüm ifadeler noktalı virgülle (;) biter.

Burada dikkat edilmesi gereken en önemli nokta, SQL'in büyük / küçük harf duyarlı olmamasıdır, bu da SELECT ve select'in SQL deyimlerinde aynı anlama sahip olduğu anlamına gelir. Oysa MySQL, tablo adlarında fark yaratır. Dolayısıyla, MySQL ile çalışıyorsanız, o zaman veritabanında var olan tablo isimlerini vermeniz gerekir.

SQL'de Çeşitli Sözdizimi

Bu eğitimde verilen tüm örnekler bir MySQL sunucusu ile test edilmiştir.

SQL SELECT İfadesi

SELECT column1, column2....columnN
FROM   table_name;

SQL DISTINCT Cümlesi

SELECT DISTINCT column1, column2....columnN
FROM   table_name;

SQL WHERE Maddesi

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION;

SQL VE / VEYA Maddesi

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION-1 {AND|OR} CONDITION-2;

SQL IN Maddesi

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name IN (val-1, val-2,...val-N);

SQL BETWEEN Cümlesi

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name BETWEEN val-1 AND val-2;

SQL LIKE İfadesi

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name LIKE { PATTERN };

Maddeye Göre SQL SİPARİŞİ

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION
ORDER BY column_name {ASC|DESC};

SQL GROUP BY Clause

SELECT SUM(column_name)
FROM   table_name
WHERE  CONDITION
GROUP BY column_name;

SQL COUNT Maddesi

SELECT COUNT(column_name)
FROM   table_name
WHERE  CONDITION;

SQL OLAN Fıkra

SELECT SUM(column_name)
FROM   table_name
WHERE  CONDITION
GROUP BY column_name
HAVING (arithematic function condition);

SQL CREATE TABLE İfadesi

CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);

SQL DROP TABLE İfadesi

DROP TABLE table_name;

SQL CREATE INDEX İfadesi

CREATE UNIQUE INDEX index_name
ON table_name ( column1, column2,...columnN);

SQL DROP INDEX İfadesi

ALTER TABLE table_name
DROP INDEX index_name;

SQL DESC İfadesi

DESC table_name;

SQL TRUNCATE TABLE İfadesi

TRUNCATE TABLE table_name;

SQL ALTER TABLE İfadesi

ALTER TABLE table_name {ADD|DROP|MODIFY} column_name {data_ype};

SQL ALTER TABLE İfadesi (Yeniden Adlandır)

ALTER TABLE table_name RENAME TO new_table_name;

SQL INSERT INTO İfadesi

INSERT INTO table_name( column1, column2....columnN)
VALUES ( value1, value2....valueN);

SQL UPDATE İfadesi

UPDATE table_name
SET column1 = value1, column2 = value2....columnN=valueN
[ WHERE  CONDITION ];

SQL DELETE İfadesi

DELETE FROM table_name
WHERE  {CONDITION};

SQL CREATE DATABASE İfadesi

CREATE DATABASE database_name;

SQL DROP DATABASE İfadesi

DROP DATABASE database_name;

SQL KULLANIM İfadesi

USE database_name;

SQL COMMIT İfadesi

COMMIT;

SQL ROLLBACK İfadesi

ROLLBACK;

SQL - Veri Türleri

SQL Veri Türü, herhangi bir nesnenin veri türünü belirten bir özniteliktir. Her sütun, değişken ve ifadenin SQL'de ilgili bir veri türü vardır. Tablolarınızı oluştururken bu veri türlerini kullanabilirsiniz. Gereksiniminize göre bir tablo sütunu için bir veri türü seçebilirsiniz.

SQL Server, kullanımınız için aşağıda listelenen altı veri türü kategorisi sunar -

Tam Sayısal Veri Türleri

VERİ TİPİ	FROM	KİME
Bigint	-9,223,372,036,854,775,808	9,223,372,036,854,775,807
int	-2.147.483.648	2.147.483.647
Smallint	-32.768	32.767
Tinyint	0	255
bit	0	1
ondalık	-10 ^ 38 +1	10 ^ 38 -1
sayısal	-10 ^ 38 +1	10 ^ 38 -1
para	-922.337.203.685.477,5808	+922.337.203.685.477,5807
küçük para	-214.748.3648	+214.748.3647

Yaklaşık Sayısal Veri Türleri

VERİ TİPİ	FROM	KİME
yüzer	-1.79E + 308	1.79E + 308
gerçek	-3.40E + 38	3.40E + 38

Tarih ve Saat Veri Türleri

VERİ TİPİ	FROM	KİME
tarih saat	1 Oca 1753	31 Aralık 9999
küçük günler	1 Ocak 1900	6 Haz 2079
tarih	30 Haziran 1991 gibi bir tarihi kaydeder
zaman	12:30 gibi günün bir saatini kaydeder

Note - Burada, datetime 3.33 milisaniye doğruluğuna sahipken, smalldatetime 1 dakikalık doğruluğa sahiptir.

Karakter Dizeleri Veri Türleri

Sr.No.	VERİ TÜRÜ & Açıklama
1	char Maksimum uzunluk 8.000 karakterdir. (Sabit uzunlukta Unicode olmayan karakterler)
2	varchar Maksimum 8.000 karakter. (Değişken uzunlukta Unicode olmayan veriler).
3	varchar(max) Maksimum uzunluk 2E + 31 karakter, Değişken uzunlukta Unicode olmayan veriler (yalnızca SQL Server 2005).
4	text Maksimum uzunluğu 2.147.483.647 karakter olan değişken uzunluklu Unicode olmayan veriler.

Unicode Karakter Dizeleri Veri Türleri

Sr.No.	VERİ TÜRÜ & Açıklama
1	nchar 4.000 karakterlik maksimum uzunluk. (Sabit uzunlukta Unicode)
2	nvarchar 4.000 karakterlik maksimum uzunluk. (Değişken uzunluklu Unicode)
3	nvarchar(max) Maksimum uzunluk 2E + 31 karakter (yalnızca SQL Server 2005). (Değişken uzunluklu Unicode)
4	ntext Maksimum uzunluk 1.073.741.823 karakterdir. (Değişken uzunluklu Unicode)

İkili Veri Türleri

Sr.No.	VERİ TÜRÜ & Açıklama
1	binary Maksimum 8.000 bayt uzunluk (Sabit uzunlukta ikili veri)
2	varbinary Maksimum 8.000 bayt uzunluk. (Değişken uzunluklu ikili veri)
3	varbinary(max) Maksimum uzunluk 2E + 31 bayt (yalnızca SQL Server 2005). (Değişken uzunluklu İkili veri)
4	image 2.147.483.647 baytlık maksimum uzunluk. (Değişken uzunluklu İkili Veri)

Çeşitli Veri Türleri

Sr.No.	VERİ TÜRÜ & Açıklama
1	sql_variant Metin, ntext ve zaman damgası dışında SQL Server tarafından desteklenen çeşitli veri türlerinin değerlerini depolar.
2	timestamp Bir satır her güncellendiğinde güncellenen veritabanı çapında benzersiz bir numarayı depolar
3	uniqueidentifier Küresel olarak benzersiz bir tanımlayıcı (GUID) depolar
4	xml XML verilerini depolar. Xml örneklerini bir sütunda veya bir değişkende depolayabilirsiniz (yalnızca SQL Server 2005).
5	cursor İmleç nesnesine referans
6	table Daha sonra işlenmek üzere bir sonuç kümesi saklar

SQL - Operatörler

SQL'de Operatör nedir?

Operatör, karşılaştırmalar ve aritmetik işlemler gibi işlemleri gerçekleştirmek için öncelikle bir SQL ifadesinin WHERE yan tümcesinde kullanılan ayrılmış bir kelime veya karakterdir. Bu Operatörler, bir SQL ifadesindeki koşulları belirtmek ve bir ifadedeki birden çok koşul için bağlaçlar olarak hizmet etmek için kullanılır.

Aritmetik operatörler
Karşılaştırma operatörleri
Mantıksal operatörler
Koşulları reddetmek için kullanılan operatörler

SQL Aritmetik Operatörleri

Varsaymak 'variable a' 10 tutar ve 'variable b' 20 tutar, sonra -

Örnekleri Göster

Şebeke	Açıklama	Misal
+ (Toplama)	İşlecin her iki tarafına da değerler ekler.	a + b 30 verir
- (Çıkarma)	Sağ el işleneni sol el işlenenden çıkarır.	a - b -10 verir
* (Çarpma işlemi)	İşlecin her iki tarafındaki değerleri çarpar.	a * b 200 verir
/ (Bölünme)	Sol el işleneni sağ el işlenene böler.	b / a 2 verecek
% (Modül)	Sol el işleneni sağ el işlenene böler ve kalanı döndürür.	b% a 0 verir

SQL Karşılaştırma Operatörleri

Varsaymak 'variable a' 10 tutar ve 'variable b' 20 tutar, sonra -

Örnekleri Göster

Şebeke	Açıklama	Misal
=	İki işlenenin değerlerinin eşit olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a = b) doğru değil.
! =	İki işlenenin değerlerinin eşit olup olmadığını kontrol eder, değerler eşit değilse koşul doğru olur.	(a! = b) doğrudur.
<>	İki işlenenin değerlerinin eşit olup olmadığını kontrol eder, değerler eşit değilse koşul doğru olur.	(a <> b) doğrudur.
>	Sol işlenenin değerinin sağ işlenenin değerinden büyük olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a> b) doğru değil.
<	Soldaki işlenenin değerinin sağ işlenenin değerinden küçük olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a <b) doğrudur.
> =	Sol işlenenin değerinin sağ işlenenin değerinden büyük veya ona eşit olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a> = b) doğru değil.
<=	Sol işlenenin değerinin sağ işlenenin değerinden küçük veya ona eşit olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a <= b) doğrudur.
! <	Soldaki işlenenin değerinin sağ işlenenin değerinden küçük olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a! <b) yanlıştır.
!>	Sol işlenenin değerinin sağ işlenenin değerinden büyük olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a!> b) doğrudur.

SQL Mantıksal Operatörler

İşte SQL'de bulunan tüm mantıksal operatörlerin bir listesi.

Örnekleri Göster

Sr.No.	Operatör ve Açıklama
1	ALL ALL operatörü, bir değeri başka bir değer kümesindeki tüm değerlerle karşılaştırmak için kullanılır.
2	AND AND operatörü, bir SQL ifadesinin WHERE tümcesinde birden çok koşulun varlığına izin verir.
3	ANY ANY operatörü, bir değeri duruma göre listedeki herhangi bir uygulanabilir değerle karşılaştırmak için kullanılır.
4	BETWEEN BETWEEN operatörü, minimum değer ve maksimum değer verildiğinde, bir değerler kümesi dahilindeki değerleri aramak için kullanılır.
5	EXISTS EXISTS operatörü, belirli bir tabloda belirli bir kriteri karşılayan bir satırın varlığını aramak için kullanılır.
6	IN IN operatörü, bir değeri belirtilen değişmez değerler listesiyle karşılaştırmak için kullanılır.
7	LIKE LIKE operatörü, joker karakter operatörleri kullanarak bir değeri benzer değerlerle karşılaştırmak için kullanılır.
8	NOT NOT operatörü, birlikte kullanıldığı mantıksal operatörün anlamını tersine çevirir. Örneğin: MEVCUT DEĞİL, ARASI DEĞİL, İÇİNDE DEĞİL vb.This is a negate operator.
9	OR OR operatörü, bir SQL ifadesinin WHERE yan tümcesinde birden çok koşulu birleştirmek için kullanılır.
10	IS NULL NULL operatörü, bir değeri NULL değerle karşılaştırmak için kullanılır.
11	UNIQUE UNIQUE operatörü, belirli bir tablonun her satırında benzersizlik için arama yapar (yineleme yok).

SQL - İfadeler

İfade, bir değer olarak değerlendirilen bir veya daha fazla değer, işleç ve SQL işlevinin birleşimidir. Bu SQL İFADELERİ formül gibidir ve sorgu dilinde yazılır. Bunları, belirli bir veri kümesi için veritabanını sorgulamak için de kullanabilirsiniz.

Sözdizimi

SELECT ifadesinin temel sözdizimini aşağıdaki gibi düşünün -

SELECT column1, column2, columnN 
FROM table_name 
WHERE [CONDITION|EXPRESSION];

Aşağıda belirtilen farklı türde SQL ifadeleri vardır -

Boolean
Numeric
Date

Şimdi bunların her birini ayrıntılı olarak tartışalım.

Boolean İfadeler

SQL Boolean İfadeleri, verileri tek bir değerin eşleşmesine göre alır. Sözdizimi aşağıdadır -

SELECT column1, column2, columnN 
FROM table_name 
WHERE SINGLE VALUE MATCHING EXPRESSION;

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün -

SQL> SELECT * FROM CUSTOMERS;
+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+
7 rows in set (0.00 sec)

Aşağıdaki tablo, çeşitli SQL Boole İfadelerinin kullanımını gösteren basit bir örnektir -

SQL> SELECT * FROM CUSTOMERS WHERE SALARY = 10000;
+----+-------+-----+---------+----------+
| ID | NAME  | AGE | ADDRESS | SALARY   |
+----+-------+-----+---------+----------+
|  7 | Muffy |  24 | Indore  | 10000.00 |
+----+-------+-----+---------+----------+
1 row in set (0.00 sec)

Sayısal İfade

Bu ifadeler, herhangi bir sorguda herhangi bir matematiksel işlemi gerçekleştirmek için kullanılır. Sözdizimi aşağıdadır -

SELECT numerical_expression as  OPERATION_NAME
[FROM table_name
WHERE CONDITION] ;

Burada sayısal_ifade, matematiksel bir ifade veya herhangi bir formül için kullanılır. Aşağıda, SQL Sayısal İfadelerinin kullanımını gösteren basit bir örnek verilmiştir -

SQL> SELECT (15 + 6) AS ADDITION
+----------+
| ADDITION |
+----------+
|       21 |
+----------+
1 row in set (0.00 sec)

Bir tabloya veya belirli bir tablo sütununa göre toplam veri hesaplamaları olarak bilinenleri gerçekleştirmek için avg (), sum (), count (), vb. Gibi birkaç yerleşik işlev vardır.

SQL> SELECT COUNT(*) AS "RECORDS" FROM CUSTOMERS; 
+---------+
| RECORDS |
+---------+
|       7 |
+---------+
1 row in set (0.00 sec)

Tarih İfadeleri

Tarih İfadeleri mevcut sistem tarih ve saat değerlerini döndürür -

SQL>  SELECT CURRENT_TIMESTAMP;
+---------------------+
| Current_Timestamp   |
+---------------------+
| 2009-11-12 06:40:23 |
+---------------------+
1 row in set (0.00 sec)

Başka bir tarih ifadesi aşağıda gösterildiği gibidir -

SQL>  SELECT  GETDATE();;
+-------------------------+
| GETDATE                 |
+-------------------------+
| 2009-10-22 12:07:18.140 |
+-------------------------+
1 row in set (0.00 sec)

SQL - Veritabanı OLUŞTUR

SQL CREATE DATABASE deyimi yeni bir SQL veritabanı oluşturmak için kullanılır.

Sözdizimi

Bu CREATE DATABASE ifadesinin temel sözdizimi aşağıdaki gibidir -

CREATE DATABASE DatabaseName;

Her zaman veritabanı adı RDBMS içinde benzersiz olmalıdır.

Misal

Yeni bir veritabanı <testDB> oluşturmak istiyorsanız, CREATE DATABASE ifadesi aşağıda gösterildiği gibi olacaktır -

SQL> CREATE DATABASE testDB;

Herhangi bir veritabanı oluşturmadan önce yönetici ayrıcalığına sahip olduğunuzdan emin olun. Bir veritabanı oluşturulduktan sonra, veritabanı listesinde aşağıdaki şekilde kontrol edebilirsiniz -

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
| testDB             |
+--------------------+
7 rows in set (0.00 sec)

SQL - Veritabanını DROP veya DELETE

SQL DROP DATABASE deyimi, mevcut bir veritabanını SQL şemasına bırakmak için kullanılır.

Sözdizimi

DROP DATABASE ifadesinin temel sözdizimi aşağıdaki gibidir -

DROP DATABASE DatabaseName;

Her zaman veritabanı adı RDBMS içinde benzersiz olmalıdır.

Misal

Mevcut bir veritabanını <testDB> silmek istiyorsanız, DROP DATABASE ifadesi aşağıda gösterildiği gibi olacaktır -

SQL> DROP DATABASE testDB;

NOTE - Bu işlemi kullanmadan önce dikkatli olun, çünkü mevcut bir veritabanını silmek, veritabanında depolanan bilgilerin tamamının kaybolmasına neden olur.

Herhangi bir veritabanını bırakmadan önce yönetici ayrıcalığına sahip olduğunuzdan emin olun. Bir veritabanı düştüğünde, onu aşağıda gösterildiği gibi veritabanları listesinde kontrol edebilirsiniz -

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
+--------------------+
6 rows in set (0.00 sec)

SQL - Veritabanı SEÇ, KULLAN İfadesi

SQL Şemanızda birden fazla veritabanınız olduğunda, işleminize başlamadan önce tüm işlemlerin gerçekleştirileceği bir veritabanı seçmeniz gerekir.

SQL USE deyimi, SQL şemasındaki herhangi bir mevcut veritabanını seçmek için kullanılır.

Sözdizimi

USE ifadesinin temel sözdizimi aşağıda gösterildiği gibidir -

USE DatabaseName;

Her zaman veritabanı adı RDBMS içinde benzersiz olmalıdır.

Misal

Mevcut veritabanlarını aşağıda gösterildiği gibi kontrol edebilirsiniz -

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
+--------------------+
6 rows in set (0.00 sec)

Şimdi, AMROOD veritabanıyla çalışmak istiyorsanız, aşağıdaki SQL komutunu çalıştırabilir ve AMROOD veritabanıyla çalışmaya başlayabilirsiniz.

SQL> USE AMROOD;

SQL - CREATE Table

Temel bir tablo oluşturmak, tabloyu adlandırmayı ve sütunlarını ve her sütunun veri türünü tanımlamayı içerir.

SQL CREATE TABLE deyimi yeni bir tablo oluşturmak için kullanılır.

Sözdizimi

CREATE TABLE ifadesinin temel sözdizimi aşağıdaki gibidir -

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
   PRIMARY KEY( one or more columns )
);

CREATE TABLE, veritabanı sistemine ne yapmak istediğinizi söyleyen anahtar kelimedir. Bu durumda, yeni bir tablo oluşturmak istersiniz. Tablonun benzersiz adı veya tanımlayıcısı CREATE TABLE deyimini izler.

Daha sonra parantez içinde, tablodaki her bir sütunu tanımlayan ve ne tür bir veri türü olduğunu tanımlayan liste gelir. Sözdizimi aşağıdaki örnekle daha net hale gelir.

Mevcut bir tablonun bir kopyası, CREATE TABLE deyimi ve SELECT deyiminin bir kombinasyonu kullanılarak oluşturulabilir. Ayrıntıların tamamını Başka Bir Tablo Kullanarak Tablo Oluştur bölümünde kontrol edebilirsiniz .

Misal

Aşağıdaki kod bloğu, birincil anahtar olarak bir KIMLIĞE sahip bir MÜŞTERİ tablosu oluşturan bir örnektir ve NOT NULL, bu tablodaki kayıtlar oluşturulurken bu alanların NULL olamayacağını gösteren kısıtlamalardır -

SQL> CREATE TABLE CUSTOMERS(
   ID   INT              NOT NULL,
   NAME VARCHAR (20)     NOT NULL,
   AGE  INT              NOT NULL,
   ADDRESS  CHAR (25) ,
   SALARY   DECIMAL (18, 2),       
   PRIMARY KEY (ID)
);

Tablonuzun başarıyla oluşturulup oluşturulmadığını SQL sunucusu tarafından görüntülenen mesaja bakarak doğrulayabilirsiniz, aksi takdirde DESC aşağıdaki gibi komut -

SQL> DESC CUSTOMERS;
+---------+---------------+------+-----+---------+-------+
| Field   | Type          | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID      | int(11)       | NO   | PRI |         |       |
| NAME    | varchar(20)   | NO   |     |         |       |
| AGE     | int(11)       | NO   |     |         |       |
| ADDRESS | char(25)      | YES  |     | NULL    |       |
| SALARY  | decimal(18,2) | YES  |     | NULL    |       |
+---------+---------------+------+-----+---------+-------+
5 rows in set (0.00 sec)

Artık veritabanınızda müşterilerle ilgili gerekli bilgileri saklamak için kullanabileceğiniz MÜŞTERİLER tablonuz var.

SQL - Tabloyu DROP veya DELETE

SQL DROP TABLE deyimi, bir tablo tanımını ve o tablo için tüm verileri, dizinleri, tetikleyicileri, kısıtlamaları ve izin özelliklerini kaldırmak için kullanılır.

NOTE - Bu komutu kullanırken çok dikkatli olmalısınız çünkü bir tablo silindikten sonra o tablodaki tüm bilgiler de sonsuza kadar kaybolacaktır.

Sözdizimi

Bu DROP TABLE ifadesinin temel sözdizimi aşağıdaki gibidir -

DROP TABLE table_name;

Misal

Önce MÜŞTERİLER tablosunu doğrulayalım ve ardından aşağıda gösterildiği gibi veritabanından silelim -

SQL> DESC CUSTOMERS;
+---------+---------------+------+-----+---------+-------+
| Field   | Type          | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID      | int(11)       | NO   | PRI |         |       |
| NAME    | varchar(20)   | NO   |     |         |       |
| AGE     | int(11)       | NO   |     |         |       |
| ADDRESS | char(25)      | YES  |     | NULL    |       |
| SALARY  | decimal(18,2) | YES  |     | NULL    |       |
+---------+---------------+------+-----+---------+-------+
5 rows in set (0.00 sec)

Bu, MÜŞTERİLER tablosunun veritabanında mevcut olduğu anlamına gelir, bu yüzden şimdi aşağıda gösterildiği gibi bırakalım.

SQL> DROP TABLE CUSTOMERS;
Query OK, 0 rows affected (0.01 sec)

Şimdi, DESC komutunu denerseniz, aşağıdaki hatayı alırsınız -

SQL> DESC CUSTOMERS;
ERROR 1146 (42S02): Table 'TEST.CUSTOMERS' doesn't exist

Burada TEST, örneklerimiz için kullandığımız veritabanı adıdır.

SQL - INSERT Sorgusu

SQL INSERT INTO İfade, veritabanındaki bir tabloya yeni veri satırları eklemek için kullanılır.

Sözdizimi

INSERT INTO deyiminin aşağıda gösterilen iki temel sözdizimi vardır.

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)  
VALUES (value1, value2, value3,...valueN);

Burada sütun1, sütun2, sütun3, ... sütunN, verileri eklemek istediğiniz tablodaki sütunların adlarıdır.

Tablonun tüm sütunları için değer ekliyorsanız, SQL sorgusunda sütun (lar) adını belirtmeniz gerekmeyebilir. Ancak değerlerin sırasının tablodaki sütunlarla aynı sırada olduğundan emin olun.

SQL INSERT INTO sözdizimi aşağıdaki gibi olacaktır -

INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

Misal

Aşağıdaki ifadeler MÜŞTERİLER tablosunda altı kayıt oluşturacaktır.

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Ramesh', 32, 'Ahmedabad', 2000.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (2, 'Khilan', 25, 'Delhi', 1500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (3, 'kaushik', 23, 'Kota', 2000.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (4, 'Chaitali', 25, 'Mumbai', 6500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (5, 'Hardik', 27, 'Bhopal', 8500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (6, 'Komal', 22, 'MP', 4500.00 );

Aşağıda gösterildiği gibi ikinci sözdizimini kullanarak MÜŞTERİLER tablosunda bir kayıt oluşturabilirsiniz.

INSERT INTO CUSTOMERS 
VALUES (7, 'Muffy', 24, 'Indore', 10000.00 );

Yukarıdaki ifadelerin tümü, aşağıda gösterildiği gibi MÜŞTERİLER tablosunda aşağıdaki kayıtları oluşturacaktır.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Bir tabloyu başka bir tabloyu kullanarak doldurun

Verileri başka bir tablo üzerindeki select deyimi aracılığıyla bir tabloya yerleştirebilirsiniz; diğer tablonun, ilk tabloyu doldurmak için gerekli olan bir dizi alana sahip olması koşuluyla.

İşte sözdizimi -

INSERT INTO first_table_name [(column1, column2, ... columnN)] 
   SELECT column1, column2, ...columnN 
   FROM second_table_name
   [WHERE condition];

SQL - Sorgu SEÇ

SQL SELECTdeyimi, bu verileri bir sonuç tablosu biçiminde döndüren bir veritabanı tablosundan verileri almak için kullanılır. Bu sonuç tablolarına sonuç kümeleri denir.

Sözdizimi

SELECT ifadesinin temel sözdizimi aşağıdaki gibidir -

SELECT column1, column2, columnN FROM table_name;

Burada sütun1, sütun2 ... değerlerini almak istediğiniz bir tablonun alanlarıdır. Alanda bulunan tüm alanları getirmek istiyorsanız, aşağıdaki sözdizimini kullanabilirsiniz.

SELECT * FROM table_name;

Misal

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıdaki kod, MÜŞTERİLER tablosunda bulunan müşterilerin ID, Ad ve Maaş alanlarını getirecek bir örnektir.

SQL> SELECT ID, NAME, SALARY FROM CUSTOMERS;

Bu, aşağıdaki sonucu verecektir -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  1 | Ramesh   |  2000.00 |
|  2 | Khilan   |  1500.00 |
|  3 | kaushik  |  2000.00 |
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

MÜŞTERİLER tablosunun tüm alanlarını getirmek istiyorsanız, aşağıdaki sorguyu kullanmalısınız.

SQL> SELECT * FROM CUSTOMERS;

Bu, aşağıda gösterildiği gibi sonucu verecektir.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

SQL - WHERE Cümlesi

SQL WHEREcümleci tümce, verileri tek bir tablodan alırken veya birden çok tabloyla birleştirerek bir koşul belirtmek için kullanılır. Verilen koşul karşılanırsa, yalnızca tablodan belirli bir değer döndürür. Kayıtları filtrelemek ve yalnızca gerekli kayıtları almak için WHERE yan tümcesini kullanmalısınız.

WHERE yan tümcesi yalnızca SELECT deyiminde kullanılmaz, aynı zamanda sonraki bölümlerde inceleyeceğimiz UPDATE, DELETE deyiminde vb. De kullanılır.

Sözdizimi

SELECT deyiminin WHERE yan tümcesi ile temel sözdizimi aşağıda gösterildiği gibidir.

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition]

Karşılaştırma veya >, <, =, gibi mantıksal operatörleri kullanarak bir koşul belirtebilirsiniz.LIKE, NOT, vb. Aşağıdaki örnekler bu kavramı netleştirecektir.

Misal

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıdaki kod, maaşın 2000'den fazla olduğu MÜŞTERİLER tablosundan Kimlik, Ad ve Maaş alanlarını getirecek bir örnektir -

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000;

Bu, aşağıdaki sonucu verecektir -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

Aşağıdaki sorgu, adı olan bir müşteri için MÜŞTERİLER tablosundan Kimlik, Ad ve Maaş alanlarını getirecek bir örnektir. Hardik.

Burada, tüm dizelerin tek tırnak ('') içinde verilmesi gerektiğine dikkat etmek önemlidir. Oysa sayısal değerler yukarıdaki örnekte olduğu gibi alıntı yapılmadan verilmelidir.

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE NAME = 'Hardik';

Bu, aşağıdaki sonucu verecektir -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  5 | Hardik   |  8500.00 |
+----+----------+----------+

SQL - VE ve VEYA Birbirine Bağlı Operatörler

SQL AND & ORoperatörler, bir SQL ifadesindeki verileri daraltmak için birden çok koşulu birleştirmek için kullanılır. Bu iki operatör, bağlantılı operatörler olarak adlandırılır.

Bu operatörler, aynı SQL deyiminde farklı operatörlerle birden fazla karşılaştırma yapmak için bir yol sağlar.

AND Operatörü

AND operatörü, bir SQL ifadesinin WHERE yan tümcesinde birden çok koşulun varlığına izin verir.

Sözdizimi

WHERE yan tümcesine sahip AND operatörünün temel sözdizimi aşağıdaki gibidir -

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];

AND işlecini kullanarak N sayıda koşulu birleştirebilirsiniz. İster işlem ister sorgu olsun, bir işlemin SQL ifadesi tarafından gerçekleştirilmesi için AND ile ayrılan tüm koşullar DOĞRU olmalıdır.

Misal

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıda, maaşın 2000'den büyük ve yaşın 25 yaşın altında olduğu MÜŞTERİLER tablosundan Kimlik, İsim ve Maaş alanlarını getirecek bir örnek verilmiştir -

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000 AND age < 25;

Bu, aşağıdaki sonucu verecektir -

+----+-------+----------+
| ID | NAME  | SALARY   |
+----+-------+----------+
|  6 | Komal |  4500.00 |
|  7 | Muffy | 10000.00 |
+----+-------+----------+

Ameliyathane Operatörü

OR operatörü, bir SQL ifadesinin WHERE yan tümcesinde birden çok koşulu birleştirmek için kullanılır.

Sözdizimi

OR operatörünün WHERE yan tümcesine sahip temel sözdizimi aşağıdaki gibidir -

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]

VEYA operatörünü kullanarak N sayıda koşulu birleştirebilirsiniz. İster işlem ister sorgu olsun, bir işlemin SQL deyimi tarafından gerçekleştirilmesi için, OR ile ayrılan koşullardan yalnızca BİRİNİN DOĞRU olması gerekir.

Misal

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıdaki kod bloğunda, maaşın 2000'den büyük olduğu VEYA yaşın 25 yaşın altında olduğu MÜŞTERİLER tablosundan Kimlik, Ad ve Maaş alanlarını getirecek bir sorgu vardır.

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000 OR age < 25;

Bu, aşağıdaki sonucu verecektir -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  3 | kaushik  |  2000.00 |
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

SQL - GÜNCELLEME Sorgusu

SQL UPDATESorgu, bir tablodaki mevcut kayıtları değiştirmek için kullanılır. Seçilen satırları güncellemek için WHERE yan tümcesini UPDATE sorgusuyla birlikte kullanabilirsiniz, aksi takdirde tüm satırlar etkilenir.

Sözdizimi

UPDATE sorgusunun WHERE yan tümcesine sahip temel sözdizimi aşağıdaki gibidir -

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

AND veya OR operatörlerini kullanarak N sayıda koşulu birleştirebilirsiniz.

Misal

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıdaki sorgu, tabloda kimlik numarası 6 olan bir müşteri için ADRES'i güncelleyecektir.

SQL> UPDATE CUSTOMERS
SET ADDRESS = 'Pune'
WHERE ID = 6;

Şimdi, MÜŞTERİLER tablosu aşağıdaki kayıtlara sahip olacaktır -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | Pune      |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

MÜŞTERİLER tablosundaki tüm ADRES ve MAAŞ sütun değerlerini değiştirmek istiyorsanız, aşağıdaki kod bloğunda gösterildiği gibi GÜNCELLEME sorgusu yeterli olacağından WHERE yan tümcesini kullanmanıza gerek yoktur.

SQL> UPDATE CUSTOMERS
SET ADDRESS = 'Pune', SALARY = 1000.00;

Şimdi, MÜŞTERİLER tablosu aşağıdaki kayıtlara sahip olacaktır -

+----+----------+-----+---------+---------+
| ID | NAME     | AGE | ADDRESS | SALARY  |
+----+----------+-----+---------+---------+
|  1 | Ramesh   |  32 | Pune    | 1000.00 |
|  2 | Khilan   |  25 | Pune    | 1000.00 |
|  3 | kaushik  |  23 | Pune    | 1000.00 |
|  4 | Chaitali |  25 | Pune    | 1000.00 |
|  5 | Hardik   |  27 | Pune    | 1000.00 |
|  6 | Komal    |  22 | Pune    | 1000.00 |
|  7 | Muffy    |  24 | Pune    | 1000.00 |
+----+----------+-----+---------+---------+

SQL - Sorguyu SİL

SQL DELETE Sorgusu, bir tablodan var olan kayıtları silmek için kullanılır.

Seçilen satırları silmek için WHERE yan tümcesini bir DELETE sorgusuyla birlikte kullanabilirsiniz, aksi takdirde tüm kayıtlar silinir.

Sözdizimi

WHERE yan tümcesi ile DELETE sorgusunun temel sözdizimi aşağıdaki gibidir -

DELETE FROM table_name
WHERE [condition];

VE veya VEYA operatörlerini kullanarak N sayıda koşulu birleştirebilirsiniz.

Misal

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıdaki kodda, kimliği 6 olan bir müşteriyi SİLECEK bir sorgu vardır.

SQL> DELETE FROM CUSTOMERS
WHERE ID = 6;

Şimdi, MÜŞTERİLER tablosu aşağıdaki kayıtlara sahip olacaktır.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

MÜŞTERİLER tablosundaki tüm kayıtları SİLMEK istiyorsanız, WHERE yan tümcesini kullanmanıza gerek yoktur ve DELETE sorgusu aşağıdaki gibi olacaktır -

SQL> DELETE FROM CUSTOMERS;

Şimdi, MÜŞTERİLER tablosunda herhangi bir kayıt olmayacak.

SQL - LIKE Cümlesi

SQL LIKEcümlesi, joker karakter operatörleri kullanarak bir değeri benzer değerlerle karşılaştırmak için kullanılır. LIKE işleci ile birlikte kullanılan iki joker karakter vardır.

Yüzde işareti (%)
Alt çizgi (_)

Yüzde işareti sıfır, bir veya birden çok karakteri temsil eder. Alt çizgi, tek bir sayı veya karakteri temsil eder. Bu semboller kombinasyonlarda kullanılabilir.

Sözdizimi

% Ve _'nin temel sözdizimi aşağıdaki gibidir -

SELECT FROM table_name
WHERE column LIKE 'XXXX%'

or 

SELECT FROM table_name
WHERE column LIKE '%XXXX%'

or

SELECT FROM table_name
WHERE column LIKE 'XXXX_'

or

SELECT FROM table_name
WHERE column LIKE '_XXXX'

or

SELECT FROM table_name
WHERE column LIKE '_XXXX_'

VE veya VEYA operatörlerini kullanarak N sayıda koşulu birleştirebilirsiniz. Burada XXXX, herhangi bir sayısal değer veya dize değeri olabilir.

Misal

Aşağıdaki tabloda, WHERE parçasının '%' ve '_' operatörleriyle farklı LIKE yan tümcesine sahip olduğunu gösteren birkaç örnek vardır -

Sr.No.	Açıklama ve Açıklama
1	WHERE SALARY LIKE '200%' 200 ile başlayan tüm değerleri bulur.
2	WHERE SALARY LIKE '%200%' Herhangi bir konumda 200 olan tüm değerleri bulur.
3	WHERE SALARY LIKE '_00%' İkinci ve üçüncü konumlarda 00 olan tüm değerleri bulur.
4	WHERE SALARY LIKE '2_%_%' 2 ile başlayan ve en az 3 karakter uzunluğunda olan tüm değerleri bulur.
5	WHERE SALARY LIKE '%2' 2 ile biten tüm değerleri bulur.
6	WHERE SALARY LIKE '_2%3' İkinci konumda 2 olan ve 3 ile biten değerleri bulur.
7	WHERE SALARY LIKE '2___3' 2 ile başlayan ve 3 ile biten beş basamaklı bir sayıdaki tüm değerleri bulur.

Gerçek bir örnek alalım, aşağıda gösterilen kayıtların bulunduğu MÜŞTERİLER tablosunu ele alalım.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıda, MAAŞ'ın 200 ile başladığı MÜŞTERİLER tablosundaki tüm kayıtları görüntüleyen bir örnek verilmiştir.

SQL> SELECT * FROM CUSTOMERS
WHERE SALARY LIKE '200%';

Bu, aşağıdaki sonucu verecektir -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
+----+----------+-----+-----------+----------+

SQL - TOP, LIMIT veya ROWNUM İfadesi

SQL TOP cümlesi, bir tablodan bir TOP N sayı veya yüzde X kayıt almak için kullanılır.

Note- Tüm veritabanları TOP maddesini desteklemiyor. Örneğin MySQL,LIMIT Oracle, sınırlı sayıda kaydı getirirken, ROWNUM sınırlı sayıda kaydı getirme komutu.

Sözdizimi

Bir SELECT ifadesiyle TOP yan tümcesinin temel sözdizimi aşağıdaki gibi olacaktır.

SELECT TOP number|percent column_name(s)
FROM table_name
WHERE [condition]

Misal

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıdaki sorgu, CUSTOMERS tablosundan ilk 3 kaydı getiren SQL sunucusundaki bir örnektir.

SQL> SELECT TOP 3 * FROM CUSTOMERS;

Bu, aşağıdaki sonucu verecektir -

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

MySQL sunucusu kullanıyorsanız, işte eşdeğer bir örnek -

SQL> SELECT * FROM CUSTOMERS
LIMIT 3;

Bu, aşağıdaki sonucu verecektir -

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

Bir Oracle sunucusu kullanıyorsanız, aşağıdaki kod bloğunun eşdeğer bir örneği vardır.

SQL> SELECT * FROM CUSTOMERS
WHERE ROWNUM <= 3;

Bu, aşağıdaki sonucu verecektir -

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

SQL - Maddeye Göre SİPARİŞ

SQL ORDER BYcümlesi, verileri bir veya daha fazla sütuna göre artan veya azalan düzende sıralamak için kullanılır. Bazı veritabanları, sorgu sonuçlarını varsayılan olarak artan bir sırada sıralar.

Sözdizimi

ORDER BY yan tümcesinin temel sözdizimi aşağıdaki gibidir -

SELECT column-list 
FROM table_name 
[WHERE condition] 
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

ORDER BY yan tümcesinde birden fazla sütun kullanabilirsiniz. Bu sütunu sıralamak için kullandığınız sütunun sütun listesinde olması gerektiğinden emin olun.

Misal

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıdaki kod bloğunun, sonucu artan sırada AD ve MAAŞ'a göre sıralayan bir örneği vardır -

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME, SALARY;

Bu, aşağıdaki sonucu verecektir -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Aşağıdaki kod bloğunun, sonucu azalan sırada NAME ile sıralayan bir örneği vardır.

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME DESC;

Bu, aşağıdaki sonucu verecektir -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
+----+----------+-----+-----------+----------+

SQL - Gruplama Ölçütü

SQL GROUP BYyan tümcesi, aynı verileri gruplar halinde düzenlemek için SELECT deyimiyle birlikte kullanılır. Bu GROUP BY yan tümcesi, bir SELECT deyimindeki WHERE yan tümcesini izler ve ORDER BY yan tümcesinden önce gelir.

Sözdizimi

GROUP BY yan tümcesinin temel sözdizimi aşağıdaki kod bloğunda gösterilmektedir. GROUP BY yan tümcesi, WHERE yan tümcesindeki koşulları takip etmeli ve kullanılıyorsa ORDER BY yan tümcesinden önce gelmelidir.

SELECT column1, column2
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2
ORDER BY column1, column2

Misal

MÜŞTERİLER tablosunun aşağıdaki kayıtlara sahip olduğunu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Her bir müşterideki maaşın toplam tutarını bilmek istiyorsanız, GROUP BY sorgusu aşağıdaki gibi olacaktır.

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
   GROUP BY NAME;

Bu, aşağıdaki sonucu verecektir -

+----------+-------------+
| NAME     | SUM(SALARY) |
+----------+-------------+
| Chaitali |     6500.00 |
| Hardik   |     8500.00 |
| kaushik  |     2000.00 |
| Khilan   |     1500.00 |
| Komal    |     4500.00 |
| Muffy    |    10000.00 |
| Ramesh   |     2000.00 |
+----------+-------------+

Şimdi, CUSTOMERS tablosunun, yinelenen adlara sahip aşağıdaki kayıtlara sahip olduğu bir tabloya bakalım -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Ramesh   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | kaushik  |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Şimdi yine, her bir müşterinin toplam maaş miktarını bilmek istiyorsanız, GROUP BY sorgusu aşağıdaki gibi olacaktır -

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
   GROUP BY NAME;

Bu, aşağıdaki sonucu verecektir -

+---------+-------------+
| NAME    | SUM(SALARY) |
+---------+-------------+
| Hardik  |     8500.00 |
| kaushik |     8500.00 |
| Komal   |     4500.00 |
| Muffy   |    10000.00 |
| Ramesh  |     3500.00 |
+---------+-------------+

SQL - Farklı Anahtar Kelime

SQL DISTINCT anahtar sözcük, tüm yinelenen kayıtları ortadan kaldırmak ve yalnızca benzersiz kayıtları almak için SELECT deyimiyle birlikte kullanılır.

Bir tabloda birden çok yinelenen kaydınız olduğunda bir durum olabilir. Bu tür kayıtları getirirken, yinelenen kayıtları getirmek yerine yalnızca bu benzersiz kayıtları getirmek daha mantıklıdır.

Sözdizimi

Yinelenen kayıtları elemek için DISTINCT anahtar kelimesinin temel sözdizimi aşağıdaki gibidir -

SELECT DISTINCT column1, column2,.....columnN 
FROM table_name
WHERE [condition]

Misal

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Öncelikle, aşağıdaki SELECT sorgusunun yinelenen maaş kayıtlarını nasıl döndürdüğünü görelim.

SQL> SELECT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Bu, maaşın (2000) iki kez geldiği ve orijinal tablodan yinelenen bir kayıt olan aşağıdaki sonucu üretecektir.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

Şimdi, yukarıdaki SELECT sorgusu ile DISTINCT anahtar kelimesini kullanalım ve sonra sonucu görelim.

SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Bu, yinelenen girişimiz olmadığında aşağıdaki sonucu üretecektir.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

SQL - SIRALAMA Sonuçları

Sözdizimi

Sonucu artan veya azalan düzende sıralamak için kullanılacak ORDER BY yan tümcesinin temel sözdizimi aşağıdaki gibidir -

SELECT column-list 
FROM table_name 
[WHERE condition] 
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

ORDER BY yan tümcesinde birden fazla sütun kullanabilirsiniz. Sıralamak için kullandığınız sütun ne olursa olsun, bu sütunun sütun listesinde olması gerektiğinden emin olun.

Misal

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıda, sonucu artan sırada AD ve MAAŞ'a göre sıralayacak bir örnek verilmiştir.

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME, SALARY;

Bu, aşağıdaki sonucu verecektir -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Aşağıdaki kod bloğunun, sonucu NAME göre azalan bir sırada sıralayan bir örneği vardır.

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME DESC;

Bu, aşağıdaki sonucu verecektir -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
+----+----------+-----+-----------+----------+

Satırları kendi tercih ettikleri sırayla getirmek için, kullanılan SELECT sorgusu aşağıdaki gibi olacaktır -

SQL> SELECT * FROM CUSTOMERS
   ORDER BY (CASE ADDRESS
   WHEN 'DELHI' 	 THEN 1
   WHEN 'BHOPAL' 	 THEN 2
   WHEN 'KOTA' 	 THEN 3
   WHEN 'AHMEDABAD' THEN 4
   WHEN 'MP' 	THEN 5
   ELSE 100 END) ASC, ADDRESS DESC;

Bu, aşağıdaki sonucu verecektir -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Bu, müşterileri adresinizde ADDRESS'e göre sıralayacaktır. ownoOrderönce ve kalan adresler için doğal bir sırada. Ayrıca, kalan Adresler ters alfabetik sırada sıralanacaktır.

SQL - Kısıtlamalar

Kısıtlamalar, bir tablonun veri sütunlarına uygulanan kurallardır. Bunlar, bir tabloya girebilecek veri türünü sınırlamak için kullanılır. Bu, veri tabanındaki verilerin doğruluğunu ve güvenilirliğini sağlar.

Kısıtlamalar, bir sütun düzeyinde veya bir tablo düzeyinde olabilir. Sütun düzeyindeki kısıtlamalar yalnızca bir sütuna, tablo düzeyindeki sınırlamalar ise tüm tabloya uygulanır.

Aşağıda, SQL'de bulunan en yaygın kullanılan kısıtlamalardan bazıları verilmiştir. Bu kısıtlamalar SQL - RDBMS Kavramları bölümünde zaten tartışılmıştır , ancak bu noktada bunları gözden geçirmeye değer.

NOT NULL Kısıtlama - Bir sütunun NULL değerine sahip olmamasını sağlar.
VARSAYILAN Kısıtlama - Hiçbiri belirtilmediğinde bir sütun için varsayılan bir değer sağlar.
UNIQUE Constraint - Bir sütundaki tüm değerlerin farklı olmasını sağlar.
BİRİNCİL Anahtar - Bir veritabanı tablosundaki her satırı / kaydı benzersiz şekilde tanımlar.
YABANCI Anahtar - Verilen veritabanı tablosunun herhangi birindeki bir satırı / kaydı benzersiz şekilde tanımlar.
CHECK Kısıtlaması - CHECK kısıtlaması bir sütundaki tüm değerlerin belirli koşulları karşılamasını sağlar.
INDEX - Veritabanından çok hızlı bir şekilde veri oluşturmak ve almak için kullanılır.

Kısıtlamalar, CREATE TABLE deyimiyle bir tablo oluşturulduğunda belirtilebilir veya tablo oluşturulduktan sonra bile kısıtlamalar oluşturmak için ALTER TABLE deyimini kullanabilirsiniz.

Düşürme Kısıtlamaları

Tanımladığınız herhangi bir kısıtlama, DROP CONSTRAINT seçeneği ile ALTER TABLE komutu kullanılarak kaldırılabilir.

Örneğin, EMPLOYEES tablosundaki birincil anahtar kısıtlamasını kaldırmak için aşağıdaki komutu kullanabilirsiniz.

ALTER TABLE EMPLOYEES DROP CONSTRAINT EMPLOYEES_PK;

Bazı uygulamalar, belirli kısıtlamaları kaldırmak için kısayollar sağlayabilir. Örneğin, Oracle'daki bir tablo için birincil anahtar kısıtlamasını kaldırmak için aşağıdaki komutu kullanabilirsiniz.

ALTER TABLE EMPLOYEES DROP PRIMARY KEY;

Bazı uygulamalar, kısıtlamaları devre dışı bırakmanıza izin verir. Bir kısıtlamayı veritabanından kalıcı olarak kaldırmak yerine, kısıtlamayı geçici olarak devre dışı bırakıp daha sonra etkinleştirmek isteyebilirsiniz.

Bütünlük Kısıtlamaları

İlişkisel bir veritabanındaki verilerin doğruluğunu ve tutarlılığını sağlamak için bütünlük kısıtlamaları kullanılır. Veri bütünlüğü, ilişkisel bir veri tabanında, referans bütünlüğü kavramı aracılığıyla ele alınır.

Bir rol oynayan birçok bütünlük kısıtlaması türü vardır. Referential Integrity (RI). Bu kısıtlamalar, Birincil Anahtar, Yabancı Anahtar, Benzersiz Kısıtlamalar ve yukarıda bahsedilen diğer kısıtlamaları içerir.

SQL - Birleştirmeleri Kullanma

SQL Joinsyan tümcesi, bir veritabanındaki iki veya daha fazla tablodaki kayıtları birleştirmek için kullanılır. BİRLEŞTİRME, iki tablodaki alanları her biri için ortak olan değerleri kullanarak birleştirmek için bir araçtır.

Aşağıdaki iki tabloyu düşünün -

Table 1 - MÜŞTERİ Tablosu

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - SİPARİŞLER Tablosu

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Şimdi, bu iki tabloyu aşağıda gösterildiği gibi SELECT deyimimizde birleştirelim.

SQL> SELECT ID, NAME, AGE, AMOUNT
   FROM CUSTOMERS, ORDERS
   WHERE  CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Bu, aşağıdaki sonucu verecektir.

+----+----------+-----+--------+
| ID | NAME     | AGE | AMOUNT |
+----+----------+-----+--------+
|  3 | kaushik  |  23 |   3000 |
|  3 | kaushik  |  23 |   1500 |
|  2 | Khilan   |  25 |   1560 |
|  4 | Chaitali |  25 |   2060 |
+----+----------+-----+--------+

Burada, birleştirmenin WHERE yan tümcesinde gerçekleştirildiği dikkat çekicidir. Tabloları birleştirmek için =, <,>, <>, <=,> =,! =, BETWEEN, LIKE ve NOT gibi çeşitli operatörler kullanılabilir; hepsi tabloları birleştirmek için kullanılabilir. Bununla birlikte, en yaygın operatör eşittir simgesidir.

SQL'de farklı türde birleştirme vardır -

INNER JOIN - her iki tabloda da bir eşleşme olduğunda satırları döndürür.
LEFT JOIN - sağ tabloda eşleşme olmasa bile soldaki tablodaki tüm satırları döndürür.
RIGHT JOIN - sol tabloda eşleşme olmasa bile sağ tablodaki tüm satırları döndürür.
FULL JOIN - tablolardan birinde eşleşme olduğunda satırları döndürür.
SELF JOIN - bir tabloyu, tablo iki tablodaymış gibi kendisine birleştirmek için kullanılır, SQL ifadesindeki en az bir tabloyu geçici olarak yeniden adlandırır.
CARTESIAN JOIN - iki veya daha fazla birleştirilmiş tablodaki kayıt kümelerinin Kartezyen çarpımını döndürür.

Şimdi bu birleşimlerin her birini ayrıntılı olarak tartışalım.

SQL - BİRLİKLER MADDESİ

SQL UNION yan tümcesi / operatörü, iki veya daha fazla SELECT ifadesinin sonuçlarını, yinelenen satırlar döndürmeden birleştirmek için kullanılır.

Bu UNION yan tümcesini kullanmak için, her SELECT deyiminin sahip olması gerekir

Aynı sayıda sütun seçildi
Aynı sayıda sütun ifadesi
Aynı veri türü ve
Onları aynı sıraya koyun

Ancak aynı uzunlukta olmaları gerekmez.

Sözdizimi

A'nın temel sözdizimi UNION fıkra aşağıdaki gibidir -

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Burada verilen koşul, gereksiniminize göre verilen herhangi bir ifade olabilir.

Misal

Aşağıdaki iki tabloyu düşünün.

Table 1 - MÜŞTERİLER Tablosu aşağıdaki gibidir.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - SİPARİŞLER Tablosu aşağıdaki gibidir.

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Şimdi bu iki tabloyu SELECT deyimimizde aşağıdaki gibi birleştirelim -

SQL> SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   LEFT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION
   SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   RIGHT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Bu, aşağıdaki sonucu verecektir -

+------+----------+--------+---------------------+
| ID   | NAME     | AMOUNT | DATE                |
+------+----------+--------+---------------------+
|    1 | Ramesh   |   NULL | NULL                |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
|    5 | Hardik   |   NULL | NULL                |
|    6 | Komal    |   NULL | NULL                |
|    7 | Muffy    |   NULL | NULL                |
+------+----------+--------+---------------------+

BİRLİK TÜM Hükmü

UNION ALL operatörü, yinelenen satırlar dahil olmak üzere iki SELECT ifadesinin sonuçlarını birleştirmek için kullanılır.

UNION yan tümcesi için geçerli olan aynı kurallar UNION ALL operatörü için de geçerli olacaktır.

Sözdizimi

Temel sözdizimi UNION ALL Şöyleki.

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION ALL

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Burada verilen koşul, gereksiniminize göre verilen herhangi bir ifade olabilir.

Misal

Aşağıdaki iki tabloyu düşünün,

Table 1 - MÜŞTERİLER Tablosu aşağıdaki gibidir.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - SİPARİŞLER tablosu aşağıdaki gibidir.

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Şimdi bu iki tabloyu SELECT deyimimizde aşağıdaki gibi birleştirelim -

SQL> SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   LEFT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION ALL
   SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   RIGHT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Bu, aşağıdaki sonucu verecektir -

+------+----------+--------+---------------------+
| ID   | NAME     | AMOUNT | DATE                |
+------+----------+--------+---------------------+
|    1 | Ramesh   |   NULL | NULL                |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
|    5 | Hardik   |   NULL | NULL                |
|    6 | Komal    |   NULL | NULL                |
|    7 | Muffy    |   NULL | NULL                |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+

UNION cümlesine benzeyen diğer iki cümle (yani operatörler) vardır.

SQL INTERSECT İfadesi - Bu, iki SELECT deyimini birleştirmek için kullanılır, ancak yalnızca ikinci SELECT deyimindeki bir satırla aynı olan ilk SELECT deyiminden satırları döndürür.
SQL EXCEPT Clause - Bu, iki SELECT deyimini birleştirir ve ilk SELECT deyiminden ikinci SELECT deyimi tarafından döndürülmeyen satırları döndürür.

SQL - NULL Değerler

SQL NULLeksik bir değeri temsil etmek için kullanılan terimdir. Bir tablodaki NULL değeri, boş görünen bir alandaki değerdir.

NULL değeri olan bir alan, değeri olmayan bir alandır. Bir NULL değerinin sıfır değerinden veya boşluklar içeren bir alandan farklı olduğunu anlamak çok önemlidir.

Sözdizimi

Temel sözdizimi NULL tablo oluştururken.

SQL> CREATE TABLE CUSTOMERS(
   ID   INT              NOT NULL,
   NAME VARCHAR (20)     NOT NULL,
   AGE  INT              NOT NULL,
   ADDRESS  CHAR (25) ,
   SALARY   DECIMAL (18, 2),       
   PRIMARY KEY (ID)
);

Buraya, NOT NULLsütunun her zaman verilen veri türünün açık bir değerini kabul etmesi gerektiğini belirtir. NOT NULL kullanmadığımız iki sütun vardır, bu da bu sütunların NULL olabileceği anlamına gelir.

NULL değerine sahip bir alan, kayıt oluşturma sırasında boş bırakılan alandır.

Misal

NULL değeri, veri seçerken sorunlara neden olabilir. Ancak bilinmeyen bir değeri başka herhangi bir değerle karşılaştırırken, sonuç her zaman bilinmez ve sonuçlara dahil edilmez. KullanmalısınızIS NULL veya IS NOT NULL operatörlerin NULL değeri kontrol etmeleri gerekir.

Aşağıda gösterilen kayıtlara sahip aşağıdaki MÜŞTERİLER tablosunu göz önünde bulundurun.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |          |
|  7 | Muffy    |  24 | Indore    |          |
+----+----------+-----+-----------+----------+

Şimdi, aşağıdaki kullanım IS NOT NULLŞebeke.

SQL> SELECT  ID, NAME, AGE, ADDRESS, SALARY
   FROM CUSTOMERS
   WHERE SALARY IS NOT NULL;

Bu, aşağıdaki sonucu verecektir -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
+----+----------+-----+-----------+----------+

Şimdi, aşağıdaki kullanım IS NULL Şebeke.

SQL> SELECT  ID, NAME, AGE, ADDRESS, SALARY
   FROM CUSTOMERS
   WHERE SALARY IS NULL;

Bu, aşağıdaki sonucu verecektir -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  6 | Komal    |  22 | MP        |          |
|  7 | Muffy    |  24 | Indore    |          |
+----+----------+-----+-----------+----------+

SQL - Alias Sözdizimi

Bir tabloyu veya sütunu geçici olarak yeniden adlandırabilirsiniz. Alias. Tablo takma adlarının kullanımı, belirli bir SQL deyimindeki bir tabloyu yeniden adlandırmaktır. Yeniden adlandırma geçici bir değişikliktir ve gerçek tablo adı veritabanında değişmez. Sütun takma adları, belirli bir SQL sorgusu amacıyla bir tablonun sütunlarını yeniden adlandırmak için kullanılır.

Sözdizimi

A'nın temel sözdizimi table takma ad aşağıdaki gibidir.

SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];

A'nın temel sözdizimi column takma ad aşağıdaki gibidir.

SELECT column_name AS alias_name
FROM table_name
WHERE [condition];

Misal

Aşağıdaki iki tabloyu düşünün.

Table 1 - MÜŞTERİLER Tablosu aşağıdaki gibidir.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - SİPARİŞLER Tablosu aşağıdaki gibidir.

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Şimdi, aşağıdaki kod bloğu, bir table alias.

SQL> SELECT C.ID, C.NAME, C.AGE, O.AMOUNT 
   FROM CUSTOMERS AS C, ORDERS AS O
   WHERE  C.ID = O.CUSTOMER_ID;

Bu, aşağıdaki sonucu verecektir.

+----+----------+-----+--------+
| ID | NAME     | AGE | AMOUNT |
+----+----------+-----+--------+
|  3 | kaushik  |  23 |   3000 |
|  3 | kaushik  |  23 |   1500 |
|  2 | Khilan   |  25 |   1560 |
|  4 | Chaitali |  25 |   2060 |
+----+----------+-----+--------+

Aşağıdakiler bir column alias.

SQL> SELECT  ID AS CUSTOMER_ID, NAME AS CUSTOMER_NAME
   FROM CUSTOMERS
   WHERE SALARY IS NOT NULL;

Bu, aşağıdaki sonucu verecektir.

+-------------+---------------+
| CUSTOMER_ID | CUSTOMER_NAME |
+-------------+---------------+
|           1 | Ramesh        |
|           2 | Khilan        |
|           3 | kaushik       |
|           4 | Chaitali      |
|           5 | Hardik        |
|           6 | Komal         |
|           7 | Muffy         |
+-------------+---------------+

SQL - Dizinler

Dizinler special lookup tablesveritabanı arama motorunun veri alımını hızlandırmak için kullanabileceği. Basitçe ifade etmek gerekirse, indeks bir tablodaki verilere bir göstericidir. Veritabanındaki bir dizin, bir kitabın arkasındaki dizine çok benzer.

Örneğin, bir kitabın belirli bir konuyu tartışan tüm sayfalarına başvurmak istiyorsanız, önce tüm konuları alfabetik olarak listeleyen ve ardından bir veya daha fazla belirli sayfa numarasına atıfta bulunan dizine başvurursunuz.

Bir dizin hızlanmaya yardımcı olur SELECT sorgular ve WHERE cümlecikleri, ancak veri girişini yavaşlatır, UPDATE ve INSERTifadeler. Veriler üzerinde herhangi bir etki olmaksızın dizinler oluşturulabilir veya çıkarılabilir.

Bir dizin oluşturmak şunları içerir: CREATE INDEX dizini adlandırmanıza, tabloyu ve hangi sütun veya sütunların dizine ekleneceğini belirtmenize ve dizinin artan veya azalan sırada olup olmadığını belirtmenize olanak tanıyan deyim.

Dizinler de benzersiz olabilir, örneğin UNIQUE kısıtlama, indeksin bir indeksin olduğu sütunda veya sütun kombinasyonunda yinelenen girişleri engellemesidir.

CREATE INDEX Komutu

A'nın temel sözdizimi CREATE INDEX Şöyleki.

CREATE INDEX index_name ON table_name;

Tek Sütunlu Dizinler

Yalnızca bir tablo sütununa dayalı olarak tek sütunlu bir dizin oluşturulur. Temel sözdizimi aşağıdaki gibidir.

CREATE INDEX index_name
ON table_name (column_name);

Benzersiz Dizinler

Benzersiz dizinler yalnızca performans için değil, aynı zamanda veri bütünlüğü için de kullanılır. Benzersiz bir dizin, tabloya yinelenen değerlerin eklenmesine izin vermez. Temel sözdizimi aşağıdaki gibidir.

CREATE UNIQUE INDEX index_name
on table_name (column_name);

Bileşik Dizinler

Bileşik dizin, bir tablonun iki veya daha fazla sütunundaki dizindir. Temel sözdizimi aşağıdaki gibidir.

CREATE INDEX index_name
on table_name (column1, column2);

İster tek sütunlu dizin ister bileşik dizin oluşturun, bir sorgunun WHERE yan tümcesinde filtre koşulları olarak çok sık kullanabileceğiniz sütunları dikkate alın.

Yalnızca bir sütun kullanılması durumunda, tek sütunlu bir dizin tercih edilmelidir. WHERE yan tümcesinde filtre olarak sıklıkla kullanılan iki veya daha fazla sütun olması durumunda, bileşik dizin en iyi seçim olacaktır.

Örtük Dizinler

Örtük dizinler, bir nesne oluşturulduğunda veritabanı sunucusu tarafından otomatik olarak oluşturulan dizinlerdir. Dizinler, birincil anahtar kısıtlamaları ve benzersiz kısıtlamalar için otomatik olarak oluşturulur.

DROP INDEX Komutu

SQL kullanılarak bir dizin bırakılabilir DROPkomut. Bir dizini düşürürken dikkatli olunmalıdır çünkü performans yavaşlayabilir veya gelişebilir.

Temel sözdizimi aşağıdaki gibidir -

DROP INDEX index_name;

Dizinlerle ilgili bazı gerçek örnekleri görmek için INDEX Kısıtlama bölümünü kontrol edebilirsiniz .

İndekslerden ne zaman kaçınılmalıdır?

Dizinler bir veritabanının performansını artırmayı amaçlasa da, kaçınılması gereken zamanlar vardır.

Aşağıdaki yönergeler, bir dizinin kullanımının ne zaman yeniden değerlendirilmesi gerektiğini belirtir.

Küçük tablolarda indeksler kullanılmamalıdır.
Sık, büyük toplu güncellemeleri veya ekleme işlemleri olan tablolar.
Yüksek sayıda NULL değer içeren sütunlarda dizinler kullanılmamalıdır.
Sıklıkla işlenen sütunlar dizine eklenmemelidir.

SQL - ALTER TABLE Komutu

SQL ALTER TABLEkomutu, mevcut bir tablodaki sütunları eklemek, silmek veya değiştirmek için kullanılır. Mevcut bir tabloya çeşitli kısıtlamalar eklemek ve bunları bırakmak için ALTER TABLE komutunu da kullanmalısınız.

Sözdizimi

ALTER TABLE komutunun temel sözdizimi New Column mevcut bir tabloda aşağıdaki gibidir.

ALTER TABLE table_name ADD column_name datatype;

ALTER TABLE komutunun temel sözdizimi DROP COLUMN mevcut bir tabloda aşağıdaki gibidir.

ALTER TABLE table_name DROP COLUMN column_name;

Bir ALTER TABLE komutunun temel sözdizimi DATA TYPE Bir tablodaki bir sütunun sayısı aşağıdaki gibidir.

ALTER TABLE table_name MODIFY COLUMN column_name datatype;

ALTER TABLE komutunun temel sözdizimi NOT NULL bir tablodaki bir sütuna kısıtlama aşağıdaki gibidir.

ALTER TABLE table_name MODIFY column_name datatype NOT NULL;

ALTER TABLE'ın temel sözdizimi ADD UNIQUE CONSTRAINT bir tabloya aşağıdaki gibidir.

ALTER TABLE table_name 
ADD CONSTRAINT MyUniqueConstraint UNIQUE(column1, column2...);

ALTER TABLE komutunun temel sözdizimi ADD CHECK CONSTRAINT bir tabloya aşağıdaki gibidir.

ALTER TABLE table_name 
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);

ALTER TABLE komutunun temel sözdizimi ADD PRIMARY KEY bir tabloya kısıtlama aşağıdaki gibidir.

ALTER TABLE table_name 
ADD CONSTRAINT MyPrimaryKey PRIMARY KEY (column1, column2...);

ALTER TABLE komutunun temel sözdizimi DROP CONSTRAINT bir tablodan aşağıdaki gibidir.

ALTER TABLE table_name 
DROP CONSTRAINT MyUniqueConstraint;

MySQL kullanıyorsanız, kod aşağıdaki gibidir -

ALTER TABLE table_name 
DROP INDEX MyUniqueConstraint;

ALTER TABLE komutunun temel sözdizimi DROP PRIMARY KEY bir tablodan kısıtlama aşağıdaki gibidir.

ALTER TABLE table_name 
DROP CONSTRAINT MyPrimaryKey;

MySQL kullanıyorsanız, kod aşağıdaki gibidir -

ALTER TABLE table_name 
DROP PRIMARY KEY;

Misal

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıda bir EKLEME örneği verilmiştir. New Column mevcut bir tabloya -

ALTER TABLE CUSTOMERS ADD SEX char(1);

Şimdi, CUSTOMERS tablosu değiştirildi ve aşağıdaki SELECT ifadesinden çıktı alınacaktır.

+----+---------+-----+-----------+----------+------+
| ID | NAME    | AGE | ADDRESS   | SALARY   | SEX  |
+----+---------+-----+-----------+----------+------+
|  1 | Ramesh  |  32 | Ahmedabad |  2000.00 | NULL |
|  2 | Ramesh  |  25 | Delhi     |  1500.00 | NULL |
|  3 | kaushik |  23 | Kota      |  2000.00 | NULL |
|  4 | kaushik |  25 | Mumbai    |  6500.00 | NULL |
|  5 | Hardik  |  27 | Bhopal    |  8500.00 | NULL |
|  6 | Komal   |  22 | MP        |  4500.00 | NULL |
|  7 | Muffy   |  24 | Indore    | 10000.00 | NULL |
+----+---------+-----+-----------+----------+------+

Aşağıda, mevcut tablodan DROP cinsiyet sütununa örnek verilmiştir.

ALTER TABLE CUSTOMERS DROP SEX;

Şimdi, CUSTOMERS tablosu değiştirildi ve aşağıdaki SELECT ifadesinden çıktı olacaktır.

+----+---------+-----+-----------+----------+
| ID | NAME    | AGE | ADDRESS   | SALARY   |
+----+---------+-----+-----------+----------+
|  1 | Ramesh  |  32 | Ahmedabad |  2000.00 |
|  2 | Ramesh  |  25 | Delhi     |  1500.00 |
|  3 | kaushik |  23 | Kota      |  2000.00 |
|  4 | kaushik |  25 | Mumbai    |  6500.00 |
|  5 | Hardik  |  27 | Bhopal    |  8500.00 |
|  6 | Komal   |  22 | MP        |  4500.00 |
|  7 | Muffy   |  24 | Indore    | 10000.00 |
+----+---------+-----+-----------+----------+

SQL - TRUNCATE TABLE Komutu

SQL TRUNCATE TABLE komutu, mevcut bir tablodan tüm verileri silmek için kullanılır.

Tablonun tamamını silmek için DROP TABLE komutunu da kullanabilirsiniz, ancak bu, tüm tablo yapısını veritabanından kaldırır ve bazı verileri depolamak isterseniz bu tabloyu bir kez daha yeniden oluşturmanız gerekir.

Sözdizimi

A'nın temel sözdizimi TRUNCATE TABLE komut aşağıdaki gibidir.

TRUNCATE TABLE  table_name;

Misal

Aşağıdaki kayıtlara sahip bir MÜŞTERİLER tablosu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıda, Kes komutu örneği verilmiştir.

SQL > TRUNCATE TABLE CUSTOMERS;

Şimdi, CUSTOMERS tablosu kesildi ve SELECT ifadesinden çıkan çıktı aşağıdaki kod bloğunda gösterildiği gibi olacak -

SQL> SELECT * FROM CUSTOMERS;
Empty set (0.00 sec)

SQL - Görünümleri Kullanma

Görünüm, veritabanında ilişkili bir adla depolanan bir SQL ifadesinden başka bir şey değildir. Görünüm, aslında önceden tanımlanmış bir SQL sorgusu biçimindeki bir tablonun bileşimidir.

Görünüm, bir tablonun tüm satırlarını içerebilir veya bir tablodan satırları seçebilir. Bir görünüm oluşturmak için yazılı SQL sorgusuna bağlı olan bir veya daha fazla tablodan bir görünüm oluşturulabilir.

Bir tür sanal tablo olan görünümler, kullanıcıların aşağıdakileri yapmasına izin verir -

Verileri, kullanıcıların veya kullanıcı sınıflarının doğal veya sezgisel bulacağı şekilde yapılandırın.
Verilere erişimi, bir kullanıcının tam olarak ihtiyaç duyduklarını görebileceği ve (bazen) değiştirebileceği ve daha fazlasını olmayacak şekilde kısıtlayın.
Rapor oluşturmak için kullanılabilecek çeşitli tablolardaki verileri özetleyin.

Görünümler Oluşturma

Veritabanı görünümleri, CREATE VIEWBeyan. Görünümler tek bir tablodan, birden çok tablodan veya başka bir görünümden oluşturulabilir.

Bir görünüm oluşturmak için, kullanıcının belirli uygulamaya göre uygun sistem ayrıcalığına sahip olması gerekir.

Basit CREATE VIEW sözdizimi aşağıdaki gibidir -

CREATE VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];

Normal bir SQL SELECT sorgusunda kullandığınız gibi, SELECT deyiminize birden çok tabloyu dahil edebilirsiniz.

Misal

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıda, MÜŞTERİLER tablosundan bir görünüm oluşturmak için bir örnek verilmiştir. Bu görünüm, MÜŞTERİLER tablosundan müşteri adını ve yaşını almak için kullanılır.

SQL > CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM  CUSTOMERS;

Artık, gerçek bir tabloyu sorgularken CUSTOMERS_VIEW'ı benzer şekilde sorgulayabilirsiniz. Aşağıdakiler bunun bir örneğidir.

SQL > SELECT * FROM CUSTOMERS_VIEW;

Bu, aşağıdaki sonucu verecektir.

+----------+-----+
| name     | age |
+----------+-----+
| Ramesh   |  32 |
| Khilan   |  25 |
| kaushik  |  23 |
| Chaitali |  25 |
| Hardik   |  27 |
| Komal    |  22 |
| Muffy    |  24 |
+----------+-----+

İLE KONTROL SEÇENEĞİ

WITH CHECK OPTION bir CREATE VIEW deyim seçeneğidir. İLE KONTROL SEÇENEĞİNİN amacı, tüm GÜNCELLEME ve INSERT'lerin görünüm tanımındaki koşul (lar) ı karşılamasını sağlamaktır.

Koşul (lar) ı karşılamazlarsa, UPDATE veya INSERT bir hata verir.

Aşağıdaki kod bloğu, WITH CHECK OPTION ile aynı CUSTOMERS_VIEW görünümü oluşturmanın bir örneğine sahiptir.

CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM  CUSTOMERS
WHERE age IS NOT NULL
WITH CHECK OPTION;

Bu durumda WITH CHECK OPTION, görünümün AGE sütunundaki herhangi bir NULL değerin girişini reddetmelidir, çünkü görünüm, AGE sütununda NULL değeri olmayan veriler tarafından tanımlanır.

Bir Görünümü Güncelleme

Bir görünüm, aşağıda verilen belirli koşullar altında güncellenebilir -

SELECT yan tümcesi DISTINCT anahtar sözcüğünü içermeyebilir.
SELECT yan tümcesi özet işlevleri içermeyebilir.
SELECT yan tümcesi set işlevlerini içermeyebilir.
SELECT yan tümcesi set operatörleri içeremez.
SELECT yan tümcesi ORDER BY yan tümcesi içermeyebilir.
FROM yan tümcesi birden çok tablo içeremez.
WHERE yan tümcesi alt sorgular içeremez.
Sorgu GROUP BY veya HAVING içeremez.
Hesaplanan sütunlar güncellenemez.
INSERT sorgusunun çalışması için temel tablodaki tüm NOT NULL sütunları görünüme dahil edilmelidir.

Dolayısıyla, bir görünüm yukarıda belirtilen tüm kuralları karşılıyorsa, o görünümü güncelleyebilirsiniz. Aşağıdaki kod bloğunun Ramesh'in yaşını güncellemek için bir örneği vardır.

SQL > UPDATE CUSTOMERS_VIEW
   SET AGE = 35
   WHERE name = 'Ramesh';

Bu, nihayetinde temel tablo MÜŞTERİLER'i güncelleyecektir ve aynısı görünümün kendisine de yansıyacaktır. Şimdi, temel tabloyu sorgulamayı deneyin, SELECT deyimi aşağıdaki sonucu verecektir.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Görünüme Satır Ekleme

Bir görünüme veri satırları eklenebilir. UPDATE komutu için geçerli olan aynı kurallar INSERT komutu için de geçerlidir.

Burada, CUSTOMERS_VIEW'a satır ekleyemiyoruz çünkü bu görünüme tüm NOT NULL sütunlarını dahil etmedik, aksi takdirde bir görünümdeki satırları bir tabloya eklediğiniz gibi benzer bir şekilde ekleyebilirsiniz.

Satırları Görünümde Silme

Bir görünümden veri satırları silinebilir. UPDATE ve INSERT komutları için geçerli olan kurallar DELETE komutu için de geçerlidir.

Aşağıda AGE = 22 olan bir kaydı silmek için bir örnek verilmiştir.

SQL > DELETE FROM CUSTOMERS_VIEW
   WHERE age = 22;

Bu sonuçta CUSTOMERS temel tablodan bir satırı siler ve aynısı görünümün kendisine de yansır. Şimdi, temel tabloyu sorgulamayı deneyin, SELECT deyimi aşağıdaki sonucu verecektir.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Görünümleri Bırakma

Açıktır ki, bir görünüme sahip olduğunuzda, artık gerekmiyorsa görünümü düşürmenin bir yolunu bulmanız gerekir. Sözdizimi çok basittir ve aşağıda verilmiştir -

DROP VIEW view_name;

Aşağıda, CUSTOMERS_VIEW’i MÜŞTERİLER tablosundan çıkarmak için bir örnek verilmiştir.

DROP VIEW CUSTOMERS_VIEW;

SQL - Madde Sahibi

HAVING Clause sonuçlarda hangi grup sonuçlarının görüneceğini filtreleyen koşulları belirlemenizi sağlar.

WHERE yan tümcesi koşulları seçili sütunlara yerleştirirken HAVING yan tümcesi, koşulları GROUP BY yan tümcesi tarafından oluşturulan gruplara yerleştirir.

Sözdizimi

Aşağıdaki kod bloğu HAVING Cümlesinin bir sorgudaki konumunu gösterir.

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

HAVING yan tümcesi, bir sorgudaki GROUP BY yan tümcesini takip etmeli ve kullanılıyorsa ORDER BY yan tümcesinden önce gelmelidir. Aşağıdaki kod bloğu HAVING yan tümcesi de dahil olmak üzere SELECT ifadesinin sözdizimine sahiptir -

SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2

Misal

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıda, 2'ye eşit veya daha fazla olacak benzer bir yaş sayımı için bir kayıt gösteren bir örnek verilmiştir.

SQL > SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM CUSTOMERS
GROUP BY age
HAVING COUNT(age) >= 2;

Bu, aşağıdaki sonucu verecektir -

+----+--------+-----+---------+---------+
| ID | NAME   | AGE | ADDRESS | SALARY  |
+----+--------+-----+---------+---------+
|  2 | Khilan |  25 | Delhi   | 1500.00 |
+----+--------+-----+---------+---------+

SQL - İşlemler

İşlem, bir veri tabanına karşı gerçekleştirilen bir iş birimidir. İşlemler, bir kullanıcı tarafından manuel olarak veya bir tür veritabanı programı tarafından otomatik olarak mantıksal bir sırayla gerçekleştirilen birimler veya iş dizileridir.

İşlem, bir veya daha fazla değişikliğin veritabanına yayılmasıdır. Örneğin, bir kayıt oluşturuyorsanız veya bir kaydı güncelliyorsanız veya tablodan bir kaydı siliyorsanız, o tablo üzerinde bir işlem gerçekleştiriyorsunuzdur. Veri bütünlüğünü sağlamak ve veritabanı hatalarını işlemek için bu işlemleri kontrol etmek önemlidir.

Pratik olarak, birçok SQL sorgusunu bir grupta toplayacaksınız ve hepsini bir işlemin parçası olarak birlikte yürüteceksiniz.

İşlemlerin Özellikleri

İşlemler, genellikle kısaltmayla anılan aşağıdaki dört standart özelliğe sahiptir. ACID.

Atomicity- İş birimindeki tüm işlemlerin başarıyla tamamlanmasını sağlar. Aksi takdirde, işlem başarısızlık noktasında iptal edilir ve önceki tüm işlemler önceki durumuna geri döndürülür.
Consistency - başarıyla tamamlanmış bir işlemden sonra veritabanının durumları doğru şekilde değiştirmesini sağlar.
Isolation - İşlemlerin birbirinden bağımsız ve şeffaf bir şekilde işlemesini sağlar.
Durability - Bir sistem arızası durumunda taahhüt edilen bir işlemin sonucunun veya etkisinin devam etmesini sağlar.

İşlem Kontrolü

İşlemleri kontrol etmek için aşağıdaki komutlar kullanılır.

COMMIT - değişiklikleri kaydetmek için.
ROLLBACK - değişiklikleri geri almak için.
SAVEPOINT - ROLLBACK'in yapılacağı işlem grupları içinde noktalar oluşturur.
SET TRANSACTION - Bir işleme bir ad verir.

İşlem Kontrol Komutları

İşlem kontrol komutları yalnızca DML Commandsörneğin - INSERT, UPDATE ve DELETE gibi. Tablolar oluşturulurken veya bırakılırken kullanılamazlar çünkü bu işlemler veritabanında otomatik olarak yapılır.

COMMIT Komutu

COMMIT komutu, bir işlem tarafından çağrılan değişiklikleri veritabanına kaydetmek için kullanılan işlem komutudur.

COMMIT komutu, bir işlem tarafından çağrılan değişiklikleri veritabanına kaydetmek için kullanılan işlem komutudur. COMMIT komutu, son COMMIT veya ROLLBACK komutundan itibaren tüm işlemleri veritabanına kaydeder.

COMMIT komutunun sözdizimi aşağıdaki gibidir.

COMMIT;

Example

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıda yaş = 25 olan bu kayıtları tablodan silen ve sonra veritabanındaki değişiklikleri TAMAMLAYACAK bir örnek verilmiştir.

SQL> DELETE FROM CUSTOMERS
   WHERE AGE = 25;
SQL> COMMIT;

Bu nedenle, tablodan iki satır silinecek ve SELECT ifadesi aşağıdaki sonucu verecektir.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

ROLLBACK Komutu

ROLLBACK komutu, veritabanına önceden kaydedilmemiş işlemleri geri almak için kullanılan işlem komutudur. Bu komut yalnızca son COMMIT veya ROLLBACK komutunun verildiği tarihten itibaren işlemleri geri almak için kullanılabilir.

Bir ROLLBACK komutunun sözdizimi aşağıdaki gibidir -

ROLLBACK;

Example

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıda, yaş = 25 olan bu kayıtları tablodan silen ve ardından veritabanındaki değişiklikleri ROLLBACK silen bir örnek verilmiştir.

SQL> DELETE FROM CUSTOMERS
   WHERE AGE = 25;
SQL> ROLLBACK;

Bu nedenle, silme işlemi tabloyu etkilemez ve SELECT deyimi aşağıdaki sonucu verir.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

SAVEPOINT Komutu

Bir SAVEPOINT, işlemin tamamını geri almadan işlemi belirli bir noktaya geri alabileceğiniz bir işlemdir.

SAVEPOINT komutunun sözdizimi aşağıda gösterildiği gibidir.

SAVEPOINT SAVEPOINT_NAME;

Bu komut, yalnızca tüm işlem ifadeleri arasında bir SAVEPOINT oluşturulmasına hizmet eder. ROLLBACK komutu, bir grup işlemi geri almak için kullanılır.

SAVEPOINT'e geri dönmenin sözdizimi aşağıda gösterildiği gibidir.

ROLLBACK TO SAVEPOINT_NAME;

Aşağıda, MÜŞTERİLER tablosundan üç farklı kaydı silmeyi planladığınız bir örnek verilmiştir. Her silme işleminden önce bir SAVEPOINT oluşturmak istersiniz, böylece uygun verileri orijinal durumuna geri döndürmek için herhangi bir zamanda herhangi bir SAVEPOINT'e GERİ DÖNME yapabilirsiniz.

Example

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıdaki kod bloğu, işlem serilerini içerir.

SQL> SAVEPOINT SP1;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=1;
1 row deleted.
SQL> SAVEPOINT SP2;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=2;
1 row deleted.
SQL> SAVEPOINT SP3;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=3;
1 row deleted.

Şimdi üç silme işlemi gerçekleştiğine göre, fikrinizi değiştirdiğinizi ve SP2 olarak tanımladığınız SAVEPOINT'e GERİ DÖNÜŞTÜRmeye karar verdiğinizi varsayalım. SP2 ilk silme işleminden sonra oluşturulduğundan, son iki silme işlemi geri alınır -

SQL> ROLLBACK TO SP2;
Rollback complete.

SP2'ye geri döndüğünüzden beri yalnızca ilk silme işleminin gerçekleştiğine dikkat edin.

SQL> SELECT * FROM CUSTOMERS;
+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+
6 rows selected.

RELEASE SAVEPOINT Komutu

RELEASE SAVEPOINT komutu, oluşturduğunuz bir SAVEPOINT'i kaldırmak için kullanılır.

RELEASE SAVEPOINT komutunun sözdizimi aşağıdaki gibidir.

RELEASE SAVEPOINT SAVEPOINT_NAME;

Bir SAVEPOINT serbest bırakıldıktan sonra, son SAVEPOINT'ten bu yana gerçekleştirilen işlemleri geri almak için artık ROLLBACK komutunu kullanamazsınız.

SET TRANSACTION Komutu

SET TRANSACTION komutu, bir veritabanı işlemini başlatmak için kullanılabilir. Bu komut, takip eden işlemin özelliklerini belirlemek için kullanılır. Örneğin, salt okunur veya okunabilir bir işlem belirtebilirsiniz.

SET TRANSACTION komutunun sözdizimi aşağıdaki gibidir.

SET TRANSACTION [ READ WRITE | READ ONLY ];

SQL - Joker Karakter Operatörleri

Joker karakter operatörlerini kullanarak bir değeri benzer değerlerle karşılaştırmak için kullanılan SQL LIKE operatörü hakkında daha önce tartışmıştık.

SQL, aşağıdaki tabloda ayrıntılı olarak açıklanan LIKE operatörü ile birlikte iki joker karakter operatörünü destekler.

Sr.No.	Joker Karakter ve Açıklama
1	The percent sign (%) Bir veya daha fazla karakterle eşleşir. Note - MS Access, yüzde işareti (%) joker karakteri yerine yıldız (*) joker karakterini kullanır.
2	The underscore (_) Bir karakterle eşleşir. Note - MS Access, herhangi bir karakteri eşleştirmek için alt çizgi (_) yerine soru işareti (?) Kullanır.

Yüzde işareti sıfır, bir veya birden çok karakteri temsil eder. Alt çizgi, tek bir sayıyı veya bir karakteri temsil eder. Bu semboller kombinasyonlarda kullanılabilir.

Sözdizimi

Bir '%' ve bir '_' operatörünün temel sözdizimi aşağıdaki gibidir.

SELECT * FROM table_name
WHERE column LIKE 'XXXX%'

or 

SELECT * FROM table_name
WHERE column LIKE '%XXXX%'

or

SELECT * FROM table_name
WHERE column LIKE 'XXXX_'

or

SELECT * FROM table_name
WHERE column LIKE '_XXXX'

or

SELECT * FROM table_name
WHERE column LIKE '_XXXX_'

AND veya OR operatörlerini kullanarak N sayıda koşulu birleştirebilirsiniz. Burada XXXX, herhangi bir sayısal değer veya dize değeri olabilir.

Misal

Aşağıdaki tabloda, '%' ve '_' operatörleriyle farklı LIKE yan tümcelerine sahip WHERE bölümünü gösteren birkaç örnek vardır.

Sr.No.	Açıklama ve Açıklama
1	WHERE SALARY LIKE '200%' 200 ile başlayan tüm değerleri bulur.
2	WHERE SALARY LIKE '%200%' Herhangi bir konumda 200 olan tüm değerleri bulur.
3	WHERE SALARY LIKE '_00%' İkinci ve üçüncü konumlarda 00 olan tüm değerleri bulur.
4	WHERE SALARY LIKE '2_%_%' 2 ile başlayan ve en az 3 karakter uzunluğunda olan tüm değerleri bulur.
5	WHERE SALARY LIKE '%2' 2 ile biten tüm değerleri bulur.
6	WHERE SALARY LIKE '_2%3' İkinci konumda 2 olan ve 3 ile biten değerleri bulur.
7	WHERE SALARY LIKE '2___3' 2 ile başlayan ve 3 ile biten beş basamaklı bir sayıdaki tüm değerleri bulur.

Gerçek bir örnek alalım, aşağıdaki kayıtların bulunduğu MÜŞTERİLER tablosunu ele alalım.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Aşağıdaki kod bloğu, MAAŞ'ın 200 ile başladığı MÜŞTERİLER tablosundaki tüm kayıtları görüntüleyen bir örnektir.

SQL> SELECT * FROM CUSTOMERS
WHERE SALARY LIKE '200%';

Bu, aşağıdaki sonucu verecektir.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
+----+----------+-----+-----------+----------+

SQL - Tarih İşlevleri

Aşağıdaki tabloda, SQL aracılığıyla kullanılabilen Tarih ve Saat ile ilgili tüm önemli işlevlerin bir listesi bulunmaktadır. RDBMS'niz tarafından desteklenen çeşitli başka işlevler vardır. Verilen liste MySQL RDBMS'ye dayanmaktadır.

Sr.No.	İşlev ve Açıklama
1	TARİH EKLE() Tarihleri ekler
2	ZAMAN EKLE() Zaman ekler
3	CONVERT_TZ () Bir saat diliminden diğerine dönüştürür
4	CURDATE () Geçerli tarihi verir
5	CURRENT_DATE (), CURRENT_DATE CURDATE için benzer kelimeler ()
6	CURRENT_TIME (), CURRENT_TIME CURTIME için benzer kelimeler ()
7	CURRENT_TIMESTAMP (), CURRENT_TIMESTAMP ŞİMDİ için eşanlamlılar ()
8	CURTIME () Geçerli saati verir
9	DATE_ADD () İki tarih ekler
10	TARİH FORMATI() Biçim tarihi belirtildiği gibi
11	DATE_SUB () İki tarih çıkarır
12	TARİH () Tarih veya tarih saat ifadesinin tarih bölümünü ayıklar
13	DATEDIFF () İki tarih çıkarır
14	GÜN() DAYOFMONTH ile eşanlamlı ()
15	GÜN ADI () Hafta içi gününün adını verir
16	AYIN GÜNÜ() Ayın gününü verir (1-31)
17	HAFTANIN GÜNÜ() Bağımsız değişkenin hafta içi dizinini verir
18	GÜNDÜZ () Yılın gününü verir (1-366)
19	AYIKLA Bir tarihin bir kısmını çıkarır
20	GÜN_DEN () Bir gün numarasını tarihe dönüştürür
21	FROM_UNIXTIME () Tarihi UNIX zaman damgası olarak biçimlendirir
22	SAAT() Saati çıkarır
23	SON GUN Bağımsız değişken için ayın son gününü verir
24	LOCALTIME (), LOCALTIME ŞİMDİ ile eşanlamlı ()
25	LOCALTIMESTAMP, LOCALTIMESTAMP () ŞİMDİ ile eşanlamlı ()
26	YAPILAN () Yıldan ve yılın gününden bir tarih oluşturur
27	ZAMAN YARATMAK ZAMAN YARATMAK()
28	MICROSECOND () Bağımsız değişkendeki mikrosaniyeleri döndürür
29	DAKİKA() Bağımsız değişkenden dakikayı verir
30	AY() Geçen tarihten ayı döndür
31	MONTHNAME () Ayın adını verir
32	ŞİMDİ () Geçerli tarih ve saati verir
33	PERIOD_ADD () Yıl-aya dönem ekler
34	PERIOD_DIFF () Dönemler arasındaki ayların sayısını verir
35	ÇEYREK () Bir tarih bağımsız değişkeninden çeyreği verir
36	SEC_TO_TIME () Saniyeleri 'HH: MM: SS' biçimine dönüştürür
37	İKİNCİ() Saniyeyi verir (0-59)
38	STR_TO_DATE () Bir dizeyi tarihe dönüştürür
39	SUBDATE () Üç bağımsız değişkenle çağrıldığında DATE_SUB () ile eşanlamlıdır
40	SUBTIME () Çıkarma süreleri
41	SYSDATE () Fonksiyonun çalıştırıldığı zamanı verir
42	ZAMAN FORMATI() Zaman olarak biçimler
43	TIME_TO_SEC () Saniyeye dönüştürülen bağımsız değişkeni verir
44	ZAMAN() İfadenin geçen zaman bölümünü ayıklar
45	TIMEDIFF () Zaman çıkarır
46	TIMESTAMP () Tek bir bağımsız değişkenle bu işlev, tarih veya tarih saat ifadesini döndürür. İki argümanla, argümanların toplamı
47	TIMESTAMPADD () Bir datetime ifadesine bir aralık ekler
48	TIMESTAMPDIFF () Bir tarih saat ifadesinden bir aralığı çıkarır
49	TO_DAYS () Günlere dönüştürülen tarih bağımsız değişkenini verir
50	UNIX_TIMESTAMP () Bir UNIX zaman damgası verir
51	UTC_DATE () Geçerli UTC tarihini verir
52	UTC_TIME () Geçerli UTC saatini verir
53	UTC_TIMESTAMP () Geçerli UTC tarihini ve saatini verir
54	HAFTA() Hafta numarasını verir
55	HAFTA İÇİ() Hafta içi dizini verir
56	WEEKOFYEAR () Tarihin (1-53) takvim haftasını verir
57	YIL() Yılı verir
58	YEARWEEK () Yılı ve haftayı verir

ADDDATE (tarih, INTERVAL ifade birimi), ADDDATE (ifade, günler)

İkinci bağımsız değişkenin INTERVAL biçimiyle çağrıldığında, ADDDATE () DATE_ADD () ile eşanlamlıdır. İlgili işlev SUBDATE (), DATE_SUB () ile eşanlamlıdır. INTERVAL birim bağımsız değişkeni hakkında bilgi için, DATE_ADD () için tartışmaya bakın.

mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| ADDDATE('1998-01-02', INTERVAL 31 DAY)                  |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

İkinci bağımsız değişkenin gün biçimi ile çağrıldığında, MySQL bunu ifadeye eklenecek tam sayı gün sayısı olarak ele alır.

mysql> SELECT ADDDATE('1998-01-02', 31);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

ADDTIME (ifade1; ifade2)

ADDTIME () ifade2'yi ifade1'e ekler ve sonucu döndürür. İfade1 bir zaman veya tarih saat ifadesidir, ifade2 ise bir zaman ifadesidir.

mysql> SELECT ADDTIME('1997-12-31 23:59:59.999999','1 1:1:1.000002');
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59.999999','1 1:1:1.000002') |
+---------------------------------------------------------+
| 1998-01-02 01:01:01.000001                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CONVERT_TZ (dt, from_tz, to_tz)

Bu, dt tarih saat değerini to_tz ile verilen zaman diliminden to_tz tarafından verilen zaman dilimine dönüştürür ve elde edilen değeri döndürür. Bağımsız değişkenler geçersizse bu işlev NULL döndürür.

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','GMT','MET')           |
+---------------------------------------------------------+
| 2004-01-01 13:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00')     |
+---------------------------------------------------------+
| 2004-01-01 22:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURDATE ()

İşlevin bir dizede mi yoksa sayısal bir bağlamda mı kullanıldığına bağlı olarak, geçerli tarihi 'YYYY-AA-GG' veya YYYYMMDD biçiminde bir değer olarak döndürür.

mysql> SELECT CURDATE();
+---------------------------------------------------------+
| CURDATE()                                               |
+---------------------------------------------------------+
| 1997-12-15                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CURDATE() + 0;
+---------------------------------------------------------+
| CURDATE() + 0                                           |
+---------------------------------------------------------+
| 19971215                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURRENT_DATE ve CURRENT_DATE ()

CURRENT_DATE ve CURRENT_DATE (), CURDATE () ile eşanlamlıdır

CURTIME ()

İşlevin bir dizede mi yoksa sayısal bir bağlamda mı kullanıldığına bağlı olarak geçerli saati 'HH: MM: SS' veya HHMMSS biçiminde bir değer olarak döndürür. Değer, geçerli saat diliminde ifade edilir.

mysql> SELECT CURTIME();
+---------------------------------------------------------+
| CURTIME()                                               |
+---------------------------------------------------------+
| 23:50:26                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CURTIME() + 0;
+---------------------------------------------------------+
| CURTIME() + 0                                           |
+---------------------------------------------------------+
| 235026                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURRENT_TIME ve CURRENT_TIME ()

CURRENT_TIME ve CURRENT_TIME (), CURTIME () ile eşanlamlıdır.

CURRENT_TIMESTAMP ve CURRENT_TIMESTAMP ()

CURRENT_TIMESTAMP ve CURRENT_TIMESTAMP (), NOW () ile eşanlamlıdır.

TARİH (ifade)

Tarihin veya tarih saat ifadesinin tarih kısmını ayıklar.

mysql> SELECT DATE('2003-12-31 01:02:03');
+---------------------------------------------------------+
| DATE('2003-12-31 01:02:03')                             |
+---------------------------------------------------------+
|  2003-12-31                                             |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATEDIFF (ifade1; ifade2)

DATEDIFF () ifade1'i döndürür. ifade2, bir tarihten diğerine gün cinsinden bir değer olarak ifade edilir. Hem ifade1 hem de ifade2, tarih veya tarih ve saat ifadeleridir. Hesaplamada değerlerin yalnızca tarih bölümleri kullanılır.

mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');
+---------------------------------------------------------+
| DATEDIFF('1997-12-31 23:59:59','1997-12-30')            |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_ADD (tarih, INTERVAL ifade birimi), DATE_SUB (tarih, INTERVAL ifade birimi)

Bu işlevler tarih aritmetiği gerçekleştirir. datebaşlangıç tarihini belirten bir DATETIME veya DATE değeridir. exprbaşlangıç tarihinden itibaren eklenecek veya çıkarılacak aralık değerini belirten bir ifadedir. İfade bir dizedir; negatif aralıklar için '-' ile başlayabilir.

Bir unit ifadenin yorumlanması gereken birimleri gösteren bir anahtar kelimedir.

INTERVAL anahtar sözcük ve birim belirteci büyük / küçük harfe duyarlı değildir.

Aşağıdaki tablo, her birim değeri için ifade bağımsız değişkeninin beklenen şeklini gösterir.

birim değer	Beklenen ifade biçimi
MICROSECOND	MICROSECONDS
İKİNCİ	SANİYE
DAKİKA	DAKİKA
SAAT	SAATLER
GÜN	GÜN
HAFTA	HAFTALAR
AY	AYLAR
ÇEYREK	ÇEYREKLER
YIL	YILLAR
SECOND_MICROSECOND	'SECONDS.MICROSECONDS'
MINUTE_MICROSECOND	'MINUTES.MICROSECONDS'
MINUTE_SECOND	"MINUTES: SECONDS"
HOUR_MICROSECOND	'HOURS.MICROSECONDS'
HOUR_SECOND	'HOURS: MINUTES: SECONDS'
HOUR_MINUTE	'HOURS: MINUTES'
DAY_MICROSECOND	'GÜNLER.MİKROSEKONLAR'
DAY_SECOND	"DAYS HOURS: MINUTES: SECONDS"
DAY_MINUTE	"DAYS HOURS: MINUTES"
DAY_HOUR	'DAYS HOURS'
YIL AY	"YIL-AY"

Değerler QUARTER ve WEEKMySQL 5.0.0'dan temin edilebilir. versiyon.

mysql> SELECT DATE_ADD('1997-12-31 23:59:59', 
   -> INTERVAL '1:1' MINUTE_SECOND);
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59', INTERVAL...             |
+---------------------------------------------------------+
| 1998-01-01 00:01:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);
+---------------------------------------------------------+
| DATE_ADD('1999-01-01', INTERVAL 1 HOUR)                 |
+---------------------------------------------------------+
| 1999-01-01 01:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_FORMAT (tarih, biçim)

Bu komut, tarih değerini biçim dizesine göre biçimlendirir.

Biçim dizesinde aşağıdaki belirticiler kullanılabilir. Biçim belirleyici karakterlerden önce '%' karakteri gereklidir.

Sr.No.	Tanımlayıcı ve Açıklama
1	%a Kısaltılmış hafta içi adı (Paz..Sat)
2	%b Kısaltılmış ay adı (Jan..Dec)
3	%c Ay, sayısal (0..12)
4	%D İngilizce son eki olan ayın günü (0, 1, 2, 3,.)
5	%d Ayın günü, sayısal (00..31)
6	%e Ayın günü, sayısal (0..31)
7	%f Mikrosaniye (000000..999999)
8	%H Saat (00..23)
9	%h Saat (01..12)
10	%I Saat (01..12)
11	%i Dakika, sayısal (00..59)
12	%j Yılın günü (001..366)
13	%k Saat (0..23)
14	%l Saat (1..12)
15	%M Ay adı (Ocak..Aralık)
16	%m Ay, sayısal (00..12)
17	%p AM veya PM
18	%r Zaman, 12 saat (ss: dd: ss ve ardından AM veya PM)
19	%S Saniye (00..59)
20	%s Saniye (00..59)
21	%T Zaman, 24 saat (ss: dd: ss)
22	%U Hafta (00..53), Pazar haftanın ilk günüdür
23	%u Hafta (00..53), Pazartesi haftanın ilk günüdür
24	%V Pazar'ın haftanın ilk günü olduğu Hafta (01..53); % X ile kullanıldı
25	%v Pazartesi haftanın ilk günü olduğu Hafta (01..53); % x ile kullanıldı
26	%W Hafta içi adı (Pazar .. Cumartesi)
27	%w Haftanın günü (0 = Pazar. 6 = Cumartesi)
28	%X Pazarın haftanın ilk günü olduğu hafta için yıl, sayısal, dört basamaklı; % V ile kullanıldı
29	%x Hafta için yıl, Pazartesi haftanın ilk günüdür, sayısal, dört basamaklı; % v ile kullanıldı
30	%Y Yıl, sayısal, dört basamaklı
31	%y Yıl, sayısal (iki basamaklı)
32	%% Gerçek bir%. karakter
33	%x x, any.x için. yukarıda listelenmemiş

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y')          |
+---------------------------------------------------------+
| Saturday October 1997                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00'
   -> '%H %k %I %r %T %S %w');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00.......                 |
+---------------------------------------------------------+
|  22 22 10 10:23:00 PM 22:23:00 00 6                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_SUB (tarih, INTERVAL ifade birimi)

Bu, DATE_ADD () işlevine benzer.

GÜN (tarih)

GÜN (), DAYOFMONTH () işlevinin eşanlamlısıdır.

DAYNAME (tarih)

Tarih için haftanın gününün adını verir.

mysql> SELECT DAYNAME('1998-02-05');
+---------------------------------------------------------+
| DAYNAME('1998-02-05')                                   |
+---------------------------------------------------------+
| Thursday                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFMONTH (tarih)

0 - 31 aralığında tarih için ayın gününü döndürür.

mysql> SELECT DAYOFMONTH('1998-02-03');
+---------------------------------------------------------+
| DAYOFMONTH('1998-02-03')                                |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFWEEK (tarih)

Tarihin hafta içi dizinini döndürür (1 = Pazar, 2 = Pazartesi,., 7 = Cumartesi). Bu indeks değerleri ODBC standardına karşılık gelir.

mysql> SELECT DAYOFWEEK('1998-02-03');
+---------------------------------------------------------+
|DAYOFWEEK('1998-02-03')                                  |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFYEAR (tarih)

1 - 366 aralığında tarih için yılın gününü döndürür.

mysql> SELECT DAYOFYEAR('1998-02-03');
+---------------------------------------------------------+
| DAYOFYEAR('1998-02-03')                                 |
+---------------------------------------------------------+
| 34                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

EKSTRAKT (tarihten itibaren birim)

EXTRACT () işlevi, DATE_ADD () veya DATE_SUB () ile aynı türden birim tanımlayıcıları kullanır, ancak tarih aritmetiği yapmak yerine tarihten bölümleri çıkarır.

mysql> SELECT EXTRACT(YEAR FROM '1999-07-02');
+---------------------------------------------------------+
| EXTRACT(YEAR FROM '1999-07-02')                         |
+---------------------------------------------------------+
| 1999                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03');
+---------------------------------------------------------+
| EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03')          |
+---------------------------------------------------------+
| 199907                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

GÜN_DEN (N)

N gün sayısı verildiğinde, bir TARİH değeri döndürür.

mysql> SELECT FROM_DAYS(729669);
+---------------------------------------------------------+
| FROM_DAYS(729669)                                       |
+---------------------------------------------------------+
| 1997-10-07                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Note- Eski tarihlerde FROM_DAYS () öğesini dikkatli kullanın. Miladi takvimin (1582) ortaya çıkışından önceki değerlerle kullanılması amaçlanmamıştır.

FROM_UNIXTIME (unix_timestamp)

FROM_UNIXTIME (unix_timestamp, biçim)

Şunun bir temsilini verir unix_timestampişlevin bir dizede mi yoksa sayısal bir bağlamda mı kullanıldığına bağlı olarak 'YYYY-AA-GG SS: AA: SS veya YYYYMMDDHHMMSS biçiminde bir değer olarak bağımsız değişken. Değer, geçerli saat diliminde ifade edilir. Unix_timestamp argümanı, tarafından üretilen dahili bir zaman damgası değerleridir.UNIX_TIMESTAMP() işlevi.

Biçim verilirse, sonuç, girişte listelenenle aynı şekilde kullanılan biçim dizesine göre biçimlendirilir. DATE_FORMAT() işlevi.

mysql> SELECT FROM_UNIXTIME(875996580);
+---------------------------------------------------------+
| FROM_UNIXTIME(875996580)                                |
+---------------------------------------------------------+
| 1997-10-04 22:23:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

HOUR (saat)

Saat için saati döndürür. Dönen değer aralığı, günün saati değerleri için 0 ile 23 arasındadır. Ancak, TIME değerlerinin aralığı gerçekte çok daha büyüktür, bu nedenle HOUR, 23'ten büyük değerler döndürebilir.

mysql> SELECT HOUR('10:05:03');
+---------------------------------------------------------+
| HOUR('10:05:03')                                        |
+---------------------------------------------------------+
| 10                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LAST_DAY (tarih)

Bir tarih veya tarih saat değeri alır ve ayın son günü için karşılık gelen değeri döndürür. Bağımsız değişken geçersizse NULL döndürür.

mysql> SELECT LAST_DAY('2003-02-05');
+---------------------------------------------------------+
| LAST_DAY('2003-02-05')                                  |
+---------------------------------------------------------+
| 2003-02-28                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LOCALTIME ve LOCALTIME ()

LOCALTIME ve LOCALTIME (), NOW () ile eşanlamlıdır.

LOCALTIMESTAMP ve LOCALTIMESTAMP ()

LOCALTIMESTAMP ve LOCALTIMESTAMP (), NOW () ile eşanlamlıdır.

MAKEDATE (yıl, günyıl)

Yıl ve yılın günü değerleri verilen bir tarih döndürür. Dayofyear değeri 0'dan büyük olmalıdır, aksi takdirde sonuç NULL olacaktır.

mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);
+---------------------------------------------------------+
| MAKEDATE(2001,31), MAKEDATE(2001,32)                    |
+---------------------------------------------------------+
| '2001-01-31', '2001-02-01'                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MAKETIME (saat, dakika, saniye)

Saat, dakika ve saniye bağımsız değişkenlerinden hesaplanan bir zaman değeri döndürür.

mysql> SELECT MAKETIME(12,15,30);
+---------------------------------------------------------+
| MAKETIME(12,15,30)                                      |
+---------------------------------------------------------+
| '12:15:30'                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MICROSECOND (ifade)

Zaman veya tarih saat ifadesindeki (ifade) mikrosaniyeleri 0 ile 999999 aralığında bir sayı olarak döndürür.

mysql> SELECT MICROSECOND('12:00:00.123456');
+---------------------------------------------------------+
| MICROSECOND('12:00:00.123456')                          |
+---------------------------------------------------------+
| 123456                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MINUTE (zaman)

0 - 59 aralığında, dakikayı döndürür.

mysql> SELECT MINUTE('98-02-03 10:05:03');
+---------------------------------------------------------+
| MINUTE('98-02-03 10:05:03')                             |
+---------------------------------------------------------+
| 5                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Ay Tarihi)

0 - 12 aralığında tarih için ayı döndürür.

mysql> SELECT MONTH('1998-02-03')
+---------------------------------------------------------+
| MONTH('1998-02-03')                                     |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MONTHNAME (tarih)

Bir tarih için ayın tam adını verir.

mysql> SELECT MONTHNAME('1998-02-05');
+---------------------------------------------------------+
| MONTHNAME('1998-02-05')                                 |
+---------------------------------------------------------+
| February                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

ŞİMDİ ()

İşlevin bir dizede mi yoksa sayısal bağlamda mı kullanıldığına bağlı olarak, geçerli tarih ve saati 'YYYY-AA-GG SS: AA: SS' veya YYYYMMDDHHMMSS biçiminde bir değer olarak döndürür. Bu değer, mevcut saat diliminde ifade edilir.

mysql> SELECT NOW();
+---------------------------------------------------------+
| NOW()                                                   |
+---------------------------------------------------------+
| 1997-12-15 23:50:26                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

PERIOD_ADD (P; N)

P dönemine N ay ekler (YYMM veya YYYYMM biçiminde). YYYYAAG biçiminde bir değer döndürür. P periyot bağımsız değişkeninin bir tarih değeri olmadığını unutmayın.

mysql> SELECT PERIOD_ADD(9801,2);
+---------------------------------------------------------+
| PERIOD_ADD(9801,2)                                      |
+---------------------------------------------------------+
| 199803                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

PERIOD_DIFF (P1; P2)

P1 ve P2 dönemleri arasındaki ay sayısını döndürür. Bu P1 ve P2 dönemleri YYMM veya YYYYMM formatında olmalıdır. P1 ve P2 dönem bağımsız değişkenlerinin tarih değerleri olmadığını unutmayın.

mysql> SELECT PERIOD_DIFF(9802,199703);
+---------------------------------------------------------+
| PERIOD_DIFF(9802,199703)                                |
+---------------------------------------------------------+
| 11                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

QUARTER (tarih)

1 - 4 aralığında tarih için yılın çeyreğini döndürür.

mysql> SELECT QUARTER('98-04-01');
+---------------------------------------------------------+
| QUARTER('98-04-01')                                     |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

İkinci kez)

0 - 59 aralığında saniyeyi döndürür.

mysql> SELECT SECOND('10:05:03');
+---------------------------------------------------------+
| SECOND('10:05:03')                                      |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SEC_TO_TIME (saniye)

İşlevin bir dizede mi yoksa sayısal bağlamda mı kullanıldığına bağlı olarak saat, dakika ve saniyeye dönüştürülen saniye bağımsız değişkenini 'SS: DD: SS' veya HHMMSS biçiminde bir değer olarak döndürür.

mysql> SELECT SEC_TO_TIME(2378);
+---------------------------------------------------------+
| SEC_TO_TIME(2378)                                       |
+---------------------------------------------------------+
| 00:39:38                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

STR_TO_DATE (str, biçim)

Bu, DATE_FORMAT () işlevinin tersidir. Bir dizge dizisi ve bir biçim dizesi biçimi alır. STR_TO_DATE () işlevi, biçim dizesi hem tarih hem de saat bölümleri içeriyorsa bir DATETIME değeri döndürür. Aksi takdirde, dize yalnızca tarih veya saat bölümlerini içeriyorsa bir TARİH veya SAAT değeri döndürür.

mysql> SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y');
+---------------------------------------------------------+
| STR_TO_DATE('04/31/2004', '%m/%d/%Y')                   |
+---------------------------------------------------------+
| 2004-04-31                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SUBDATE (tarih, INTERVAL ifade birimi) ve SUBDATE (ifade, günler)

İkinci bağımsız değişkenin INTERVAL biçimiyle çağrıldığında, SUBDATE () DATE_SUB () ile eşanlamlıdır. INTERVAL birim bağımsız değişkeni hakkında bilgi için, DATE_ADD () için tartışmaya bakın.

mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_SUB('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1997-12-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| SUBDATE('1998-01-02', INTERVAL 31 DAY)                  |
+---------------------------------------------------------+
| 1997-12-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SUBTIME (ifade1; ifade2)

SUBTIME () işlevi ifade1'i döndürür. ifade2, ifade1 ile aynı biçimde bir değer olarak ifade edilir. İfade1 değeri bir saat veya tarih saat ifadesidir, ifade2 değeri ise bir zaman ifadesidir.

mysql> SELECT SUBTIME('1997-12-31 23:59:59.999999',
   -> '1 1:1:1.000002');
+---------------------------------------------------------+
| SUBTIME('1997-12-31 23:59:59.999999'...                 |
+---------------------------------------------------------+
| 1997-12-30 22:58:58.999997                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SYSDATE ()

İşlevin bir dizede mi yoksa sayısal bir bağlamda mı kullanıldığına bağlı olarak, geçerli tarih ve saati 'YYYY-AA-GG SS: AA: SS' veya YYYYMMDDHHMMSS biçiminde bir değer olarak döndürür.

mysql> SELECT SYSDATE();
+---------------------------------------------------------+
| SYSDATE()                                               |
+---------------------------------------------------------+
| 2006-04-12 13:47:44                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIME (ifade)

Zamanın zaman bölümünü veya tarih saat ifadesini ayıklar expr ve onu bir dizge olarak döndürür.

mysql> SELECT TIME('2003-12-31 01:02:03');
+---------------------------------------------------------+
| TIME('2003-12-31 01:02:03')                             |
+---------------------------------------------------------+
| 01:02:03                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMEDIFF (ifade1; ifade2)

TIMEDIFF () işlevi ifade1'i döndürür. ifade2 bir zaman değeri olarak ifade edilir. Bu ifade1 ve ifade2 değerleri saat veya tarih ve saat ifadeleridir ancak her ikisi de aynı türde olmalıdır.

mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001',
   -> '1997-12-30 01:01:01.000002');
+---------------------------------------------------------+
| TIMEDIFF('1997-12-31 23:59:59.000001'.....              |
+---------------------------------------------------------+
|  46:58:57.999999                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMP (ifade), TIMESTAMP (ifade1, ifade2)

Tek bir bağımsız değişkenle bu işlev, tarih veya tarih saat ifadesini tarih saat değeri olarak döndürür. İki bağımsız değişkenle, expr2 zaman ifadesini tarih veya tarih saat ifadesine eklerexpr1 ve sonucu tarih saat değeri olarak döndürür.

mysql> SELECT TIMESTAMP('2003-12-31');
+---------------------------------------------------------+
| TIMESTAMP('2003-12-31')                                 |
+---------------------------------------------------------+
| 2003-12-31 00:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMPADD (birim, aralık; tarihsaat_expr)

Bu fonksiyon, tamsayı ifade aralığını tarih veya tarih saat ifadesine ekler datetime_expr. Aralık birimi, aşağıdaki değerlerden biri olması gereken birim bağımsız değişkeni tarafından verilir -

FRAC_SECOND
SECOND, MINUTE
HOUR, DAY
WEEK
MONTH
QUARTER veya
YEAR

Birim değeri, gösterilen anahtar sözcüklerden biri kullanılarak veya bir SQL_TSI_ öneki ile belirtilebilir.

Örneğin, DAY ve SQL_TSI_DAY yasaldır.

mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');
+---------------------------------------------------------+
| TIMESTAMPADD(MINUTE,1,'2003-01-02')                     |
+---------------------------------------------------------+
| 2003-01-02 00:01:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMPDIFF (birim; tarihsaat_expr1; tarihsaat_expr2)

Tarih veya tarih saat ifadeleri datetime_expr1 ve datetime_expr2 arasındaki tam sayı farkını döndürür. Sonucun birimi, birim bağımsız değişkeni tarafından verilir. Birim için yasal değerler, TIMESTAMPADD () işlevinin açıklamasında listelenenlerle aynıdır.

mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');
+---------------------------------------------------------+
| TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01')          |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIME_FORMAT (saat, biçim)

Bu işlev DATE_FORMAT () işlevi gibi kullanılır, ancak biçim dizesi yalnızca saat, dakika ve saniye için biçim belirleyicileri içerebilir.

Zaman değeri 23'ten büyük bir saat bölümü içeriyorsa,%H ve %k saat biçimi belirleyicileri, 0 ile 23 arasındaki normal aralıktan daha büyük bir değer üretir. Diğer saat biçimi belirleyicileri, 12 modulo saat değerini üretir.

mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');
+---------------------------------------------------------+
| TIME_FORMAT('100:00:00', '%H %k %h %I %l')              |
+---------------------------------------------------------+
| 100 100 04 04 4                                         |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIME_TO_SEC (zaman)

Saniyeye dönüştürülen zaman bağımsız değişkenini döndürür.

mysql> SELECT TIME_TO_SEC('22:23:00');
+---------------------------------------------------------+
| TIME_TO_SEC('22:23:00')                                 |
+---------------------------------------------------------+
| 80580                                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Bugünün tarihi)

Bir tarih verildiğinde, bir gün numarası döndürür (0 yılından bu yana geçen günlerin sayısı).

mysql> SELECT TO_DAYS(950501);
+---------------------------------------------------------+
| TO_DAYS(950501)                                         |
+---------------------------------------------------------+
| 728779                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UNIX_TIMESTAMP (), UNIX_TIMESTAMP (tarih)

Bağımsız değişken olmadan çağrılırsa, bu işlev işaretsiz bir tamsayı olarak bir Unix zaman damgası döndürür ('1970-01-01 00:00:00' UTC'den bu yana saniyeler). UNIX_TIMESTAMP () bir tarih bağımsız değişkeniyle çağrılırsa, bağımsız değişkenin değerini '1970-01-01 00:00:00' UTC'den bu yana saniye olarak döndürür. tarih bir DATE dizesi, DATETIME dizesi, TIMESTAMP veya YYAAGG veya YYYYAAGG biçiminde bir sayı olabilir.

mysql> SELECT UNIX_TIMESTAMP();
+---------------------------------------------------------+
| UNIX_TIMESTAMP()                                        |
+---------------------------------------------------------+
| 882226357                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');
+---------------------------------------------------------+
| UNIX_TIMESTAMP('1997-10-04 22:23:00')                   |
+---------------------------------------------------------+
| 875996580                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_DATE, UTC_DATE ()

İşlevin bir dizede mi yoksa sayısal bağlamda mı kullanıldığına bağlı olarak, geçerli UTC tarihini "YYYY-AA-GG" veya YYYYMMDD biçiminde bir değer olarak döndürür.

mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
+---------------------------------------------------------+
| UTC_DATE(), UTC_DATE() + 0                              |
+---------------------------------------------------------+
| 2003-08-14, 20030814                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_TIME, UTC_TIME ()

İşlevin bir dizede mi yoksa sayısal bağlamda mı kullanıldığına bağlı olarak, geçerli UTC saatini "HH: MM: SS" veya HHMMSS biçiminde bir değer olarak döndürür.

mysql> SELECT UTC_TIME(), UTC_TIME() + 0;
+---------------------------------------------------------+
| UTC_TIME(), UTC_TIME() + 0                              |
+---------------------------------------------------------+
| 18:07:53, 180753                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_TIMESTAMP, UTC_TIMESTAMP ()

İşlevin bir dizede mi yoksa sayısal bir bağlamda mı kullanıldığına bağlı olarak geçerli UTC tarih ve saatini 'YYYY-AA-GG SS: DD: SS' veya YYYYMMDDHHMMSS biçiminde bir değer olarak döndürür.

mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;
+---------------------------------------------------------+
| UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0                    |
+---------------------------------------------------------+
| 2003-08-14 18:08:04, 20030814180804                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

WEEK (tarih [, mod])

Bu işlev tarih için hafta numarasını döndürür. WEEK () 'in iki bağımsız değişkenli biçimi, haftanın Pazar mı yoksa Pazartesi mi başladığını ve dönüş değerinin 0 ile 53 arasında mı yoksa 1 ile 53 arasında mı olması gerektiğini belirlemenize olanak tanır. Mod bağımsız değişkeni atlanırsa, default_week_format sistem değişkeninin değeri kullanılır

Mod	Haftanın ilk günü	Aralık	1. Hafta ilk haftadır.
0	Pazar	0-53	bu yıl bir Pazar günü
1	Pazartesi	0-53	bu yıl 3 günden fazla
2	Pazar	1-53	bu yıl bir Pazar günü
3	Pazartesi	1-53	bu yıl 3 günden fazla
4	Pazar	0-53	bu yıl 3 günden fazla
5	Pazartesi	0-53	bu yıl bir pazartesi ile
6	Pazar	1-53	bu yıl 3 günden fazla
7	Pazartesi	1-53	bu yıl bir pazartesi ile

mysql> SELECT WEEK('1998-02-20');
+---------------------------------------------------------+
| WEEK('1998-02-20')                                      |
+---------------------------------------------------------+
| 7                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

WEEKDAY (tarih)

Tarihin hafta içi dizinini döndürür (0 = Pazartesi, 1 = Salı,. 6 = Pazar).

mysql> SELECT WEEKDAY('1998-02-03 22:23:00');
+---------------------------------------------------------+
| WEEKDAY('1998-02-03 22:23:00')                          |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

WEEKOFYEAR (tarih)

Tarihin takvim haftasını 1 - 53 aralığında bir sayı olarak döndürür. WEEKOFYEAR () WEEK (tarih, 3) ile eşdeğer bir uyumluluk işlevidir.

mysql> SELECT WEEKOFYEAR('1998-02-20');
+---------------------------------------------------------+
| WEEKOFYEAR('1998-02-20')                                |
+---------------------------------------------------------+
| 8                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

YIL (tarih)

1000 - 9999 aralığında tarih için yılı veya sıfır için 0 değerini döndürür. tarih.

mysql> SELECT YEAR('98-02-03');
+---------------------------------------------------------+
| YEAR('98-02-03')                                        |
+---------------------------------------------------------+
| 1998                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

YEARWEEK (tarih), YEARWEEK (tarih, mod)

Bir tarih için yılı ve haftayı döndürür. Mod argümanı tam olarak WEEK () işlevinin mod argümanı gibi çalışır. Sonuçtaki yıl, yılın ilk ve son haftası için tarih bağımsız değişkenindeki yıldan farklı olabilir.

mysql> SELECT YEARWEEK('1987-01-01');
+---------------------------------------------------------+
| YEAR('98-02-03')YEARWEEK('1987-01-01')                  |
+---------------------------------------------------------+
| 198653                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Note - Hafta numarası, WEEK () işlevinin 0 veya 1 isteğe bağlı bağımsız değişkenler için (0) döndüreceğinden farklıdır, çünkü WEEK (), verilen yıl bağlamında haftayı döndürür.

SQL - Geçici Tablolar

Geçici Tablolar nelerdir?

Geçici tabloları destekleyen RDBMS vardır. Geçici Tablolar size izin veren harika bir özelliktir.store and process intermediate results tipik SQL Server tablolarıyla kullanabileceğiniz aynı seçim, güncelleme ve birleştirme yeteneklerini kullanarak.

Geçici tablolar, bazı durumlarda geçici verileri saklamak için çok yararlı olabilir. Geçici tablolar için bilinmesi gereken en önemli şey, mevcut istemci oturumu sona erdiğinde silinecek olmalarıdır.

Geçici tablolar MySQL 3.23 sürümünden itibaren mevcuttur. MySQL'in 3.23'ten daha eski bir sürümünü kullanıyorsanız, geçici tablolar kullanamazsınız, ancakheap tables.

Daha önce belirtildiği gibi, geçici tablolar yalnızca oturum canlı olduğu sürece devam edecektir. Kodu bir PHP betiğinde çalıştırırsanız, betik yürütmeyi bitirdiğinde geçici tablo otomatik olarak yok edilir. MySQL veritabanı sunucusuna MySQL istemci programı aracılığıyla bağlanırsanız, geçici tablo siz istemciyi kapatana veya tabloyu manuel olarak yok edene kadar var olacaktır.

Misal

İşte size geçici bir tablonun kullanımını gösteren bir örnek.

mysql> CREATE TEMPORARY TABLE SALESSUMMARY (
   -> product_name VARCHAR(50) NOT NULL
   -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
   -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO SALESSUMMARY
   -> (product_name, total_sales, avg_unit_price, total_units_sold)
   -> VALUES
   -> ('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SALESSUMMARY;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
| cucumber     |      100.25 |          90.00 |                2 |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)

Bir SHOW TABLES komutu verdiğinizde, geçici tablonuz listede listelenmeyecektir. Şimdi, MySQL oturumunu kapatırsanız ve ardından bir SELECT komutu verirseniz, veritabanında hiçbir veri bulamazsınız. Geçici masanız bile mevcut olmayacak.

Geçici Tabloları Kaldırmak

Varsayılan olarak, veritabanı bağlantınız sonlandırıldığında tüm geçici tablolar MySQL tarafından silinir. Yine de aralarında silmek isterseniz, bunu birDROP TABLE komut.

Aşağıda geçici bir tablonun düşürülmesine bir örnek verilmiştir.

mysql> CREATE TEMPORARY TABLE SALESSUMMARY (
   -> product_name VARCHAR(50) NOT NULL
   -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
   -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO SALESSUMMARY
   -> (product_name, total_sales, avg_unit_price, total_units_sold)
   -> VALUES
   -> ('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SALESSUMMARY;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
| cucumber     |      100.25 |          90.00 |                2 |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)
mysql> DROP TABLE SALESSUMMARY;
mysql>  SELECT * FROM SALESSUMMARY;
ERROR 1146: Table 'TUTORIALS.SALESSUMMARY' doesn't exist

SQL - Tabloları Klonla

Bir tablonun tam bir kopyasına ihtiyaç duyduğunuzda ve CREATE TABLE ... veya SELECT ... komutlarının amaçlarınıza uygun olmadığı bir durum olabilir çünkü kopya aynı indeksleri, varsayılan değerleri vb. İçermelidir.

MySQL RDBMS kullanıyorsanız, bu durumu aşağıda verilen adımlara uyarak halledebilirsiniz -

Kaynak tablonun yapısını, dizinlerini ve tümünü belirten bir CREATE TABLE deyimi almak için SHOW CREATE TABLE komutunu kullanın.
Tablo adını klon tablosununkiyle değiştirmek ve ifadeyi yürütmek için ifadeyi değiştirin. Bu şekilde tam bir klon tablosuna sahip olacaksınız.
İsteğe bağlı olarak, tablo içeriğinin de kopyalanması gerekiyorsa, bir INSERT INTO veya bir SELECT ifadesi de yayınlayın.

Misal

Aşağıdaki örneği deneyerek bir klon tablosu oluşturmayı deneyin. TUTORIALS_TBL yapısı aşağıdaki gibidir -

Step 1 - Masanın tüm yapısını alın.

SQL> SHOW CREATE TABLE TUTORIALS_TBL \G; 
*************************** 1. row *************************** 
      Table: TUTORIALS_TBL 
Create Table: CREATE TABLE 'TUTORIALS_TBL' ( 
  'tutorial_id' int(11) NOT NULL auto_increment, 
  'tutorial_title' varchar(100) NOT NULL default '', 
  'tutorial_author' varchar(40) NOT NULL default '', 
  'submission_date' date default NULL, 
  PRIMARY KEY  ('tutorial_id'), 
  UNIQUE KEY 'AUTHOR_INDEX' ('tutorial_author') 
) TYPE = MyISAM 
1 row in set (0.00 sec)

Step 2 - Bu tabloyu yeniden adlandırın ve başka bir tablo oluşturun.

SQL> CREATE TABLE `CLONE_TBL` ( 
  -> 'tutorial_id' int(11) NOT NULL auto_increment, 
  -> 'tutorial_title' varchar(100) NOT NULL default '', 
  -> 'tutorial_author' varchar(40) NOT NULL default '', 
  -> 'submission_date' date default NULL, 
  -> PRIMARY KEY  (`tutorial_id'), 
  -> UNIQUE KEY 'AUTHOR_INDEX' ('tutorial_author') 
-> ) TYPE = MyISAM; 
Query OK, 0 rows affected (1.80 sec)

Step 3- 2. adımı uyguladıktan sonra, veritabanınızdaki bir tabloyu klonlayacaksınız. Eski bir tablodan veri kopyalamak istiyorsanız, bunu INSERT INTO ... SELECT deyimini kullanarak yapabilirsiniz.

SQL> INSERT INTO CLONE_TBL (tutorial_id, 
   ->                        tutorial_title, 
   ->                        tutorial_author, 
   ->                        submission_date) 
   -> SELECT tutorial_id,tutorial_title, 
   ->        tutorial_author,submission_date, 
   -> FROM TUTORIALS_TBL; 
Query OK, 3 rows affected (0.07 sec) 
Records: 3  Duplicates: 0  Warnings: 0

Son olarak, istediğiniz gibi tam bir klon tablosuna sahip olacaksınız.

SQL - Alt Sorgular

Bir Alt Sorgu veya İç sorgu veya İç içe sorgu, başka bir SQL sorgusu içindeki ve WHERE yan tümcesine gömülü bir sorgudur.

Bir alt sorgu, alınacak verileri daha da kısıtlamak için bir koşul olarak ana sorguda kullanılacak verileri döndürmek için kullanılır.

Alt sorgular SELECT, INSERT, UPDATE ve DELETE ifadeleriyle birlikte =, <,>,> =, <=, IN, BETWEEN, vb. Gibi işleçlerle kullanılabilir.

Alt sorguların uyması gereken birkaç kural vardır -

Alt sorgular parantez içine alınmalıdır.
Alt sorgunun seçili sütunlarını karşılaştırmak için ana sorguda birden çok sütun olmadığı sürece, bir alt sorgunun SELECT yan tümcesinde yalnızca bir sütun olabilir.
ORDER BY komutu bir alt sorguda kullanılamaz, ancak ana sorgu ORDER BY kullanabilir. GROUP BY komutu, bir alt sorguda ORDER BY ile aynı işlevi gerçekleştirmek için kullanılabilir.
Birden fazla satır döndüren alt sorgular yalnızca IN operatörü gibi birden çok değer operatörüyle kullanılabilir.
SEÇİM listesi, BLOB, ARRAY, CLOB veya NCLOB olarak değerlendirilen değerlere herhangi bir referans içeremez.
Bir alt sorgu, bir küme işlevinin içine hemen eklenemez.
BETWEEN operatörü bir alt sorgu ile kullanılamaz. Ancak BETWEEN operatörü alt sorgu içinde kullanılabilir.

SELECT İfadesine sahip alt sorgular

Alt sorgular en çok SELECT deyimiyle kullanılır. Temel sözdizimi aşağıdaki gibidir -

SELECT column_name [, column_name ]
FROM   table1 [, table2 ]
WHERE  column_name OPERATOR
   (SELECT column_name [, column_name ]
   FROM table1 [, table2 ]
   [WHERE])

Misal

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Şimdi aşağıdaki alt sorguyu bir SELECT ifadesiyle kontrol edelim.

SQL> SELECT * 
   FROM CUSTOMERS 
   WHERE ID IN (SELECT ID 
         FROM CUSTOMERS 
         WHERE SALARY > 4500) ;

Bu, aşağıdaki sonucu verecektir.

+----+----------+-----+---------+----------+
| ID | NAME     | AGE | ADDRESS | SALARY   |
+----+----------+-----+---------+----------+
|  4 | Chaitali |  25 | Mumbai  |  6500.00 |
|  5 | Hardik   |  27 | Bhopal  |  8500.00 |
|  7 | Muffy    |  24 | Indore  | 10000.00 |
+----+----------+-----+---------+----------+

INSERT İfadesine sahip alt sorgular

Alt sorgular ayrıca INSERT deyimleriyle de kullanılabilir. INSERT ifadesi, başka bir tabloya eklemek için alt sorgudan döndürülen verileri kullanır. Alt sorgudaki seçilen veriler karakter, tarih veya sayı işlevlerinden herhangi biri ile değiştirilebilir.

Temel sözdizimi aşağıdaki gibidir.

INSERT INTO table_name [ (column1 [, column2 ]) ]
   SELECT [ *|column1 [, column2 ]
   FROM table1 [, table2 ]
   [ WHERE VALUE OPERATOR ]

Misal

CUSTOMERS tablosu ile benzer yapıya sahip bir CUSTOMERS_BKP tablosu düşünün. Şimdi, CUSTOMERS tablosunun tamamını CUSTOMERS_BKP tablosuna kopyalamak için aşağıdaki sözdizimini kullanabilirsiniz.

SQL> INSERT INTO CUSTOMERS_BKP
   SELECT * FROM CUSTOMERS 
   WHERE ID IN (SELECT ID 
   FROM CUSTOMERS) ;

UPDATE İfadesine sahip alt sorgular

Alt sorgu, UPDATE ifadesiyle bağlantılı olarak kullanılabilir. UPDATE ifadesiyle bir alt sorgu kullanıldığında, bir tablodaki tek veya birden çok sütun güncellenebilir.

Temel sözdizimi aşağıdaki gibidir.

UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

Misal

Varsayalım ki, CUSTOMERS tablosunun yedeği olan CUSTOMERS_BKP tablosumuz var. Aşağıdaki örnek, YAŞI 27'den büyük veya 27'ye eşit olan tüm müşteriler için MÜŞTERİLER tablosundaki MAAŞ'ı 0,25 kat günceller.

SQL> UPDATE CUSTOMERS
   SET SALARY = SALARY * 0.25
   WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
      WHERE AGE >= 27 );

Bu, iki satırı etkiler ve son olarak CUSTOMERS tablosu aşağıdaki kayıtlara sahip olur.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |   125.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  2125.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

DELETE İfadesine sahip alt sorgular

Alt sorgu, yukarıda bahsedilen diğer tüm ifadelerde olduğu gibi DELETE ifadesi ile birlikte kullanılabilir.

Temel sözdizimi aşağıdaki gibidir.

DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

Misal

Varsayalım ki, CUSTOMERS tablosunun yedeği olan bir CUSTOMERS_BKP tablosumuz var. Aşağıdaki örnek, YAŞ değeri 27'den büyük veya 27'ye eşit olan tüm müşteriler için MÜŞTERİLER tablosundaki kayıtları siler.

SQL> DELETE FROM CUSTOMERS
   WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
      WHERE AGE >= 27 );

Bu, iki satırı etkiler ve son olarak CUSTOMERS tablosu aşağıdaki kayıtlara sahip olur.

+----+----------+-----+---------+----------+
| ID | NAME     | AGE | ADDRESS | SALARY   |
+----+----------+-----+---------+----------+
|  2 | Khilan   |  25 | Delhi   |  1500.00 |
|  3 | kaushik  |  23 | Kota    |  2000.00 |
|  4 | Chaitali |  25 | Mumbai  |  6500.00 |
|  6 | Komal    |  22 | MP      |  4500.00 |
|  7 | Muffy    |  24 | Indore  | 10000.00 |
+----+----------+-----+---------+----------+

SQL - Sıraları Kullanma

Bir dizi, talep üzerine sırayla üretilen 1, 2, 3, ... tam sayıları kümesidir. Diziler sıklıkla veritabanlarında kullanılır çünkü birçok uygulama bir tablodaki her satırın benzersiz bir değer içermesini gerektirir ve diziler bunları oluşturmak için kolay bir yol sağlar.

Bu bölüm, MySQL'de dizilerin nasıl kullanılacağını açıklar.

AUTO_INCREMENT sütunu kullanılıyor

MySQL'de dizileri kullanmanın en basit yolu, bir sütunu AUTO_INCREMENT olarak tanımlamak ve gerisini ilgilenmesi için MySQL'e bırakmaktır.

Misal

Aşağıdaki örneği deneyin. Bu bir tablo oluşturacak ve bundan sonra bu tabloya MySQL tarafından otomatik olarak artırıldığı için bir kayıt kimliği vermenin gerekli olmadığı birkaç satır ekleyecektir.

mysql> CREATE TABLE INSECT
   -> (
   -> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
   -> PRIMARY KEY (id),
   -> name VARCHAR(30) NOT NULL, # type of insect
   -> date DATE NOT NULL, # date collected
   -> origin VARCHAR(30) NOT NULL # where collected
);
Query OK, 0 rows affected (0.02 sec)
mysql> INSERT INTO INSECT (id,name,date,origin) VALUES
   -> (NULL,'housefly','2001-09-10','kitchen'),
   -> (NULL,'millipede','2001-09-10','driveway'),
   -> (NULL,'grasshopper','2001-09-10','front yard');
Query OK, 3 rows affected (0.02 sec)
Records: 3  Duplicates: 0  Warnings: 0
mysql> SELECT * FROM INSECT ORDER BY id;
+----+-------------+------------+------------+
| id | name        | date       | origin     |
+----+-------------+------------+------------+
|  1 | housefly    | 2001-09-10 | kitchen    |
|  2 | millipede   | 2001-09-10 | driveway   |
|  3 | grasshopper | 2001-09-10 | front yard |
+----+-------------+------------+------------+
3 rows in set (0.00 sec)

AUTO_INCREMENT Değerlerini Alın

LAST_INSERT_ID () bir SQL işlevidir, bu nedenle onu SQL ifadelerinin nasıl yayınlanacağını anlayan herhangi bir istemcinin içinden kullanabilirsiniz. Aksi takdirde, PERL ve PHP betikleri, son kaydın otomatik olarak artan değerini almak için özel işlevler sağlar.

PERL Örneği

Kullan mysql_insertidSorgu tarafından oluşturulan AUTO_INCREMENT değerini elde etmek için öznitelik. Bu özniteliğe, sorguyu nasıl yayınladığınıza bağlı olarak bir veritabanı tanıtıcısı veya bir ifade tutamacı aracılığıyla erişilir. Aşağıdaki örnek, veritabanı tanıtıcısı aracılığıyla buna başvurur.

$dbh->do ("INSERT INTO INSECT (name,date,origin) VALUES('moth','2001-09-14','windowsill')"); my $seq = $dbh->{mysql_insertid};

PHP Örneği

AUTO_INCREMENT değeri üreten bir sorgu gönderdikten sonra, değeri çağırarak alın mysql_insert_id( ) işlevi.

mysql_query ("INSERT INTO INSECT (name,date,origin)
VALUES('moth','2001-09-14','windowsill')", $conn_id);
$seq = mysql_insert_id ($conn_id);

Mevcut Bir Sırayı Yeniden Numaralandırma

Bir tablodan çok sayıda kayıt sildiğiniz ve tüm kayıtları yeniden sıralamak istediğiniz bir durum olabilir. Bu basit bir numara kullanılarak yapılabilir, ancak bunu yaparken çok dikkatli olmalısınız ve masanızın başka bir masa ile birleşip birleşmediğini kontrol etmelisiniz.

Bir AUTO_INCREMENT sütununun yeniden dizilmesinin kaçınılmaz olduğunu belirlerseniz, bunu yapmanın yolu sütunu tablodan bırakıp tekrar eklemektir.

Aşağıdaki örnek, bu teknik kullanılarak böcek tablosundaki id değerlerinin nasıl yeniden numaralandırılacağını gösterir.

mysql> ALTER TABLE INSECT DROP id;
mysql> ALTER TABLE insect
   -> ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
   -> ADD PRIMARY KEY (id);

Sıraya Belirli Bir Değerden Başlama

Varsayılan olarak, MySQL diziyi 1'den başlatır, ancak tablo oluşturma sırasında başka herhangi bir sayıyı da belirtebilirsiniz.

Aşağıdaki kod bloğu, MySQL'in diziyi 100'den başlayacağı bir örneğe sahiptir.

mysql> CREATE TABLE INSECT
   -> (
   -> id INT UNSIGNED NOT NULL AUTO_INCREMENT = 100,
   -> PRIMARY KEY (id),
   -> name VARCHAR(30) NOT NULL, # type of insect
   -> date DATE NOT NULL, # date collected
   -> origin VARCHAR(30) NOT NULL # where collected
);

Alternatif olarak, tabloyu oluşturabilir ve ardından ALTER TABLE ile ilk sıra değerini ayarlayabilirsiniz.

mysql> ALTER TABLE t AUTO_INCREMENT = 100;

SQL - Yinelenenleri İşleme

Bir tabloda birden çok yinelenen kaydınız olduğunda bir durum olabilir. Bu tür kayıtları getirirken, yinelenen kayıtları getirmek yerine yalnızca benzersiz kayıtları getirmek daha mantıklıdır.

SQL DISTINCT Daha önce tartıştığımız anahtar sözcük, tüm yinelenen kayıtları ortadan kaldırmak ve yalnızca benzersiz kayıtları almak için SELECT deyimi ile birlikte kullanılır.

Sözdizimi

Yinelenen kayıtları elemek için bir DISTINCT anahtar sözcüğünün temel sözdizimi aşağıdaki gibidir.

SELECT DISTINCT column1, column2,.....columnN 
FROM table_name
WHERE [condition]

Misal

Aşağıdaki kayıtlara sahip MÜŞTERİLER tablosunu düşünün.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Öncelikle, aşağıdaki SELECT sorgusunun yinelenen maaş kayıtlarını nasıl döndürdüğünü görelim.

SQL> SELECT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Bu, 2000 maaşının iki kez geldiği ve orijinal tablodan yinelenen bir kayıt olan aşağıdaki sonucu üretecektir.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

Şimdi yukarıdaki SELECT sorgusu ile DISTINCT anahtar kelimesini kullanalım ve sonucu görelim.

SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Bu, yinelenen girişimiz olmadığında aşağıdaki sonucu üretecektir.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

SQL - Enjeksiyon

Bir web sayfası üzerinden bir kullanıcı girdisi alır ve bunu bir SQL veritabanına eklerseniz, bir güvenlik sorunu için kendinizi tamamen açık bırakmış olabilirsiniz. SQL Injection. Bu bölüm size bunun olmasını nasıl engelleyeceğinizi öğretecek ve PERL Komut Dosyası gibi sunucu tarafı komut dosyalarınızdaki komut dosyalarınızı ve SQL ifadelerinizi güvenli hale getirmenize yardımcı olacaktır.

Enjeksiyon genellikle bir kullanıcıdan adı gibi bir girdi istediğinizde ve bir isim yerine size bilmeden veritabanınızda çalıştıracağınız bir SQL ifadesi verdiğinizde gerçekleşir. Kullanıcı tarafından sağlanan verilere asla güvenmeyin, bu verileri yalnızca doğrulamadan sonra işleyin; kural olarak, bu şu şekilde yapılır:Pattern Matching.

Aşağıdaki örnekte, name alfanümerik karakterler artı alt çizgi ve 8 ila 20 karakter arası bir uzunlukla sınırlıdır (bu kuralları gerektiği gibi değiştirin).

if (preg_match("/^\w{8,20}$/", $_GET['username'], $matches)) { $result = mysql_query("SELECT * FROM CUSTOMERS 
      WHERE name = $matches[0]");
} else {
   echo "user name not accepted";
}

Sorunu göstermek için bu alıntıyı düşünün -

// supposed input
$name = "Qadir'; DELETE FROM CUSTOMERS;";
mysql_query("SELECT * FROM CUSTOMSRS WHERE name='{$name}'");

İşlev çağrısının, CUSTOMERS tablosundan, ad sütununun kullanıcı tarafından belirtilen adla eşleştiği bir kaydı alması beklenir. Normal şartlar altında,$nameyalnızca alfanümerik karakterler ve belki de ilia dizesi gibi boşluklar içerebilir. Ama burada, $ name'e tamamen yeni bir sorgu ekleyerek, veritabanına yapılan çağrı felakete dönüşüyor; enjekte edilen DELETE sorgusu, MÜŞTERİLER tablosundaki tüm kayıtları kaldırır.

Neyse ki, MySQL kullanıyorsanız, mysql_query()işlevi, tek bir işlev çağrısında birden çok SQL sorgusunun yığınlanmasına veya yürütülmesine izin vermez. Sorguları yığmaya çalışırsanız, arama başarısız olur.

Ancak, diğer PHP veritabanı uzantıları, örneğin SQLite ve PostgreSQL mutlu bir şekilde yığılmış sorgular gerçekleştirin, tek bir dizede sağlanan tüm sorguları yürütün ve ciddi bir güvenlik sorunu yaratın.

SQL Enjeksiyonunu Önleme

PERL ve PHP gibi betik dillerinde tüm kaçış karakterlerini akıllıca işleyebilirsiniz. PHP için MySQL uzantısı şu işlevi sağlar:mysql_real_escape_string() MySQL'e özel giriş karakterlerinden çıkış yapmak için.

if (get_magic_quotes_gpc()) {
   $name = stripslashes($name); } $name = mysql_real_escape_string($name); mysql_query("SELECT * FROM CUSTOMERS WHERE name='{$name}'");

GİBİ İkilemi

LIKE sorgusunu ele almak için, özel bir kaçış mekanizmasının kullanıcı tarafından sağlanan '%' ve '_' karakterlerini değişmez değerlere dönüştürmesi gerekir. Kullanımaddcslashes(), kaçış için bir karakter aralığı belirlemenizi sağlayan bir işlev.

$sub = addcslashes(mysql_real_escape_string("%str"), "%_"); // $sub == \%str\_
mysql_query("SELECT * FROM messages 
   WHERE subject LIKE '{$sub}%'");

SQL - Veritabanı Ayarı

Veritabanı Uzmanı veya uzman Veritabanı Yöneticisi olmak zaman alır. Bunların tümü, çeşitli veritabanı tasarımlarında ve iyi eğitimlerde çok fazla deneyim ile birlikte gelir.

Ancak aşağıdaki liste, yeni başlayanlar için güzel bir veritabanı performansına sahip olmak için yardımcı olabilir -

Bu öğreticide RDBMS Kavramları bölümünde açıklanan 3BNF veritabanı tasarımını kullanın.
Sayılar ve karakterler farklı şekilde karşılaştırıldığı ve performans düşüşüne yol açtığı için sayıdan karaktere dönüşümlerden kaçının.
SELECT deyimini kullanırken, yalnızca gerekli bilgileri alın ve SELECT sorgularınızda * kullanmaktan kaçının çünkü bu, sistemi gereksiz yere yükleyecektir.
Sık arama işlemleri yaptığınız tüm tablolarda indekslerinizi dikkatlice oluşturun. Daha az sayıda arama işlemine ve daha fazla ekleme ve güncelleme işlemine sahip olduğunuz tablolarda indekslemekten kaçının.
WHERE yan tümcesindeki sütunların kendileriyle ilişkili bir dizini olmadığında tam tablo taraması gerçekleşir. Bir SQL ifadesinin WHERE yan tümcesinde koşullar olarak kullanılan sütunlarda bir dizin oluşturarak tam tablo taramasından kaçınabilirsiniz.
Gerçek sayılar ve tarih / saat değerleri olan eşitlik operatörlerine çok dikkat edin. Bunların her ikisinin de gözle görülemeyecek kadar küçük farklılıkları olabilir, ancak tam eşlemeyi imkansız kılar ve böylece sorgularınızın satırların geri gelmesini engeller.
Kalıp eşleştirmeyi mantıklı bir şekilde kullanın. LIKE COL% geçerli bir WHERE koşuludur ve döndürülen kümeyi yalnızca COL dizesiyle başlayan verilere sahip kayıtlara indirgemektedir. Bununla birlikte, COL% Y,% Y etkin bir şekilde değerlendirilemediği için döndürülen sonuçları daha fazla azaltmaz. Değerlendirmeyi yapma çabası, dikkate alınamayacak kadar büyük. Bu durumda COL% kullanılır, ancak% Y atılır. Aynı nedenle, önde gelen bir% COL joker karakteri, filtrenin tamamının kullanılmasını etkili bir şekilde engeller.
Tablolarınızı hızlı veri işlemeyi destekleyecek şekilde tasarlayıp tasarlamadığınızı ve sorguyu optimum şekilde yazıp yazmadığınızı keşfetmek için sorguların (ve alt sorguların) yapısını inceleyerek SQL sorgularınızı ince ayarlayın, böylece DBMS'nizin verileri verimli bir şekilde işlemesine izin verin .
Düzenli olarak yürütülen sorgular için prosedürleri kullanmayı deneyin. Prosedür, potansiyel olarak büyük bir SQL ifadeleri grubudur. Prosedürler, veritabanı motoru tarafından derlenir ve ardından yürütülür. Bir SQL ifadesinin aksine, veritabanı motorunun yürütülmeden önce prosedürü optimize etmesi gerekmez.
Mümkünse bir sorguda mantıksal işleci VEYA kullanmaktan kaçının. VEYA önemli boyuttaki bir tabloya karşı hemen hemen her sorguyu kaçınılmaz olarak yavaşlatır.
Dizinleri bırakarak toplu veri yüklemelerini optimize edebilirsiniz. Binlerce satır içeren geçmiş tablosunu hayal edin. Bu geçmiş tablosunun da bir veya daha fazla dizini olması muhtemeldir. Bir dizin düşündüğünüzde, normalde daha hızlı tablo erişimini düşünürsünüz, ancak toplu yüklemeler söz konusu olduğunda, dizin (ler) i düşürerek fayda sağlayabilirsiniz.
Toplu işlemleri gerçekleştirirken, her kayıt oluşturduktan sonra bunları oluşturmak yerine, makul sayıda kayıt oluşturduktan sonra COMMIT gerçekleştirin.
Haftalık bir rutin geliştirmek anlamına gelse bile, veritabanını düzenli olarak birleştirmeyi planlayın.

Yerleşik Ayarlama Araçları

Oracle, SQL deyimi performansını yönetmek için birçok araca sahiptir, ancak aralarında ikisi çok popülerdir. Bu iki araç -

Explain plan - araç, SQL deyimi yürütüldüğünde alınacak erişim yolunu tanımlar.
tkprof - SQL deyimi işlemenin her aşamasında geçen süreye göre performansı ölçer.

Oracle'da bir sorgunun geçen süresini basitçe ölçmek istiyorsanız, SQL * Plus SET TIMING ON komutunu kullanabilirsiniz.

Yukarıda belirtilen araçlar ve veritabanını birleştirmek hakkında daha fazla ayrıntı için RDBMS belgelerinize bakın.