# Veri Tabanı Yönetim Sistemleri

> ER modelinden ilişkisel modele, normalizasyondan SQL sorgularına, transaction yönetiminden indeks ve yetkilendirmeye kadar veri tabanı temellerini kapsayan ders notları.

- Author: Muhammet Ali Köker
- Language: tr
- Canonical: https://alikoker.com.tr/veri-tabani-yonetim-sistemleri
- Translation: https://alikoker.com.tr/en/database-management-systems
- Published: 2014-11-09T18:50:00+03:00
- Modified: 2026-07-24T20:35:00+03:00
- Verified: 2026-08-08T15:00:00+03:00
- Type: article

Veri tabanı ders notlarını önce kavramsal modelleme, ardından ilişkisel model ve SQL, son olarak bütünlük, transaction ve erişim denetimi sırasıyla tutmuştum. Bu sürüm aynı sıralamayı koruyor. Normalizasyon ve anahtar tanımlarındaki terminolojiyi özellikle yeniden denetledim; örneğin BCNF koşulunda belirleyicinin aday anahtar değil süper anahtar olması gerektiğini açık biçimde ayırdım.

## Ünite 1: Temel Kavramlar

### Klasik dosya yapıları

Bir veri tabanı yönetim sistemini anlamanın en kolay yolu, önce klasik dosya yaklaşımının sınırlarını görmektir. Dosya, kalıcı depolama ortamında tutulan veri topluluğudur. Bir dosyanın yapısı uygulamanın gereksinimine göre belirlenir. Muhasebe, stok, personel veya öğrenci işleri gibi farklı uygulamalar kendi dosyalarını oluşturabilir.

Klasik dosya yaklaşımında veri yapısı ile uygulama kodu genellikle sıkı biçimde bağlıdır. Kayıt biçimindeki bir değişiklik uygulamanın da değiştirilmesini gerektirebilir. Aynı veri farklı uygulamalarda tekrar tutulabilir. Bu durum veri tekrarı, tutarsızlık ve bakım maliyeti oluşturur.

### Kayıt ve alan

Dosya içindeki mantıksal veri birimine **kayıt** denir. Bir öğrenci, personel veya ürün hakkında tutulan bilgiler tek bir kayıt oluşturabilir.

Kayıt içindeki tekil veri öğelerine **alan** denir.

Örneğin bir öğrenci kaydı şu alanları içerebilir:

- öğrenci numarası,
- ad,
- soyad,
- doğum tarihi,
- bölüm.

Alanlar veri tabanı terminolojisinde daha sonra sütun veya nitelik kavramlarıyla karşılık bulur.

### Sıralı dosyalar

Sıralı dosyada kayıtlara belirli bir sıra içinde erişilir. Bütün kayıtların işleneceği uygulamalarda bu yaklaşım yeterli olabilir.

Örneğin bütün öğrencilerin dönem sonu listesini üretmek için kayıtların baştan sona okunması doğal bir işlemdir.

Buna karşılık yalnız tek bir öğrencinin kaydına erişmek gerektiğinde dosyanın tamamını taramak verimsizdir. Kayıt sayısı büyüdükçe erişim maliyeti de artar.

### İndeksli dosyalar

İndeksli dosya yapısında kayıtların konumunu gösteren ayrı bir indeks tutulur. Aranan anahtar önce indekste bulunur. Ardından ilgili kaydın konumuna erişilir.

Bir öğrenci dosyasında öğrenci numarası indeks alanı olarak kullanılabilir.

İndeksin temel amacı arama alanını küçültmektir. Bunun karşılığında indeks için ek depolama gerekir. Ekleme, silme ve güncelleme işlemlerinde indeksin de güncel tutulması gerekir.

Bu ödünleşim modern veri tabanlarındaki indeks mekanizmalarının da temelidir.

### Hesaba dayalı dosyalar

Hesaba dayalı dosyalarda bir anahtar değerden kayıt konumuna ulaşmak için bir **hash** fonksiyonu kullanılır.

Temel düşünce:

```text
anahtar -> hash fonksiyonu -> hedef konum
```

Uygun dağılım sağlandığında doğrudan erişim çok hızlı olabilir. Ancak farklı anahtarların aynı konuma düşmesi çakışma oluşturur. Bu nedenle hash tabanlı yapılarda çakışma yönetimi gerekir.

### Veri tabanı sistemleri

Veri tabanı, birbiriyle ilişkili verilerin belirli bir mantıksal model altında düzenlenmiş bütünüdür.

**Veri Tabanı Yönetim Sistemi, VTYS**, verinin:

- tanımlanmasını,
- saklanmasını,
- sorgulanmasını,
- değiştirilmesini,
- bütünlüğünün korunmasını,
- eşzamanlı kullanılmasını,
- yetkilendirilmesini

sağlayan yazılım sistemidir.

VTYS yaklaşımında uygulama, verinin fiziksel yerleşim ayrıntılarından mümkün olduğunca bağımsız çalışır. Bu özellik **veri bağımsızlığı** kavramının temelidir.

### Veri tabanı sistemlerinin üstünlükleri

Klasik dosya yaklaşımına göre temel üstünlükler şunlardır:

- veri tekrarının azaltılması,
- tutarlılığın korunması,
- ortak verinin birden fazla uygulama tarafından kullanılabilmesi,
- erişim denetimi,
- bütünlük kurallarının merkezi uygulanması,
- eşzamanlı kullanıcı desteği,
- yedekleme ve kurtarma,
- sorgulama dilinin sağladığı esneklik,
- uygulama ile fiziksel veri düzeninin ayrıştırılması.

Bir VTYS veri tekrarını tamamen ortadan kaldırmaz. Ama tekrarın denetimli olmasını ve tutarlılık kurallarıyla yönetilmesini sağlar.

### Veri modelleri

Veri modeli, verinin mantıksal olarak nasıl temsil edileceğini tanımlayan kavram, yapı ve işlemler bütünüdür.

Tarihsel olarak:

- hiyerarşik model,
- ağ modeli,
- ilişkisel model,
- nesne yönelimli yaklaşımlar

geliştirilmiştir.

Günümüzde genel amaçlı kurumsal veri tabanlarında ilişkisel model temel konumunu korur. Nesne, belge, anahtar-değer, grafik ve sütun ailesi gibi farklı modeller ise belirli iş yüklerinde ayrı çözümler sunar.

Bu dersin temel modeli **ilişkisel veri modeli**dir.

## Ünite 2: Varlık İlişki Modeli

### Varlık ilişki modeli

Varlık-İlişki modeli, veri tabanının doğrudan fiziksel tablolarını tanımlamak yerine problem alanındaki varlıkları, nitelikleri ve ilişkileri modellemek için kullanılır.

Model genellikle **ER - Entity Relationship** biçiminde anılır.

ER modeli veri tabanı tasarımının kavramsal aşamasında kullanılır. Model tamamlandıktan sonra ilişkisel şemaya dönüştürülebilir.

### Varlık

**Varlık**, diğer nesnelerden ayırt edilebilen gerçek veya kavramsal bir nesnedir.

Örnekler:

- öğrenci,
- ders,
- personel,
- bölüm,
- hesap,
- ürün.

Tek bir öğrenci bir varlık örneğidir. Öğrenci kavramının tüm örnekleri ise varlık kümesini oluşturur.

### Varlık kümesi

Aynı türdeki varlıkların oluşturduğu topluluğa **varlık kümesi** denir.

Örneğin:

```text
OGRENCI = {O1, O2, O3, ...}
DERS    = {D1, D2, D3, ...}
```

Varlık kümesi veri tabanındaki tablo kavramıyla yakından ilişkilidir ancak kavramsal model ile fiziksel tablo aynı şey değildir.

### İlişki ve ilişki kümesi

Varlıklar arasındaki anlamlı bağlantıya **ilişki** denir.

Örneğin:

```text
OGRENCI -- ALIR --> DERS
```

Bir öğrencinin bir dersi alması tek bir ilişki örneğidir. Aynı türdeki bütün ilişkilerin toplamı ilişki kümesini oluşturur.

Matematiksel olarak iki varlık kümesi arasındaki ilişki, bu kümelerin Kartezyen çarpımının bir alt kümesi olarak düşünülebilir.

### Nitelikler

Bir varlığı tanımlayan özelliklere **nitelik** denir.

Bir personel için:

- personel numarası,
- ad,
- soyad,
- doğum tarihi,
- ücret

birer niteliktir.

İlişkisel modele geçildiğinde nitelikler çoğunlukla sütunlara karşılık gelir.

### Etki alanı

Bir niteliğin alabileceği geçerli değerler kümesine **domain**, yani etki alanı denir.

Örneğin bir not alanının etki alanı 0 ile 100 arasındaki tamsayılar olabilir.

Etki alanı yalnız veri tipini değil, kavramsal olarak geçerli değerler kümesini ifade eder.

### Türetilen nitelikler

Başka niteliklerden hesaplanabilen niteliğe **türetilen nitelik** denir.

Örneğin yaş bilgisi doğum tarihinden hesaplanabilir.

```text
yas = bugunun_tarihi - dogum_tarihi
```

Türetilen verinin ayrıca saklanması gerekmez. Saklanırsa kaynak değer değiştiğinde tutarlılığın korunması gerekir.

### Çok değerli nitelikler

Bir varlık için birden fazla değer alabilen nitelik **çok değerli nitelik**tir.

Örneğin bir kişinin birden fazla telefon numarası olabilir.

İlişkisel tasarımda çok değerli nitelikler çoğunlukla ayrı tabloya dönüştürülür.

```text
KISI
----
kisi_id
ad

KISI_TELEFON
------------
kisi_id
telefon
```

### Birleşik nitelikler

Alt niteliklerden oluşan özelliklere **birleşik nitelik** denir.

Örneğin adres:

- ülke,
- şehir,
- ilçe,
- mahalle,
- açık adres

bileşenlerine ayrılabilir.

Birleşik niteliğin nasıl saklanacağı sorgulama ve bütünlük gereksinimlerine göre belirlenir.

### Rol

Aynı varlık kümesinin bir ilişki içinde farklı görevler üstlenmesi durumunda rol kavramı kullanılır.

Örneğin PERSONEL kümesindeki bir kişi yönetici, başka bir kişi çalışan rolünde olabilir.

```text
PERSONEL -- YONETIR --> PERSONEL
```

Burada aynı varlık kümesi ilişkinin iki tarafında farklı rollerle bulunur.

### Varlıkların eşlendirilmesi

İki varlık kümesi arasındaki ilişkinin kardinalitesi temel olarak dört biçimde ele alınır.

### Birden bire ilişki

Bir A varlığı en fazla bir B varlığıyla, bir B varlığı da en fazla bir A varlığıyla ilişkilidir.

```text
A 1 ----- 1 B
```

### Birden çoğa ilişki

Bir A varlığı birden fazla B varlığıyla ilişkili olabilir. Her B varlığı en fazla bir A varlığına bağlıdır.

```text
BOLUM 1 ----- N PERSONEL
```

İlişkisel tasarımda yabancı anahtar çoğunlukla N tarafında bulunur.

### Çoktan bire ilişki

Birden çoğa ilişkinin ters yönden görünümüdür.

```text
PERSONEL N ----- 1 BOLUM
```

### Çoktan çoğa ilişki

Bir A varlığı birden fazla B varlığıyla, bir B varlığı da birden fazla A varlığıyla ilişkili olabilir.

```text
OGRENCI N ----- N DERS
```

İlişkisel modele dönüşümde ara tablo gerekir.

```text
OGRENCI_DERS
------------
ogrenci_id
ders_id
```

### Varoluş koşulu

Bir varlığın başka bir varlığın varlığına bağlı olup olmadığı tasarım açısından önemlidir.

Bir alt varlık üst varlık olmadan anlamlı değilse **varoluş bağımlılığı** söz konusudur.

Bu durum yabancı anahtarların `NOT NULL`, silme davranışları ve zayıf varlık tasarımı üzerinde etkili olabilir.

### Anahtarlar

Anahtar, bir varlığı diğerlerinden ayırt etmeye yarayan nitelik veya nitelikler kümesidir.

### Süper anahtar

Bir kaydı benzersiz belirleyen herhangi bir nitelik kümesine **süper anahtar** denir.

Gereksiz nitelikler içerebilir.

```text
{ogrenci_no}
{ogrenci_no, ad}
{ogrenci_no, ad, dogum_tarihi}
```

Öğrenci numarası tek başına benzersizse üçü de süper anahtar olabilir.

### Aday anahtar

İçinden herhangi bir nitelik çıkarıldığında benzersizlik özelliğini kaybeden minimal süper anahtar **aday anahtar**dır.

Bir tabloda birden fazla aday anahtar bulunabilir.

Bunlardan biri birincil anahtar olarak seçilir.

### Zayıf ve kuvvetli varlıklar

Kendi nitelikleriyle benzersiz biçimde tanımlanabilen varlık **kuvvetli varlık**tır.

Kimliği başka bir varlığın anahtarına bağımlı olan varlık **zayıf varlık** olarak ele alınabilir.

Örneğin sipariş satırı:

```text
SIPARIS(siparis_id, ...)
SIPARIS_SATIR(siparis_id, satir_no, ...)
```

yapısında `satir_no` yalnız sipariş kapsamında anlamlı olabilir.

### ER şemaları

ER şeması varlıkları, nitelikleri, anahtarları, ilişkileri ve kardinaliteleri görsel biçimde ifade eder.

Şema hazırlanırken önce problem alanının kuralları belirlenmelidir. Diyagram, bu kuralların görsel sonucudur.

### ER modelinin tablolara dönüştürülmesi

Genel dönüşüm ilkeleri şöyledir:

- kuvvetli varlık -> tablo,
- basit nitelik -> sütun,
- birincil anahtar -> PRIMARY KEY,
- 1:N ilişki -> N tarafına FOREIGN KEY,
- N:N ilişki -> ara tablo,
- çok değerli nitelik -> ayrı tablo,
- zayıf varlık -> sahibinin anahtarını içeren tablo.

Dönüşüm yalnız mekanik bir işlem değildir. Bütünlük kuralları da tablo tasarımına aktarılmalıdır.

## Ünite 3: İlişkisel Veri Modeli

### İlişkisel model

İlişkisel model veriyi ilişkiler biçiminde ele alır. Uygulamada bir ilişki çoğunlukla tablo biçiminde gösterilir.

Bir ilişkinin:

- satırları tuple,
- sütunları attribute,
- sütun değer kümeleri domain

kavramlarına karşılık gelir.

İlişkisel modelin önemli özelliği verinin fiziksel yerleşiminden çok mantıksal yapısını temel almasıdır.

### İlişkisel veri tabanı

Birbiriyle ilişkili tablolardan oluşan veri tabanına ilişkisel veri tabanı denir.

Örnek:

```text
BOLUM(
    bolum_no,
    bolum_adi
)

PERSONEL(
    personel_no,
    ad,
    ucret,
    bolum_no
)
```

`PERSONEL.bolum_no`, `BOLUM.bolum_no` değerine başvurarak iki tablo arasında ilişki kurabilir.

### Tabloların özellikleri

Kuramsal ilişkisel modelde:

- her satır aynı nitelik kümesine sahiptir,
- her hücre ilgili domain'den bir değer taşır,
- satır sırası anlam taşımaz,
- sütun sırası ilişkisel anlamın parçası değildir,
- yinelenen tuple'lar ilişki kavramında yer almaz.

SQL tabloları kuramsal ilişkiden bazı yönleriyle ayrılır. Örneğin `SELECT` sonucu `DISTINCT` kullanılmadıkça yinelenen satırlar içerebilir. Bu nedenle ilişkisel model ile SQL'in pratik davranışı aynı kavram olarak görülmemelidir.

### Veri tabanı şeması

Şema, veri tabanının yapısal tanımıdır.

Tablo adları, sütunlar, veri tipleri, anahtarlar, sınırlamalar ve ilişkiler şemanın parçalarıdır.

Verinin kendisi değişebilir. Şema ise verinin hangi kurallara göre tutulacağını tanımlar.

### Veri tabanı bütünlüğü

Bütünlük, veri tabanındaki verilerin tanımlanan kurallara uygun kalmasıdır.

Başlıca bütünlük alanları:

- anahtar bütünlüğü,
- varlık bütünlüğü,
- başvuru bütünlüğü,
- domain sınırlamaları,
- işletme kurallarıdır.

### Birincil anahtar

`PRIMARY KEY`, her satırı benzersiz tanımlar.

Birincil anahtar:

- benzersiz olmalıdır,
- `NULL` olmamalıdır.

Örnek:

```sql
CREATE TABLE BOLUM (
    BOLUM_NO NUMBER PRIMARY KEY,
    BOLUM_ADI VARCHAR2(100) NOT NULL
);
```

### Dış anahtar

`FOREIGN KEY`, bir tablodaki değerin başka bir tablodaki aday veya birincil anahtarla ilişkilendirilmesini sağlar.

```sql
CREATE TABLE PERSONEL (
    PERSONEL_NO NUMBER PRIMARY KEY,
    AD VARCHAR2(100),
    BOLUM_NO NUMBER,
    CONSTRAINT FK_PERSONEL_BOLUM
        FOREIGN KEY (BOLUM_NO)
        REFERENCES BOLUM(BOLUM_NO)
);
```

Bu yapı başvuru bütünlüğünü sağlar.

### Veri değeri sınırlamaları

Bir sütunun kabul edeceği değerler:

- veri tipi,
- `NOT NULL`,
- `CHECK`,
- `UNIQUE`,
- uygulama kuralları

ile sınırlandırılabilir.

```sql
UCRET NUMBER CHECK (UCRET >= 0)
```

### İşletme kuralları

Her bütünlük kuralı yalnız veri tipinden çıkarılamaz.

Örneğin:

- bir öğrencinin dönem başına en fazla belirli sayıda ders alabilmesi,
- bir hesabın kapanması için bakiyesinin sıfır olması,
- belirli görevlerin yalnız belirli bölümlerde tanımlanabilmesi

işletme kurallarıdır.

Bu kurallar mümkün olduğunca uygun veri tabanı sınırlamaları ve uygulama mantığıyla birlikte ele alınmalıdır.

### Nitelikler arası bağımlılıklar

Bir niteliğin başka bir niteliği belirlemesi veri tasarımının temel konularındandır.

```text
personel_no -> ad, soyad, bolum_no
```

Bu ifade aynı `personel_no` değerinin tek bir personel bilgisini belirlediğini söyler.

Fonksiyonel bağımlılıklar normalleştirmenin temelidir.

## Ünite 4: İlişkisel Veri Tabanı Tasarımı

### Normalleştirme

Normalleştirme, ilişkisel şemaları veri tekrarı ve güncelleme anomalilerini azaltacak biçimde düzenleme sürecidir.

Amaç bütün veriyi mümkün olan en fazla sayıda tabloya bölmek değildir. Amaç fonksiyonel ve çok değerli bağımlılıkları doğru temsil eden, kayıpsız ve anlamlı bir şema oluşturmaktır.

Kötü tasarım üç temel anomali üretir:

- ekleme anomalisi,
- silme anomalisi,
- güncelleme anomalisi.

### Fonksiyonel bağımlılık

Bir R ilişkisinde X niteliği veya nitelik kümesi Y'yi tekil biçimde belirliyorsa:

```text
X -> Y
```

fonksiyonel bağımlılığı vardır.

Örneğin:

```text
personel_no -> ad
personel_no -> bolum_no
```

Aynı personel numarası iki farklı ad veya bölüm bilgisine karşılık gelmemelidir.

### Tam ve kısmi bağımlılık

Bir birleşik anahtarın tamamına bağlı olan nitelik **tam fonksiyonel bağımlıdır**.

Nitelik birleşik anahtarın yalnız bir bölümüne bağlıysa **kısmi bağımlılık** vardır.

Örneğin:

```text
KAYIT(ogrenci_no, ders_no, ogrenci_adi, not)
```

anahtar `(ogrenci_no, ders_no)` ise:

```text
ogrenci_no -> ogrenci_adi
(ogrenci_no, ders_no) -> not
```

`ogrenci_adi` birleşik anahtarın yalnız bir parçasına bağlıdır.

### Birinci normal form

Bir ilişki 1NF'de ise her sütun konumunda tek bir değer bulunur. Tek hücre içinde tekrarlayan grup veya çoklu değer listesi tutulmaz.

Uygun olmayan:

```text
OGRENCI
ogrenci_no | telefonlar
1          | 555..., 532...
```

Daha uygun:

```text
OGRENCI(ogrenci_no, ...)
OGRENCI_TELEFON(ogrenci_no, telefon)
```

### Birinci normal formun sorunları

1NF atomik değer sorununu çözer ancak fonksiyonel bağımlılık sorunlarını tek başına çözmez.

Tekrarlanan bölüm adı, personel bilgisi veya ders bilgisi güncelleme anomalilerine yol açabilir.

### İkinci normal form

Bir ilişki 2NF'de olabilmek için:

1. 1NF'de olmalıdır.
2. Anahtar olmayan her nitelik, her aday anahtarın tamamına bağımlı olmalıdır.

2NF özellikle birleşik anahtarlardaki kısmi bağımlılıkları ortadan kaldırır.

### İkinci normal formun sorunları

2NF'ye ulaşıldığında kısmi bağımlılıklar giderilir. Ancak anahtar olmayan nitelikler arasında geçişli bağımlılıklar kalabilir.

Örneğin:

```text
PERSONEL(
    personel_no,
    bolum_no,
    bolum_adi
)
```

```text
personel_no -> bolum_no
bolum_no -> bolum_adi
```

Burada `bolum_adi`, `personel_no` üzerinden geçişli biçimde belirlenir.

### Üçüncü normal form

Bir ilişki 3NF'de olduğunda anahtar olmayan niteliklerin anahtara uygunsuz geçişli bağımlılıkları giderilmiştir.

Yukarıdaki örnek:

```text
PERSONEL(personel_no, bolum_no)
BOLUM(bolum_no, bolum_adi)
```

biçiminde ayrılabilir.

### Boyce-Codd normal formu

BCNF, 3NF'den daha güçlü bir koşuldur.

Her anlamlı fonksiyonel bağımlılıkta belirleyici tarafın bir süper anahtar olması beklenir.

Kısaca:

```text
X -> Y
```

trivial olmayan bir bağımlılıksa `X` bir süper anahtar olmalıdır.

BCNF özellikle birden fazla örtüşen aday anahtarın bulunduğu yapılarda 3NF'nin bıraktığı bazı anomalileri giderir.

### Dördüncü normal form

4NF çok değerli bağımlılıklarla ilgilidir.

Bir varlığa ait birbirinden bağımsız iki çok değerli bilgi aynı tabloda tutulduğunda gereksiz Kartezyen tekrar oluşabilir.

Örneğin bir öğretim üyesinin:

- uzmanlık alanları,
- konuştuğu yabancı diller

birbirinden bağımsız çok değerli bilgilerse ayrı ilişkilerde tutulmaları daha uygundur.

### Beşinci normal form

5NF bir tablonun daha küçük ilişkilere ayrılıp tekrar birleştirilmesiyle oluşan **join dependency** problemleriyle ilgilidir.

Pratik uygulamalarda 1NF, 2NF, 3NF ve BCNF daha sık karşılaşılan konulardır. 4NF ve 5NF daha özel bağımlılık yapılarını ele alır.

### Normalleştirme ve performans

Normalleştirme veri bütünlüğü için temel bir tasarım aracıdır. Ancak bazı okuma ağırlıklı sistemlerde bilinçli **denormalizasyon** uygulanabilir.

Denormalizasyon ancak:

- tekrarın maliyeti biliniyorsa,
- tutarlılık mekanizması tanımlıysa,
- ölçülmüş performans ihtiyacı varsa

yapılmalıdır.

Önce doğru model, sonra ölçüme dayalı optimizasyon yaklaşımı daha güvenlidir.

## Ünite 5: İlişkisel Cebir

### İlişkisel cebir kavramı

İlişkisel cebir, ilişkiler üzerinde çalışan ve sonuç olarak yine ilişki üreten işlemler bütünüdür.

SQL'in kuramsal temelini anlamak için önemlidir.

Temel işlemler:

- seçim,
- izdüşüm,
- Kartezyen çarpım,
- birleşim,
- kesişim,
- fark,
- doğal birleştirme,
- bölmedir.

### Seçim

Seçim, belirli koşulu sağlayan satırları elde eder.

```text
sigma kosul (R)
```

SQL karşılığı çoğunlukla `WHERE` koşuludur.

```sql
SELECT *
FROM PERSONEL
WHERE UCRET > 50000;
```

### İzdüşüm

Ders notlarında atma işlemi olarak ifade edilen işlem, ilişkisel cebirde **projection**, yani izdüşümdür.

Belirli sütunları seçer.

```sql
SELECT AD, UCRET
FROM PERSONEL;
```

### Kartezyen çarpım

İki ilişkinin bütün satır kombinasyonlarını üretir.

R ilişkisi `m`, S ilişkisi `n` satır içeriyorsa:

```text
|R x S| = m * n
```

olabilir.

Birleştirme koşulu unutulduğunda istenmeyen büyük ara sonuçlar üretilebilir.

### Birleşim

İki uyumlu ilişkinin satırlarını tek sonuçta toplar.

SQL'de:

```sql
SELECT ...
FROM A
UNION
SELECT ...
FROM B;
```

`UNION` tekrarları kaldırır. `UNION ALL` tekrarları korur.

### Kesişim

Her iki ilişkide de bulunan satırları üretir.

Oracle SQL'de `INTERSECT` kullanılır.

### Fark

Birinci ilişkide bulunup ikinci ilişkide bulunmayan satırları üretir.

Oracle SQL'de geleneksel olarak `MINUS` işleci kullanılır.

### Doğal birleştirme

Doğal birleştirme aynı ad ve uyumlu anlamdaki sütunlar üzerinden ilişkileri birleştirir.

Pratik SQL'de birleştirme koşulunun açık yazılması çoğu zaman daha okunabilir ve daha güvenlidir.

```sql
SELECT P.AD, B.BOLUM_ADI
FROM PERSONEL P
JOIN BOLUM B
  ON B.BOLUM_NO = P.BOLUM_NO;
```

### Bölme

Bölme, "tümüne sahip olanları bul" tipindeki sorguları modellemek için kullanılır.

Örneğin tüm zorunlu dersleri alan öğrencileri bulma problemi bölme düşüncesiyle ifade edilebilir.

SQL'de doğrudan `DIVIDE` işleci bulunmaz. Problem genellikle `NOT EXISTS`, gruplama veya alt sorgularla çözülür.

## Ünite 6: SQL Yapısal Sorgulama Dili

### SQL'in rolü

SQL ilişkisel veri tabanlarında:

- veri tanımlama,
- veri sorgulama,
- veri değiştirme,
- yetkilendirme,
- işlem yönetimi

amaçlarıyla kullanılır.

SQL bildirimseldir. Kullanıcı çoğunlukla **hangi sonucu** istediğini belirtir. Sonucun fiziksel olarak nasıl elde edileceğine sorgu eniyileyicisi karar verir.

### SELECT deyiminin yapısı

Temel yapı:

```sql
SELECT [DISTINCT] sutunlar
FROM tablo
WHERE kosul
ORDER BY sutunlar;
```

Bütün sütunları seçmek için:

```sql
SELECT *
FROM PERSONEL;
```

Belirli sütunları seçmek için:

```sql
SELECT PERSONEL_NO, AD, UCRET
FROM PERSONEL;
```

### SELECT yazım kuralları

SQL anahtar sözcükleri çoğu sistemde büyük-küçük harfe duyarlı değildir. Ancak karakter verileri, tırnaklı tanımlayıcılar ve karşılaştırmalar sistem ayarlarına bağlı olarak farklı davranabilir.

Okunabilir sorgularda her ana bölümün ayrı satıra yazılması yararlıdır:

```sql
SELECT PERSONEL_NO, AD, UCRET
FROM PERSONEL
WHERE BOLUM_NO = 20
ORDER BY AD;
```

### Aritmetik ifadeler

Sayısal sütunlar sorgu içinde hesaplamalarda kullanılabilir.

```sql
SELECT AD, UCRET * 12 AS YILLIK_UCRET
FROM PERSONEL;
```

### İşlem sırası

Aritmetik ifadelerde matematiksel öncelik kuralları geçerlidir.

```text
* ve /
+ ve -
```

Parantezler değerlendirme sırasını açık hale getirir.

```sql
SELECT 12 * (UCRET + 500)
FROM PERSONEL;
```

### NULL değeri

`NULL`:

- sıfır değildir,
- boş metin kavramıyla genel olarak aynı değildir,
- bilinmeyen veya mevcut olmayan değeri temsil eder.

Bir aritmetik işlem `NULL` içerirse sonuç çoğunlukla `NULL` olur.

```sql
SELECT UCRET + KOMISYON
FROM PERSONEL;
```

`KOMISYON` `NULL` ise sonuç da `NULL` olabilir.

Oracle'da `NVL` ile alternatif değer verilebilir:

```sql
SELECT UCRET + NVL(KOMISYON, 0)
FROM PERSONEL;
```

### Sütun takma adları

Sorgu sonucu için sütun adı değiştirilebilir.

```sql
SELECT UCRET * 12 AS YILLIK_UCRET
FROM PERSONEL;
```

Takma ad sonuç kümesinin okunabilirliğini artırır.

### Sütun içeriklerini birleştirme

Oracle SQL'de karakter birleştirme için `||` kullanılabilir.

```sql
SELECT AD || ' ' || SOYAD AS AD_SOYAD
FROM PERSONEL;
```

### Yinelenen satırlar

`DISTINCT`, aynı sonucu veren tekrar satırlarını kaldırır.

```sql
SELECT DISTINCT BOLUM_NO
FROM PERSONEL;
```

`DISTINCT` gereksiz kullanılırsa ek sıralama veya hash maliyeti oluşturabilir. Yalnız semantik olarak gerekiyorsa kullanılmalıdır.

### Verinin sınırlandırılması

`WHERE`, sonuç kümesine alınacak satırları belirler.

```sql
SELECT *
FROM PERSONEL
WHERE UCRET > 50000;
```

### Karşılaştırma işleçleri

Temel karşılaştırmalar:

```text
=
<>
>
<
>=
<=
```

Oracle SQL'de `!=` de eşit olmama amacıyla kullanılabilir.

### BETWEEN

Aralık denetimi:

```sql
SELECT *
FROM PERSONEL
WHERE UCRET BETWEEN 40000 AND 60000;
```

Sınırlar dahildir.

### IN

Bir değerin belirli kümedeki değerlerden biri olup olmadığını denetler.

```sql
SELECT *
FROM PERSONEL
WHERE BOLUM_NO IN (10, 20, 30);
```

### LIKE

Metinsel örüntü araması için kullanılır.

```sql
SELECT *
FROM PERSONEL
WHERE AD LIKE 'A%';
```

Yaygın jokerler:

- `%`: sıfır veya daha fazla karakter,
- `_`: tek karakter.

### IS NULL

`NULL` değeri `=` ile sınanmaz.

Yanlış:

```sql
WHERE KOMISYON = NULL
```

Doğru:

```sql
WHERE KOMISYON IS NULL
```

veya:

```sql
WHERE KOMISYON IS NOT NULL
```

### Mantıksal işleçler

Koşullar:

- `AND`,
- `OR`,
- `NOT`

ile birleştirilebilir.

```sql
SELECT *
FROM PERSONEL
WHERE BOLUM_NO = 20
  AND UCRET > 50000;
```

Karmaşık ifadelerde parantez kullanmak mantıksal önceliği açık hale getirir.

### Sıralama

`ORDER BY` sonuç kümesinin sırasını belirler.

```sql
SELECT AD, UCRET
FROM PERSONEL
ORDER BY UCRET DESC, AD ASC;
```

İlişkisel modelde satırların doğal sırası yoktur. Belirli sıra gerekiyorsa `ORDER BY` açıkça kullanılmalıdır.

## Ünite 7: SQL Fonksiyonları

### Fonksiyon kavramı

Fonksiyon, girdiler üzerinde işlem yapıp değer üreten yapıdır.

SQL fonksiyonları:

- tek satır fonksiyonları,
- grup fonksiyonları

olarak ele alınabilir.

### Karakter fonksiyonları

#### LOWER ve UPPER

```sql
SELECT LOWER(AD), UPPER(SOYAD)
FROM PERSONEL;
```

Büyük-küçük harf dönüşümü yapar.

#### LENGTH

Metnin karakter uzunluğunu verir.

```sql
SELECT AD, LENGTH(AD)
FROM PERSONEL;
```

### Sayısal fonksiyonlar

#### ROUND

Sayıyı belirtilen basamağa yuvarlar.

```sql
SELECT ROUND(123.456, 2)
FROM DUAL;
```

#### TRUNC

Oracle'da sayının belirli basamaktan sonrasını kesmek için kullanılabilir.

```sql
SELECT TRUNC(123.456, 2)
FROM DUAL;
```

#### MOD

Kalan hesaplar.

```sql
SELECT MOD(10, 3)
FROM DUAL;
```

### Tarih fonksiyonları

Oracle tarih işlemlerinde çeşitli fonksiyonlar sağlar.

`SYSDATE`, veri tabanı sunucusunun tarih ve zaman bilgisini verir.

```sql
SELECT SYSDATE
FROM DUAL;
```

İki tarih arasındaki ay farkı:

```sql
SELECT MONTHS_BETWEEN(SYSDATE, GIRIS_TARIHI)
FROM PERSONEL;
```

Tarihe ay eklemek:

```sql
SELECT ADD_MONTHS(GIRIS_TARIHI, 6)
FROM PERSONEL;
```

Ayın son günü:

```sql
SELECT LAST_DAY(GIRIS_TARIHI)
FROM PERSONEL;
```

### Dönüştürme fonksiyonları

#### TO_CHAR

Sayı veya tarih değerini metne dönüştürür.

```sql
SELECT TO_CHAR(GIRIS_TARIHI, 'YYYY-MM')
FROM PERSONEL;
```

#### TO_NUMBER

Metinsel sayıyı sayısal değere dönüştürür.

```sql
SELECT TO_NUMBER('1250')
FROM DUAL;
```

#### TO_DATE

Metni tarih değerine dönüştürür.

```sql
SELECT TO_DATE('2014-11-09', 'YYYY-MM-DD')
FROM DUAL;
```

Tarih dönüşümlerinde örtük dönüşüme güvenmek yerine formatın açık belirtilmesi daha güvenlidir.

### Genel fonksiyonlar

#### NVL

Oracle'a özgü `NVL`, `NULL` değer yerine alternatif değer döndürür.

```sql
SELECT NVL(KOMISYON, 0)
FROM PERSONEL;
```

#### DECODE

`DECODE`, Oracle'a özgü koşullu dönüştürme fonksiyonudur.

```sql
SELECT DECODE(BOLUM_NO,
              10, 'YONETIM',
              20, 'TEKNIK',
              'DIGER')
FROM PERSONEL;
```

Yeni kodlarda standart SQL'e daha yakın olan `CASE` ifadesi çoğu durumda daha okunabilir bir alternatiftir.

### İç içe fonksiyonlar

Fonksiyonların çıktısı başka fonksiyonların girdisi olabilir.

```sql
SELECT UPPER(TRIM(AD))
FROM PERSONEL;
```

İç fonksiyon önce değerlendirilir.

## Ünite 8: Verileri Gruplayarak Analiz Etmek

### Grup fonksiyonları

Grup fonksiyonları birden fazla satırı tek bir özet değere dönüştürür.

Başlıca fonksiyonlar:

- `AVG`,
- `SUM`,
- `STDDEV`,
- `VARIANCE`,
- `MAX`,
- `MIN`,
- `COUNT`.

### AVG

```sql
SELECT AVG(UCRET)
FROM PERSONEL;
```

Ortalama değeri üretir.

### SUM

```sql
SELECT SUM(UCRET)
FROM PERSONEL;
```

Toplamı üretir.

### STDDEV ve VARIANCE

Dağılımın ölçülmesinde standart sapma ve varyans hesaplanabilir.

```sql
SELECT STDDEV(UCRET), VARIANCE(UCRET)
FROM PERSONEL;
```

### MAX ve MIN

```sql
SELECT MAX(UCRET), MIN(UCRET)
FROM PERSONEL;
```

En büyük ve en küçük değerleri verir.

### COUNT

```sql
SELECT COUNT(*)
FROM PERSONEL;
```

Satır sayısını verir.

```sql
SELECT COUNT(KOMISYON)
FROM PERSONEL;
```

yalnız `KOMISYON` değeri `NULL` olmayan satırları sayar.

### GROUP BY

Verileri belirli sütunlara göre gruplar.

```sql
SELECT BOLUM_NO, AVG(UCRET)
FROM PERSONEL
GROUP BY BOLUM_NO;
```

Gruplama yapılmış bir sorguda seçilen normal sütunlar genellikle `GROUP BY` içinde bulunmalıdır.

### Birden fazla sütuna göre gruplama

```sql
SELECT BOLUM_NO, GOREV, AVG(UCRET)
FROM PERSONEL
GROUP BY BOLUM_NO, GOREV;
```

Her farklı `(BOLUM_NO, GOREV)` birleşimi ayrı grup oluşturur.

### HAVING

`WHERE` satırları gruplamadan önce süzer.

`HAVING` gruplar oluştuktan sonra grup sonuçlarını süzer.

```sql
SELECT BOLUM_NO, AVG(UCRET)
FROM PERSONEL
GROUP BY BOLUM_NO
HAVING AVG(UCRET) > 50000;
```

## Ünite 9: Çoklu Tablolar

### Çoklu tabloların kullanımı

Veri normalleştirildiğinde bilgi birden fazla tabloya dağılır. Sorgu sırasında bu tablolar yeniden ilişkilendirilir.

### Tabloların birleştirilmesi

Modern SQL'de açık `JOIN` sözdizimi tercih edilir.

```sql
SELECT P.AD, B.BOLUM_ADI
FROM PERSONEL P
JOIN BOLUM B
  ON B.BOLUM_NO = P.BOLUM_NO;
```

### Kartezyen çarpım

Birleştirme koşulu olmadan iki tablonun bütün satır kombinasyonları üretilebilir.

```sql
SELECT *
FROM PERSONEL
CROSS JOIN BOLUM;
```

Çoğu iş sorgusunda bu sonuç istenmez.

### Eşiti olan birleştirme

Birleştirme koşulunda eşitlik kullanılır.

```sql
ON P.BOLUM_NO = B.BOLUM_NO
```

En yaygın join türüdür.

### Sütun isimlerindeki belirsizlik

İki tabloda aynı isimli sütun bulunuyorsa tablo adı veya takma adı kullanılmalıdır.

```sql
SELECT P.BOLUM_NO, B.BOLUM_ADI
FROM PERSONEL P
JOIN BOLUM B
  ON B.BOLUM_NO = P.BOLUM_NO;
```

### Tablo takma adları

Takma ad sorguyu kısaltır ve özellikle self join gibi yapılarda zorunlu hale gelebilir.

```sql
PERSONEL P
BOLUM B
```

### Eşiti olmayan birleştirme

Birleştirme koşulu yalnız eşitlik olmak zorunda değildir.

Örneğin ücretin belirli aralığa düştüğü ücret sınıfını bulmak için aralık karşılaştırması yapılabilir.

### Dış birleştirme

`INNER JOIN` yalnız eşleşen satırları döndürür.

Dış birleştirmeler eşleşmeyen tarafı da sonuçta tutabilir:

- `LEFT OUTER JOIN`,
- `RIGHT OUTER JOIN`,
- `FULL OUTER JOIN`.

```sql
SELECT B.BOLUM_ADI, P.AD
FROM BOLUM B
LEFT JOIN PERSONEL P
  ON P.BOLUM_NO = B.BOLUM_NO;
```

Personeli olmayan bölümler de listelenir.

### Kendine birleştirme

Bir tablo kendisiyle birleştirilebilir.

Örneğin personel-yönetici ilişkisi:

```sql
SELECT P.AD AS PERSONEL,
       Y.AD AS YONETICI
FROM PERSONEL P
LEFT JOIN PERSONEL Y
  ON Y.PERSONEL_NO = P.YONETICI_NO;
```

### UNION ve UNION ALL

`UNION` iki sorgu sonucunu birleştirir ve tekrarları kaldırır.

`UNION ALL` tekrarları korur.

Sorguların sütun sayıları ve karşılık gelen veri tipleri uyumlu olmalıdır.

### INTERSECT

İki sorguda ortak olan sonuçları döndürür.

### MINUS

Oracle SQL'de ilk sorguda olup ikinci sorguda olmayan satırları döndürür.

## Ünite 10: Karmaşık Sorgular

### Alt sorgu kavramı

Başka bir SQL deyimi içinde kullanılan sorguya **alt sorgu** denir.

```sql
SELECT AD, UCRET
FROM PERSONEL
WHERE UCRET > (
    SELECT UCRET
    FROM PERSONEL
    WHERE PERSONEL_NO = 110
);
```

İç sorgunun sonucu dış sorgunun koşulunda kullanılır.

### Alt sorgu düzenleme kuralları

Alt sorgunun döndürdüğü satır ve sütun sayısı, dış sorgunun kullandığı işleçle uyumlu olmalıdır.

Tek değer bekleyen:

```text
=
>
<
>=
<=
```

gibi işleçlerin karşısında alt sorgunun birden fazla satır üretmesi hata oluşturur.

### Tek satır alt sorguları

Tek satır alt sorgusu en fazla bir satır döndürür.

```sql
WHERE UCRET > (
    SELECT AVG(UCRET)
    FROM PERSONEL
)
```

Grup fonksiyonu `GROUP BY` olmadan tek satır üretebilir.

### Grup fonksiyonlarının kullanımı

Alt sorgular özet değer üretmek için kullanılabilir.

```sql
SELECT AD, UCRET
FROM PERSONEL
WHERE UCRET > (
    SELECT AVG(UCRET)
    FROM PERSONEL
);
```

### HAVING ile alt sorgu

Gruplar başka bir sorgudan elde edilen değerle karşılaştırılabilir.

```sql
SELECT BOLUM_NO, MIN(UCRET)
FROM PERSONEL
GROUP BY BOLUM_NO
HAVING MIN(UCRET) > (
    SELECT MIN(UCRET)
    FROM PERSONEL
    WHERE BOLUM_NO = 20
);
```

### Çok satırlı alt sorgular

Birden fazla satır döndüren alt sorgularda uygun işleç kullanılmalıdır.

### IN

```sql
WHERE BOLUM_NO IN (
    SELECT BOLUM_NO
    FROM BOLUM
    WHERE KONUM = 'ANKARA'
)
```

### ANY

Koşulun alt sorgudan dönen değerlerden en az biriyle sağlanması yeterlidir.

```sql
UCRET > ANY (...)
```

### ALL

Koşulun alt sorgudan dönen bütün değerler için sağlanması gerekir.

```sql
UCRET > ALL (...)
```

### Çok sütunlu alt sorgular

Birden fazla sütun birlikte karşılaştırılabilir.

```sql
SELECT AD, GOREV, UCRET
FROM PERSONEL
WHERE (GOREV, UCRET) IN (
    SELECT GOREV, UCRET
    FROM PERSONEL
    WHERE AD = 'SEZIN'
);
```

### FROM içinde alt sorgu

Alt sorgu geçici ilişkisel sonuç olarak `FROM` bölümünde kullanılabilir.

```sql
SELECT X.BOLUM_NO, X.ORT_UCRET
FROM (
    SELECT BOLUM_NO, AVG(UCRET) AS ORT_UCRET
    FROM PERSONEL
    GROUP BY BOLUM_NO
) X
WHERE X.ORT_UCRET > 50000;
```

Bu yapı **inline view** olarak da anılır.

## Ünite 11: DML ve Hareket İşleme

### DML kavramı

DML, veri tabanındaki satırları değiştiren SQL işlemlerini ifade eder.

Temel deyimler:

- `INSERT`,
- `UPDATE`,
- `DELETE`.

### Satır ekleme

```sql
INSERT INTO BOLUM (
    BOLUM_NO,
    BOLUM_ADI,
    KONUM
)
VALUES (
    70,
    'EGITIM',
    'ANKARA'
);
```

Sütun listesi açık yazıldığında sorgu tablo sütun sırasına daha az bağımlı olur.

### NULL değer ekleme

Sütun `NULL` kabul ediyorsa değer açıkça `NULL` verilebilir veya uygun durumda sütun ekleme listesinden çıkarılabilir.

```sql
INSERT INTO PERSONEL (
    PERSONEL_NO,
    AD,
    KOMISYON
)
VALUES (
    100,
    'ALI',
    NULL
);
```

### Fonksiyonlarla veri ekleme

```sql
INSERT INTO LOG_TABLOSU (
    ID,
    OLUSTURMA_TARIHI
)
VALUES (
    1,
    SYSDATE
);
```

### Başka tablodan satır kopyalama

```sql
INSERT INTO YONETICILER (
    PERSONEL_NO,
    AD,
    GOREV,
    UCRET
)
SELECT PERSONEL_NO,
       AD,
       GOREV,
       UCRET
FROM PERSONEL
WHERE GOREV IN ('MUDUR', 'SEF');
```

### Verileri güncelleme

```sql
UPDATE PERSONEL
SET UCRET = 2500
WHERE PERSONEL_NO = 300;
```

`WHERE` koşulu unutulursa bütün satırlar güncellenebilir.

### Alt sorguyla güncelleme

```sql
UPDATE PERSONEL
SET BOLUM_NO = 90
WHERE GOREV = (
    SELECT GOREV
    FROM PERSONEL
    WHERE PERSONEL_NO = 350
);
```

Alt sorgunun beklenen kardinaliteyi üretmesi gerekir.

### Satır silme

```sql
DELETE FROM BOLUM
WHERE BOLUM_NO = 60;
```

`WHERE` kullanılmadan çalıştırılan `DELETE`, tablodaki bütün satırları hedefler.

Başvuru bütünlüğü ilişkileri silme işlemini engelleyebilir veya tanımlanmış silme davranışını uygulayabilir.

### Hareket kavramı

Bir veya daha fazla SQL işleminin tek mantıksal bütün olarak ele alınmasına **transaction**, ders terminolojisinde hareket denir.

Transaction için temel özellikler ACID başlığı altında özetlenir:

- Atomicity,
- Consistency,
- Isolation,
- Durability.

### COMMIT

`COMMIT`, mevcut transaction içindeki değişiklikleri kalıcı hale getirir.

```sql
COMMIT;
```

### ROLLBACK

`ROLLBACK`, henüz commit edilmemiş değişiklikleri geri alır.

```sql
ROLLBACK;
```

Transaction sınırları uygulamanın hata yönetimi ve bütünlük modelinin parçası olmalıdır.

## Ünite 12: Veri Tabanı Nesneleri

### Tablolar

Tablo veri tabanındaki temel ilişkisel nesnedir.

Oracle örneği:

```sql
CREATE TABLE BOLUM (
    BOLUM_NO NUMBER(4),
    BOLUM_ADI VARCHAR2(100),
    KONUM VARCHAR2(100)
);
```

### Tablo isimlendirme

İsimler:

- anlamlı,
- tutarlı,
- kurum veya proje standardına uygun

olmalıdır.

Anahtar kelimeleri nesne adı olarak kullanmamak taşınabilirlik ve okunabilirlik açısından yararlıdır.

### Veri türleri

Oracle'da yaygın türler:

- `NUMBER`,
- `VARCHAR2`,
- `CHAR`,
- `DATE`,
- `TIMESTAMP`,
- `CLOB`,
- `BLOB`.

Veri türü yalnız saklama biçimi değildir. Karşılaştırma, indeksleme, doğrulama ve sorgu semantiğini de etkiler.

### CREATE TABLE

```sql
CREATE TABLE PERSONEL (
    PERSONEL_NO NUMBER PRIMARY KEY,
    AD VARCHAR2(100) NOT NULL,
    UCRET NUMBER(12, 2),
    BOLUM_NO NUMBER
);
```

### Alt sorgu ile tablo yaratma

Oracle'da `CREATE TABLE AS SELECT` kullanılabilir.

```sql
CREATE TABLE PER20 AS
SELECT PERSONEL_NO,
       AD,
       UCRET * 12 AS YILLIK_UCRET
FROM PERSONEL
WHERE BOLUM_NO = 20;
```

Bu işlem veri ve belirli sütun yapılarını kopyalar. Kaynak tablodaki bütün sınırlamaların otomatik taşınacağı varsayılmamalıdır.

### Sütun ekleme

```sql
ALTER TABLE PERSONEL
ADD EMAIL VARCHAR2(200);
```

### Sütun tanımını değiştirme

```sql
ALTER TABLE PERSONEL
MODIFY EMAIL VARCHAR2(300);
```

Mevcut veriler yeni tanımla uyumlu olmalıdır.

### Tablo adını değiştirme

Oracle'da:

```sql
RENAME PERSONEL TO CALISAN;
```

veya sürüme ve bağlama uygun `ALTER TABLE ... RENAME TO ...` biçimleri kullanılabilir.

### Tabloyu yok etme

```sql
DROP TABLE PERSONEL;
```

`DROP`, nesnenin kendisini kaldırır.

### Tabloyu budama

`TRUNCATE TABLE`, satırları hızlı biçimde kaldırmak için kullanılan DDL işlemidir.

```sql
TRUNCATE TABLE GECICI_VERI;
```

`DELETE` ile aynı transaction davranışına sahip kabul edilmemelidir.

### Sınırlamalar

Başlıca tablo sınırlamaları:

- `NOT NULL`,
- `UNIQUE`,
- `PRIMARY KEY`,
- `FOREIGN KEY`,
- `CHECK`.

### NOT NULL

```sql
AD VARCHAR2(100) NOT NULL
```

Sütunda `NULL` bulunmasını engeller.

### UNIQUE

```sql
EMAIL VARCHAR2(200) UNIQUE
```

Tekrarlı değerleri sınırlar. `NULL` davranışı VTYS semantiğine göre değerlendirilmelidir.

### PRIMARY KEY

```sql
CONSTRAINT PK_PERSONEL
PRIMARY KEY (PERSONEL_NO)
```

Satır kimliğini tanımlar.

### FOREIGN KEY

```sql
CONSTRAINT FK_PERSONEL_BOLUM
FOREIGN KEY (BOLUM_NO)
REFERENCES BOLUM(BOLUM_NO)
```

Başvuru bütünlüğünü tanımlar.

### CHECK

```sql
CONSTRAINT CK_UCRET
CHECK (UCRET >= 0)
```

Satır değerine ilişkin mantıksal koşul tanımlar.

### Var olan tabloya sınırlama ekleme

```sql
ALTER TABLE PERSONEL
ADD CONSTRAINT UQ_PERSONEL_EMAIL
UNIQUE (EMAIL);
```

Mevcut verinin yeni sınırlamayı sağlaması gerekir.

### Sınırlamayı kaldırma

```sql
ALTER TABLE PERSONEL
DROP CONSTRAINT UQ_PERSONEL_EMAIL;
```

### Görünümler

**View**, bir sorgunun adlandırılmış mantıksal görünümüdür.

```sql
CREATE VIEW AKTIF_PERSONEL AS
SELECT PERSONEL_NO, AD, BOLUM_NO
FROM PERSONEL
WHERE AKTIF = 1;
```

Görünüm:

- karmaşık sorguyu soyutlamak,
- belirli sütunları gizlemek,
- kullanıcıya sınırlı veri sunmak,
- uygulama arayüzünü kararlı hale getirmek

için kullanılabilir.

### Görünümün güncellenmesi

Her görünüm güncellenebilir değildir.

Tek tabloya dayalı basit görünümler belirli koşullarda güncellenebilir. Birleştirme, gruplama, küme işlemleri veya türetilmiş sütunlar güncellenebilirliği sınırlayabilir.

Görünüm tanımı değiştirilecekse Oracle'da:

```sql
CREATE OR REPLACE VIEW ...
```

kullanılabilir.

### İndeksler

İndeks, tablodaki satırlara belirli anahtarlar üzerinden erişimi hızlandıran yardımcı veri yapısıdır.

```sql
CREATE INDEX IX_PERSONEL_BOLUM
ON PERSONEL(BOLUM_NO);
```

İndeks okuma performansını artırabilir. Buna karşılık:

- ek depolama kullanır,
- `INSERT`,
- `UPDATE`,
- `DELETE`

işlemlerinde bakım maliyeti oluşturur.

Bu nedenle "çok indeks daha hızlı veri tabanı" yaklaşımı doğru değildir.

### İndeks ne zaman yararlıdır?

Genel olarak:

- seçiciliği anlamlı sütunlarda,
- sık kullanılan filtrelerde,
- join anahtarlarında,
- sıralama veya erişim desenleriyle uyumlu sorgularda

yararlı olabilir.

İndeks seçimi tablo boyutu, veri dağılımı, sorgu planı ve iş yüküyle birlikte değerlendirilmelidir.

Sabit yüzde kurallarına güvenmek yerine gerçek yürütme planı ve ölçüm kullanılmalıdır.

### İndeksi kaldırma

```sql
DROP INDEX IX_PERSONEL_BOLUM;
```

## Ünite 13: Kullanıcı Erişiminin Denetlenmesi

### Kullanıcı erişimi

Bir veri tabanında bütün kullanıcıların aynı yetkilere sahip olması doğru değildir.

Temel ilke:

> Kullanıcıya yalnız görevi için gerekli en az yetki verilmelidir.

Bu yaklaşım **least privilege** ilkesidir.

### Kullanıcı yaratma

Oracle'da kullanıcı tanımlama:

```sql
CREATE USER UYGULAMA_KULLANICISI
IDENTIFIED BY guclu_bir_parola;
```

Gerçek sistemlerde parola politikası, kimlik doğrulama yöntemi ve hesap yaşam döngüsü kurumsal güvenlik politikasına göre yönetilmelidir.

### Sistem yetkileri

Kullanıcının veri tabanında belirli işlemleri gerçekleştirebilmesi sistem yetkileriyle denetlenir.

Örneğin:

```sql
GRANT CREATE SESSION TO UYGULAMA_KULLANICISI;
```

Tablo veya görünüm yaratma gibi yetkiler ayrıca verilebilir.

### Parola değişikliği

Oracle'da kullanıcı nitelikleri `ALTER USER` ile değiştirilebilir.

```sql
ALTER USER UYGULAMA_KULLANICISI
IDENTIFIED BY yeni_parola;
```

Üretim ortamında parolanın SQL metinleri ve kayıt dosyalarında açık biçimde görünmemesine dikkat edilmelidir.

### Roller

Rol, yetkilerin mantıksal grubudur.

```sql
CREATE ROLE RAPORLAMA_ROLU;
```

Yetki role atanır:

```sql
GRANT CREATE SESSION TO RAPORLAMA_ROLU;
```

Rol kullanıcıya atanır:

```sql
GRANT RAPORLAMA_ROLU TO UYGULAMA_KULLANICISI;
```

Roller çok sayıda kullanıcıya ortak yetki yönetimini kolaylaştırır.

### Nesne yetkileri

Bir kullanıcıya belirli tablo üzerinde belirli yetki verilebilir.

```sql
GRANT SELECT
ON PERSONEL
TO RAPOR_KULLANICISI;
```

Örnek nesne yetkileri:

- `SELECT`,
- `INSERT`,
- `UPDATE`,
- `DELETE`,
- `REFERENCES`.

Yetki yalnız ihtiyaç duyulan nesne ve işlemle sınırlandırılmalıdır.

### Yetkilerin geri alınması

```sql
REVOKE SELECT
ON PERSONEL
FROM RAPOR_KULLANICISI;
```

Yetki modelinde doğrudan kullanıcıya verilen yetkiler ile roller üzerinden gelen yetkiler ayrı değerlendirilmelidir.

## Ünite 14: İleri SQL Konularının Bütünleştirilmesi

İleri Veri Tabanı Sistemleri notlarının ilk bölümleri temel dersin SQL konularını tekrar eder. Aynı kavramlar burada ikinci kez çoğaltılmadan temel bölümlerde bütünleştirilmiştir.

İleri düzeye geçmeden önce şu başlıkların bilinmesi gerekir:

- `SELECT`,
- filtreleme ve sıralama,
- tek satır fonksiyonları,
- grup fonksiyonları,
- `GROUP BY` ve `HAVING`,
- join türleri,
- alt sorgular,
- `CREATE TABLE`,
- sınırlamalar,
- `INSERT`, `UPDATE`, `DELETE`,
- transaction yönetimi.

Bu bilgiler PL/SQL programlamasının doğrudan temelidir.

## Bu Çalışmaya Atıf

Köker, M. A. (2014). Veri Tabanı Yönetim Sistemleri. alikoker.com.tr. https://alikoker.com.tr/veri-tabani-yonetim-sistemleri

- BibTeX: https://alikoker.com.tr/veri-tabani-yonetim-sistemleri.bib
- RIS: https://alikoker.com.tr/veri-tabani-yonetim-sistemleri.ris
- CSL-JSON: https://alikoker.com.tr/veri-tabani-yonetim-sistemleri.csl.json