c++ Nedir? Temel Dersler

ÖNEMLİ NOT:Bu bir alıntıdır.

Temel Bilgiler

C++ bilindiği gibi programlama dünyasında en çok ilgi gören C dilinden türemiştir. C++’ı klasik C dilinden farklı yapan yanı; Nesne Yönelimli Programlamayı da ( Object Oriented Programming) C’nin sözdizimi kurallarıyla birlikte desteklemesidir. Normalde C ile sadece yapısal programlama yaparken C++ dili ile hem yapısal hem de nesne yönelimli programlar yazabilirisiniz. C++ diline başlarken önce dilin C’den gelen ve temel olan özelliklerini öğrenmek gerekir. Örneğin, değişken tanımlama, atama ve diğer basit aritmektik işlemler, kontrol yapıları ve döngüler gibi.
Teknolojinin ulaştığı son noktadaki programlama dillerinden olan C ve C++, bir çok yeni ve güçlü özellikleri içerir. Derslerimiz devam ettikçe bunların teker teker içine gireceğiz. C dilinin özelliklerinin %80 i C++’da da mevcuttur (bu karşılaştırma şahsi görüşümdür). Zaten C++, C’nin üst gurubudur. Bunu şöyle sıralayabiliriz. C, C++ ve C# dır.
C dilinin avantajları, az komut kümesinden oluşması ve bu komutların diğer yüksek seviyeli dillere nazaran daha hızlı çalışmasıdır. Ayrıca C deki kütüphaneler sayesinde fonksiyon tanımlamanıza gerek kalmadan işlemlerinizi yapmak mümkün olacaktır. Bu konuda çok detaya inmeden, programlamaya geçmek istiyorum. Çünkü, programlamaya başladığımızda her örnekten sonra o an kullandığımız programın içinde geçen fonksiyon, hata, değişken, belirleyiciler, kısıtlamalar, notasyonlar v.s gibi bilgilerden ara ara bahsedeceğim. Yalnız çok önemli olan bir konuya burada değinmek istiyorum. C nin avantajlarını programlamayla birlikte görmek güzel ama C nin dezavantajlarını programlamadan önce bilmeliyiz ki bunlardan sakınalım. Öncelikle Tanımlayıcılardan bahsetmek istiyorum. Her derleyici ve assmbley için değişkenleri, sabitleri, etiketleri ve fonksiyon adlarını tanımlama kuralları vardır. Bu notasyonlara, tanımlayıcı denir. C++ da tüm tanımlayıcılar a, . . . , z – A, . . . , Z harfleri ile ya da alt çizgi “_” ile başlar. Bundan sonra rakam, harf, ya da alt çizgi kullanılabilir. ANCI C uyumlu derleyiciler 31 karaktere kadar tanımlayıcı kabul ederler fakat tanımlayıcının ilk sekiz karakterini kullanmayı kendimize alışkanlık etmeliyiz. Dikkat etmemiz gereken özelliklerden biri de kullandığımız ifadelerdeki büyük küçük harflerdir. C ve C++ büyük ve küçük harf duyarlılığına sahiptir. Kullandığımız ifadeleri birbirinden farklı ve aynı ifade olarak kullanıyorsak programımız hata verecektir. Bunu bir örnekle anlatayım:
Program
PROGRAM
progRAM
ProgRam Bu şekilde tanımlarsak hepsi birbirinden farklı ifadeler olarak C++ da okunacaktır. Biz Şunu alışkanlık edinmeliyiz; tanımlayıcılarımızın baş harfi büyük olacak. Büyük ve küçük harf kombinasyonlarının kullanılması ile önceden yapılan tanımlamalar bazen işi zorlaştırabilir. Eğer bu değişkenlerden birini kullanmak isterseniz, bu zamana kadar nasıl tanımladığınızı bilmeniz gerekir. Örneğin printf()`in PRINTF() olarak çağrılması durumunda ” bilinmeyen tanımlayıcı ” (Unknown identifier) hata mesajı vererek sizi uyarır. Buna benzer olarak %f ve %F kullanımı hata verdirecektir. Programlamayı yaparken bunlara dikkat etmemiz gerekecek. Çünkü bir değişkeni veya tanımlayıcıyı başta nasıl kullandıysanız üç, dört sayfa kod yazdıktan sonrada aynı şekliyle kullanmak zorundasınızdır. İşte burada en büyük handikap yaşanacaktır. Çünkü C/C++ derleyicileri her zaman hatanın nerde olduğunu göstermez. Bunu programcı kendisi satır satır takip ederek bulacaktır. Bundan dolayı bu söylediklerime baştan dikkat etmemiz gerekiyor.
Tavsiyeler:

İyi bir programlama yapabilmek için benim size olan tavsiyelerim; daha az kod kullanarak daha çok işlem yapabilme. Gerçi bunu yapsak zaten profesyonel oluruz . Zaten C++ `ın paradigması da buradan geliyor. Aslında C++ da yapabileceğimiz tüm programları C de yapma olanağımız var ama bu bize hem fazla kod yazmayı gerektirecek hem de zaman kaybetmemize sebep olacak. Zaten bunlardan kaçındığımız için C++ diyoruz. Elimizde nesneye yönelik bir dil varken ve kullanacağımız fonksiyonlar içinde hazır olarak mevcutsa, tabi bize de bunun keyfini sürmek kalıyor. Tavsiyelerimden biride derslerde verdiğimiz örneklerin dışında aynı algoritmaya benzer farklı örnekler yapın. Öğrenmenin en iyi yolu yanlış yapmaktır. Bunu şöyle izah edeyim: eğer yanlış yapıyorsanız ve de o yanlışın kaynağını bulup düzeltebiliyorsanız, o an onu öğrenmişsiniz demektir. Tabi örnekler sizin için alıştırma olacaktır ve hafızanızda kalıcı bir yer tutacaktır. Bunca kodu başka türlü hafızada tutamayız. İlk başlarda sık sık not alınız, mümkün olduğunca da bol örnek yapınız. Örneklerinizi de kendiniz düşünüp kendi hayal gücünüzle oluşturursanız eminim bu işi başaracaksınızdır. Başta çok zor gelebilir ama başarı ter dökülmeden olmaz. Bu kısmı fazla uzatıp sizi daha başlamadan C/C++ dan uzaklaştırmak istemiyorum.

C++ İle Programlamaya Giriş

İlk programımız!

// ilk1.cpp
// Ekrana “Bu benim ilk programım” yazdırıyoruz
#include <iostream.h>

int main()
{
cout << “Bu benim ilk programım”;

return 0;
} Şimdi Yazdığımız programı inceleyelim:
“//” işaretini açıklama satırlarında kullanıyoruz. C++ derleyicisi bu notasyonla başlayan satırı okumaz. Bununla birlikte daha uzun cümlelerimiz olursa bunları da ” /* */ ” notasyonunun içinde yazıcağız. Bu özellik de C den bize kalma. Demiştik zaten C `nin tüm özelliklerini C++ içerir. Fakat biz genelde ” // ” yi kullanacağız.
#include <iostream.h> : Bu bizim C++ da bulunan kütüphane dosyamızı çağırmaya yarıyor. Ben size şöyle tarif edeyim. iostream.h kütüphanesindeki hazır olan ” cout ” fonksiyonunu çağırıyor. Yani buda bizim fazla kod yazmamıza engel oluyor. .h ile biten dosyalar kütüphane dosyalarıdır. Bunu şuna da benzetebiliriz. Farz edelim ki elimizde bir alet çantası var içinden tornavidayı çağırdığımızda vida sıkacağızdır. Bu da ona benziyor. C++ da ki hazır kütüphanelerde bir çok hazır fonksiyonlar vardır. İlerde Bu hazır fonksiyonlar işimizi görmemeye başlayınca kendi kütüphanemizi yapmaya başlayacağız. Tabi bu seviyeye geldiğimizde olayı hemen hemen kavramış olacağız, tabi neden olmasın öyle değil mi?
Daha sonraki satır her C++ programında mutlaka bulunması gereken bir satırdır. Her C++ programında main() fonksiyonu olmak zorundadır; bu fonksiyonumuzun önünde ise o fonksiyonun dönderdiği değişkenin veri tipi olmalıdır. Tabi ki C++ fonksiyonlar ve onların dönderdikleri değerler konusunu da ileride işleyeceğiz.
Bir sonraki satırda ise; C++ fonksiyonlar ve kod blokları ” { } ” parantezleri arasında bulunmalıdır. main de bir fonksiyon ise onun içindeki kodlar doğal olarak { } parantezleri arasındadır.
Program derlenip çalıştırıldığında ise ( Turbo C++ 3.1 kullanıyorsanız ctrl+f9 kısa yoluyla programı çalıştırabilirsiniz (Run) ) karşımıza “Bu benim ilk programım” yazısı çıkacaktır. İşte bu yazıyı ekrana veren komut da iostream.h kütüphanesindeki cout fonksiyonudur.
Önemli bir nokta ise C++ dilinde her satır ifadenin sonuna ” ; ” koymak zorundayız. Bundan farklı olarak #include satırlarının ve bir kaç farklı satırın arkasına ” ; ” gelmez. Bunları ileride göreceğiz.
Return 0 : programımızın (aynı zamanda main fonksiyonumuzun) çıkış noktasıdır. Eğer return ile 0 değeri dönderirsek programımızın güvenle çıktığını işletim sistemine bildirmiş oluruz. Bu sayede güvenle programımızın çalıştığını göreceğiz.
Şimdi size bir örnek daha vereceğim bununla da aynı çıktıyı elde edeceğiz. Arasındaki farkları eminim basit olarak sizlerde göreceksinizdir.
// ilk2.cpp
// Ekrana “Bu benim ilk programım” yazdırıyoruz
#include <stdio.h>
main()
{
printf(“Selam bu benim ilk programım.\n”);
return 0;
} Evet şimdi burada çok fark varmış gibi gözüküyor aslında ama öyle değil. Sadece kütüphanemiz stdio.h oldu ve ekrana yazdır fonksiyonumuzda printf oldu. Bu özellik C den kalma. Bunlar diğer program ile aynı işlevi görüyor. Buradaki fark ” \n ” notasyonu. Bu noptasyon bir sonraki satıra geçmek için kullanılır. Bu notasyonlara Escape dizileri denir. Tablo olarak bunları size veriyorum. Son yazdığımız ilk2.cpp de yerlerine koyarsanız çalışacaktır.

Şu an bunları bilmeniz yeterli.

Dizi:

Değişkenler

Şimdi bize yine çok lazım olacak bir özellik de değişken tanımlamak ve atama yapmaktır. Bunu bir örnek üzerinde anlatmak istiyorum. Örneğimiz;
// degisken.cpp
// Burda değişken tanımlamayı göreceğiz.
// Aynı zamanda verilen bir sayıyı kendisi ile carpma 2.2=4 gibi

#include <iostream.h>
#include <stdio.h> // kütüphane dosyamız
main()
{
int i; // Değişken tanımlama
cout << “Bir sayı giriniz: “;
cin >> i;
i=i*i;
cout << “sonuc: ” << i ;
return 0;
} Burada bundan önce yaptığımız programlardan farklı olarak int i kullandık, yani değişken tanımladık.
Değişken Nasıl Tanımlanır?

Değişkenleri tanımlamak için aşağıdaki şema kullanılır.
[Veri Tipi] [Değişken Adı];
Örneğin
int sayi;
Şimdi degisken.cpp örneğindeki int i; kısmını anlamışsınızdır. Burada değişkenlere değinmek istiyorum. Biz yukarda İçinde sayı tutan bir değişkeni tanımladık. Benzer olarak aşağıdaki tanımlamalar da vardır.
char c;
int i;
float f;
double d;
unsigned int ui;
Burada [Veri Tipi] [Değişken Adı]; bu kalıba göre tanımlama yaptığımız için önce Veri Tiplerini inceleyelim.

 

Veri Tipleri

1) İnt tip.

Integer = Tamsayı

Tamsayıları içerir. Bellekte 2 Byte tutar. DOS’ta ve Win3.1′de 16 bit uzunlugunda ama Windows9x, WinNT, Win200 ve WinXP 32 bit uzunluğundadır.
Değer aralıkları Short ve long için değişir.
Örnek: 5, -20, 1 gibi.

2) Sort tip.

Tam sayıları içerir. 16 bit uzunluğundadır.
signed: -32768 ile +32767 arasinda değer alır, unsigned: 0 ile 65535 arasinda değer alır.
3) Long tip.

Tam sayılar içerir. 32 bit uzunluğundadır.
signed: -2147483648 ile +2177483647 arasinda değer alır, unsigned: 0 ile 65535 arasinda değer alır.
4) Gerçel Tipler (Float, Double, Long double)

Gerçel sayıları içerirler.
float : Bellekte 4 Byte yer tutar. 3.4E-38 ile 3.4E+38 aralığında değer alır. Hassasiyet 7-8 basamaktır.
double : Bellekte 8 Byte ter tutar. 1.7E-308 ile 1.7E308 aralığında değer alır. Hassasiyet 15-16 basamaktır.
long double : doublenin tipinin daha genişidir.1.2E-4932 ile 1.2E-4932 aralığında değer alır. Hassasiyet 19-20 basamak.
5) Char Tip

Char : Karakter
Alfanumerik karakterleri içerir. Ve ya 8 bit uzunluğunda tamsayı.
signed: -128 ile 127 arasinda değer alır, unsigned: 0 ile 255 arasında değer alır.
Örneğin: ‘ 0,1,2,3,4,5,6,7,… ‘ , ‘ *,-,+,… ‘ , ‘a,b,c,….,A,B,C,D,,,,, ‘
6) Bool tip.

true(dogru) = 1 veya false(yanlis) = 0 değerini alır. Eski derleyiciler bu türü desteklemeyebilir. Yeni ANSI C++ standardında eklenmiştir. Bu soyut matematik gördüyseniz. “p V q” ya benzer ( matematikçiyiz, konuşturalım azıcık). Değer aralığı ise ya 1 dir (doğru) yada 0 dır (yanlış).
7) Enum tip.

enum sıralanmış değerleri tutar. Short int ile aynı değeri taşır.
Başta Fazla Detaya inip sizi bunaltmak istemiyorum. Çünkü C++ dili başlarda karmaşık gelen bir dildir. Bu da zaten kendisini yüksek seviyeli bir dil yapıyor . Ben size Bu dilin temel özelliklerini anlatarak basit programlar yapmayı göstereceğim.
Bu temel bilgileri aldıktan sonra programlamaya geçebiliriz. Derleyici Olarak ben Turbo C++ 3.1 i tavsiye ederim. Şu an bununla başlar iseniz işiniz daha kolay olacaktır (bence). İlerde Borland a geçeceğiz.
Değişken tanımlama konusunda bir konuya daha değinmek istiyorum. Değişkenlere değer atama ve aynı anda bir çok değişken tanımlamamız C++ da mümkündür.
char c = ‘c’;
int i = 5;
Daha sonradan değer atama:
char c;
int i;
c = ‘c ‘;
i = 5;
Bir de aynı anda bir çok değişken tanımlayalım.
Örneğin:
int x , y , z;
x = y = z = 5;
x,y,z’ nın değeri 5 oldu
Bir sonraki derste ise değişkenlerle birlikte bir de Operatörleri ele alacağız.

 

Operatörler I

Operatör ve Operand nedir?

Bunu bir örnek üzerinde anlatmak istiyorum. Örneğin; x + y ‘de x ve y operand + ise operatördür. Bu bir aritmetiksel operatördür. Matematikte işlemler operatörler ve operandlar ile anlatılır.
Operatörleri öncelikle türlerine göre ayıralım:
1) Aritmetiksel operatörler + , – , * , / , % , ++ , –
2) Karşılaştırma operatörleri < , > , <=, >= , ==, !=
3) Eşitleme operatörleri = , += , -=, *= , /= , %= , <=, >>=, &=, != , ^=
4) Mantıksal Operatörler ! , || , &&
5) Bit bazında işlem yapan operatörler & , ! , ^ , ~ ,
Aritmetiksel (Matematiksel) Operatörler:

Matematiksel ifadeleri günlük hayattaki biçimde bilgisayarda yazamadığımız için belli kurallara uymamız gerekir. Bu kısım önemli olduğu için biraz geniş yer vereceğim. Kullandığımız matematiksel işlemler ve anlamları şöyledir:

Bu operatörle verilen iki veya daha fazla operand toplanabilir. Yazılış şekli Aşağıdaki gibidir.
değişken1 + değişken2
Eğer bu iki değişkeni Sonuç gibi başka bir değişkene atarsak eşitleme operatörüyle aşağıdaki gibi yaparız.
Sonuç = değişken1 + değişken2
Buna bir örnek verelim.
// toplama.cpp
//Vize ve final notlarinindan geçme notunu hesaplama

#include <iostream.h>
#include <math.h>

main()
{
int vize, final, ort;
vize = 10;
final = 80;
ort = vize * 0.4 + final * 0.6;
cout<< “Geçme notunuz: ” << ort;
} Burada çarpma operatörünü de kullandık sanırım, artık diğerlerinin de ne olduğunu kavramış oldunuz. Bir örnekte işi ucuza getirdim . Fakat bir artma ve bir azalmaya örnek verelim. Bu bana çok lazım olmuştu.
Burada dikkat etmemiz gereken olay ” ++ ” operatörünü değişkenin önüne yazmanız gerektiğidir. Bu sayede değişken bir arttırılarak işleme konur. Arkasına konursa değişken işlenir, sonra bir arttırılır. ” — ” operatöründe ise aynı şekilde de bir azaltma yapılır.
// carpim.cpp
// x i bir arttırıp y yi bir azaltıp çarptık.

#include <iostream.h>

main()
{
int x = 5;
int y = 10;
cout << “x = ” <<x << endl;
cout << “y = ” << y << endl;

cout <<”++x * –y = ” << ++x * –y ;

} İşte bir fark daha yakaladık bunu da hemen örnek üzerinde anlatalım. Sanırım buraya kadar geldiğimiz yerlerde int i , çarpma işlemini, bir arttırıp azaltmayı gördük, ama diyeceksiniz ki ” endl ” ne oluyor? Hemen açıklayayım; Satır sonunu belirterek yeni satıra geçmemizi sağlar, bir nevi ” \n ” Escape operatörü gibi bir işleve sahiptir.

Operatörler I

Operatör ve Operand nedir?

Bunu bir örnek üzerinde anlatmak istiyorum. Örneğin; x + y ‘de x ve y operand + ise operatördür. Bu bir aritmetiksel operatördür. Matematikte işlemler operatörler ve operandlar ile anlatılır.
Operatörleri öncelikle türlerine göre ayıralım:
1) Aritmetiksel operatörler + , – , * , / , % , ++ , –
2) Karşılaştırma operatörleri < , > , <=, >= , ==, !=
3) Eşitleme operatörleri = , += , -=, *= , /= , %= , <=, >>=, &=, != , ^=
4) Mantıksal Operatörler ! , || , &&
5) Bit bazında işlem yapan operatörler & , ! , ^ , ~ ,
Aritmetiksel (Matematiksel) Operatörler:

Matematiksel ifadeleri günlük hayattaki biçimde bilgisayarda yazamadığımız için belli kurallara uymamız gerekir. Bu kısım önemli olduğu için biraz geniş yer vereceğim. Kullandığımız matematiksel işlemler ve anlamları şöyledir:

Bu operatörle verilen iki veya daha fazla operand toplanabilir. Yazılış şekli Aşağıdaki gibidir.
değişken1 + değişken2
Eğer bu iki değişkeni Sonuç gibi başka bir değişkene atarsak eşitleme operatörüyle aşağıdaki gibi yaparız.
Sonuç = değişken1 + değişken2
Buna bir örnek verelim.
// toplama.cpp
//Vize ve final notlarinindan geçme notunu hesaplama

#include <iostream.h>
#include <math.h>

main()
{
int vize, final, ort;
vize = 10;
final = 80;
ort = vize * 0.4 + final * 0.6;
cout<< “Geçme notunuz: ” << ort;
} Burada çarpma operatörünü de kullandık sanırım, artık diğerlerinin de ne olduğunu kavramış oldunuz. Bir örnekte işi ucuza getirdim . Fakat bir artma ve bir azalmaya örnek verelim. Bu bana çok lazım olmuştu.
Burada dikkat etmemiz gereken olay ” ++ ” operatörünü değişkenin önüne yazmanız gerektiğidir. Bu sayede değişken bir arttırılarak işleme konur. Arkasına konursa değişken işlenir, sonra bir arttırılır. ” — ” operatöründe ise aynı şekilde de bir azaltma yapılır.
// carpim.cpp
// x i bir arttırıp y yi bir azaltıp çarptık.

#include <iostream.h>

main()
{
int x = 5;
int y = 10;
cout << “x = ” <<x << endl;
cout << “y = ” << y << endl;

cout <<”++x * –y = ” << ++x * –y ;

} İşte bir fark daha yakaladık bunu da hemen örnek üzerinde anlatalım. Sanırım buraya kadar geldiğimiz yerlerde int i , çarpma işlemini, bir arttırıp azaltmayı gördük, ama diyeceksiniz ki ” endl ” ne oluyor? Hemen açıklayayım; Satır sonunu belirterek yeni satıra geçmemizi sağlar, bir nevi ” \n ” Escape operatörü gibi bir işleve sahiptir.

Operatörler III

Mantıksal Operatörler (Lojik Operatör Sembolleri) :

Burası biraz Soyut Matematik, biraz değinmek istiyorum. Yukarıda gördüğümüz mantıksal operatörler, Doğru (1) yada Yanlış (0) sonucunu argümanlara bakarak üretirler. Mantıksal Değil (!), değeri tersine çevirir. Ve ( && ) operatörü ise yalnızca her iki ifadede Doğru (1) ise sonuç Doğru (1) ` dur; diğer durumlarda Yanlış (0)` dır. Veya` da ( || ) ise yalnızca iki ifadenin Yanlış (0) durumunda sonuç Yanlış (0) olur diğer durumlarda Doğru (1)`dur.
Ne diyorlardı? En iyi programcılar matematikçilerden çıkar . Arkadaşlar umarım zorlanmıyorsunuzdur. Olabildiğince ince eliyorum ve anlayacağınız şekle indirgemeye çalışıyorum. Bunun üstüne bir çay içerim. Geldiğimde devam edeceğim…
Bit bazında İşlem Yapan Operatörler :

Bu kısımda Soyut Matematiğin daha da ayrıntılarına girilmesi gerekiyor. Ben size kısaca bunu anlatayım. Çok karışıklık da sizi yoracaktır. Örnekleri yaparken yine üstünde dururuz.
Bit bazında işlem yapan operatörler şunlardır: AND (Ve ( & ) , OR (Veya ( ~ )), XOR ( ^ ).
And (&) operatörü; bitleri karşılaştırır. Eğer her ikisi de Doğru (1) ise sonuç Doğru (1), aksi halde Yanlış (0)`dır.
OR (~) operatörü; iki biti karşılaştırır ve eğer ikisi de Doğru (1) ise yada birisi Doğru (1) ise sonucu Doğru (1) yapar. OR işlemi belirli bir bit i Doğru (1) e çekmek için kullanılabilir.
XOR (^) operatörü; bit düzeyinde EXCLUSIVE OR (dışında tutan veya) (Türkçe’sini çevirince saçma oluyor) işlemi yalnızca karşılaştırılan bitler bir birinden farklı ise Doğru (1) üretir, aksi halde Yanlış (0) üretir.
! işareti ise her bir bit i ters çevirir.
Not: Bunlar yeni başlayanlar için yorucu olabilir. Son iki bölümün fazla üstünde durmayın
< Bir de bize C++ile gelmiş olan operatörlerden bahsetmek istiyorum. Bunlar;
” :: ” Erim çözünürlüğü (Scope resolution operatörü).
” * ” Dolaylı adresleme (Pointerlerle kullanacağız).
” & ” Adres operatörü (Pointerlerle kullanacağız).
” new ” Dinamik bellek ayırma .
” sizeof ” Nesne Boyutu.
İlerde fonksiyonlara geçince, bunları ve diğerlerini de göreceğiz. Şu an için sizi bunlarla yormak istemiyorum.

Program Kontrol ve Döngü Komutları

Daha önceki bölümlerde, standart veri tiplerini öğrendik, bununla birlikte diğer dillerde olmayan fakat C/C++`a özgü işlemleri de tanıdık. Şimdi ise C/C++ mantıksal kontrol yapılarını öğreneceğiz. Bu komutların bir çoğu diğer yüksek seviyeli dillerde de mevcuttur. Örneğin; if, if-else, switch, for, while ve do-while döngüleri. Fakat ?:, break, ve continue komutları gibi yalnızca C/C++`a özgü kontrol komutları da vardır. Ne demiştik C++ , C yi kapsar. O halde C de olan tüm mantıksal kontrol yapıları C++ da da mevcuttur.
Programlar (algoritmalar) üç temel blok kullanılarak gerçekleştirilebilirler. Bunlar; artarda, bir koşula bağlı olarak ve sonlu sayıda yineleme (döngü) dür.
Biz şimdi bu Mantıksal ifadeleri teker teker ele alacağız. Hem Bu sayede hepsine daha çok yer vermiş olacağız ve de örneklerle bunu pekiştireceğiz. Şimdiye kadar geldiğimiz bölümleri iyi bilip, Mantıksal ifadelerin yapılarını da öğrendiğimizde, bayağı bir yol kat etmiş olacağız.

If Komutu

if komutu anlaşılması ve yazılımı en basit olanıdır. if komutu, bir grup komutun koşullu olarak yürütülmesi amacıyla kullanılır. Buna bir örnek verecek olursak; düşünün ki bir sınav yapılıyor ve 50 ve üzeri alanlar geçecek. Bunun için if i kullanırsak not 50 ye eşit veya büyükse (büyük eşit) geçer not olacak.
//not.cpp
// 50 ve 50 den yukarsı geçiyor.
#include <iostream.h>

main()
{
int not;
cout << “Notu yazınız:”;
cin >> not;

if ( not >= 50 )
cout << “Geçtiniz!”;

} Sanırım bu örnekte ne dediğimi anlamış olacaksınız.
if ( not >= 50 )
cout << “Geçtiniz!”;

if (ifade)
{
Komut;
Komut;
…
} Burda görüldüğü gibi if (ifade) ve sonraki komutlarda { } bloğunun içine yazılır. Şimdi if`e bir de şu açıdan yaklaşalım. if in kelime anlamı “eğer” dir. Mantık şudur: eğer belirtilen parametre doğruysa, if komutu, if ten sonra gelen bloktaki fonksiyonları gerçekleştirir. Doğru değilse, if den sonraki bloğu yok sayar. Burada bir detaya daha inmek istiyorum. Ne demiştik, mantık işlemlerinde olay ya doğrudur (1) ya da yanlıştır (0). Şimdi yukarıdaki if in genel kullanım şekline tekrar bakalım. Bunu, eğer parametre doğru ise kullanabiliriz. Bir de bunun tersini düşünelim. Bit bazında işlemlerde sanırım ( ! ) bunu görmüştük. Her bir biti ters çevirir.
if (!ifade)
{
komut (yanlış (0));
Komut (yanlış (0));
….
} Derdimi anlamış olduğunuzu ümit ediyorum . Ama bence buranın üstünde biraz daha duralım. Çünkü bunu anlarsak diğerlerinde zorlanmayız. Son yaptığımızda ifadeyi tersine çevirdik.

//pozitif.cpp
// Bunada açıklama yaptırmayın ( yapamadımda)
#include <iostream.h>
main()
{
int x;
cout << “Bir sayı girin:” ;
cin>> x;
if ( x > 0 )
cout << “Pozitif” ;
} Aynısının negatif ini de siz yapın. Şimdi bir de iç içe if örneğine bakalım:
//gecti.cpp
// Buna açıklama yapmıycam!
#include <iostream.h>
main()
{
int not;
cout << “Notunuzu giriniz:”;
cin >> not;
if ( not> 50)
cout << “Geçtiniz!” ;
if (not < 50)
cout << “Kaldınız!” ;
if ( not==50)
cout << “zar zor geçtin “;
} Anlamış olduğunuzu umut ederek if komutunu burada bitiriyorum.

If-else Komutları

if-else komutu iki işlemden hangisinin uygulanacağına karar verir. Else kısmı seçimlidir, gerekmiyorsa kullanılmayabilir. Yazılım kuralı ile şöyledir;
if ( ifade)
komut1;
else
komut2; daha genel şekliyle
if ( ifade )
{
komut1;
komut2;
…
}
else
{
komut1;
komut2;
…
} Veya lojik olarak baktığımızda sanırım daha iyi anlayacaksınız
if (ifade)
blok_dogru (1);
else
blok_yanlis (0); Sanırım artık açıklama yapmama gerek kalmayacak. Şimdi örneklerle bunu pekiştirmeye çalışalım.
//tekcift.cpp
//sayı tekmi çiftmi onu görüceğiz
#include <iostream.h>
main()
{
int sayi;
cout<< “Bir sayı giriniz:”;
cin >> sayi;
if (sayi %2==1 )
cout <<”tek”;
else
cout << “çift” ;
} Bir örnek daha verelim:
//ifelse.cpp
#include <iostream.h>
main()
{
int not;
cout<< “Notu giriniz:”;
cin >> not;
if (not >= 50)
cout << “Geçti!”;
else
cout << “Kaldı!”;
} if kısmından anlatmaya başlayacağım. Eğer notumuz 50 ye eşit veya 50 den büyük ise geçiyoruz aksi halde kalıyoruz.
Bir de bir if-else in altında bir tane daha if-else kullanalım.
//sinav.cpp
// alt alta if-else
#include <iostream.h>
main()
{
int not;
cout<< “Not`u giriniz:”;
cin >> not;
if (not >= 50)
cout << “Geçtiniz!”;
else
{
cout <<”Bütten alınan not:”;
cin >>not;
if( not>=60 )
cout << “Geçtiniz!”;
else
cout <<”Kaldınız!”;

}
} Burada da şunu inceledik: diyelim ki sınava girdik ve notumuzu öğrendik, notu giriyoruz 50 nin altındaysa kalıyoruz. ve bütünleme sınavına giriyoruz. Bütte de geçer not en az 60. Sanırım bu basit örneklerle olayı iyice kavramışızdır. if-else i de burada bitiriyoruz.

?: Komutu

Bu komut, yalnızca C++ a özgüdür. Kendine özgü bir yazılımı ve mantıksal kullanımı vardır. if-else komutunun kısaltılmışıdır. Fakat, tüm if-else komutları yerine kullanılmaz. Yalnızca karşılaştırma sonrası, tek komut kullanılan uygulamalar için geçerlidir. Bu söylediklerimizi örnek üstünde gösterelim:
//tekcift.cpp
//tekcift.cpp yi bu sefer ?: ile yapıyoruz
#include <iostream.h>
main()
{
int sayi;
cout<< “Bir sayı giriniz:”;
cin >> sayi;
cout << (sayi %2==1 ? “tek” : “çift”) ;
} Kullanış biçimi: cout << (sayi %2==1 ? “tek” : “çift”) ; çok basit ama dikkat edelim. Her zaman kullanmıyoruz.

Switch-case Komutları

Switch Case deyimi işlev bakımından if deyimine çok benzemektedir. Çok sayıda if işlem blokları kullandığımızda programın okunurluğu azalacak ve programı izlemek zorlaşacaktır. Programımızın bir değerini bir çok değerle karşılaştırmak gerektiğinde switch komutunu kullanacağız. Switch seçeneği ile değişkenin durumuna göre bir çok durum içersinden bir tanesi gerçekleştirilir. İstersek de if deyimi ile switch case’ yi birlikte kullanabiliriz. Switch in yaptığı iş kısaca, ifadenin değerini sırayla sabitlerle karşılaştırarak ve her satırı işlemektir.
switch( Kontrol Değişkeni )
{
case Sabit1 : komut1;
case Sabit2 : komut2;
.
.
.
default : Komutson;
} Buna en basit örneğimizi verelim

//switch.cpp
// switch-case yi öğreniyoruz.

#include <iostream.h>

main()
{
int i;
cout<< ” 1 ile 4 arası sir sayı giriniz:”;
cin>>i;
switch(i)
{

case 1 :cout<<”1 Girdiniz”; break;
case 2 :cout<<”2 Girdiniz”; break;
case 3 :cout<<”3 Girdiniz”; break;
case 4 :cout<<”4 Girdiniz”; break;

default:cout<<”1 ile 4 ten farklı”;
}
} Burada gördüğümüz gibi i değişkenine bağlı olarak program işliyor. Case’lerinin aldığı değere göre kendinden sonra gelen komutları işliyorlar. Burada daha önce görmediğimiz break komutunu gördük. Buna ilerde daha detaylı olarak değineceğim. Fakat biraz bahsetmek istiyorum. Programımızda değişkene 1 değerini verdiğimizi farz edelim. Case 1 adlı satırı geçip ondan sonraki komut dizisini işleme soktuk. Bu işlemin tamamlanması için break komutu kullanılıyor. Yazılımda break komutu goto gibi işlev görür ve derleyiciye switch komutundan çıkması için talimat verir. Sorunu ortadan kaldırmak için her durum için break deyimi eklemeliyiz (tavsiye). Ne demiştik; bir çok karşılaştırma olduğunda switch’e ihtiyaç duyuyoruz. Karşılaştırmaların hiç biri olmadığı anda da ortaya default tan sonraki satırın işlenmesi kalıyor. Sanırım bu örnekte basit olarak anlamış olacağız.
Daha karmaşık bir örnek verecek olursak:
//ucgen.cpp
// Program gireceğimiz ölçülere göre üçgenin Alan, Yükseklik ve Tabanını bulur
// switch-case örneğimiz.

#include <iostream.h>

int main()
{
char secenek;
float alan, yukseklik, taban;

cout << “Program gireceğimiz ölçülere göre üçgen’in Alan,
Yükseklik ve Tabanını bulur!\n” << endl
<< ” A —> Alan : Bulmak için yükseklik ve tabanı gireceğiz:” << endl
<< ” h —> Yükseklik : Bulmak için alan ve tabanı gireceğiz:” << endl
<< ” t —> Taban : Bulmak için alan ve yüksekliği gireceğiz:” << endl
<< endl << endl;
cout<< “Seçeneğiniz? —> A, h, t :”;
cin>> secenek;

switch(secenek)
{
case ‘a’:

case ‘A’:
{
cout<< endl <<endl <<”Yükseklik: “;
cin>> yukseklik;
cout<<endl << “Taban: “;
cin >> taban;

alan = 0.5 * taban * yukseklik;

cout<<endl << endl << “Alanı: ” << alan << endl;

break;
}

case ‘h’:
case ‘H’:
{
cout<< endl << endl <<”Alanı: “;
cin>> alan;
cout<<endl << “Tanabı: “;
cin >> taban;

yukseklik = 2.0 * alan / taban;

cout << endl << endl << “Yükselik: ” << yukseklik << endl;
break;
}

case ‘t’:
case ‘T’:
{
cout << endl <<endl <<”Alanı: “;
cin >> alan;
cout << endl << “Yüksekliği: “;
cin >> yukseklik;

taban = 2.0 * yukseklik / alan;

cout << endl << endl <<”Tabanı: ” << taban << endl;
break;
}
}
return 0;
} Gayet basit bir örnek değişkenleri tanımladık. Caseleri koyduk ve caselerden sonra gelecek komut satırlarını yerleştirdik. Bu program göründüğü gibi zor değildir.

Döngü Komutları

Bir ya da birden fazla deyimin tekrar edilmesini sağlarlar. Döngüler, ” belli bir koşul sağlandığı sürece sürekli çalıştırılacak kod parçası ” olarak nitelendirilebilir. For döngüsü, while döngüsü, do-while döngüleri, diğer yüksek seviyeli dillerdeki gibidir. Ancak en büyük fark, programın bu tekrar döngüleri istediğinde terk edebilmesidir. C/C++, döngüden çıkmak için beş ayrı yöntem vardır.

C/C++ da ki döngülerin arasındaki fark, beklenen döngü sayıları arasındaki farktan kaynaklanır. Eğer önceden belirli bir döngü sayımız mevcut ise For döngüsü kullanılır. while ve do-while döngülerinde döngü sayısı belli değildir. C++ nın bize vermiş olduğu esneklik sayesinde, döngüleri son derece esnek bir biçimde kullanma şansımız vardır.

While Döngüsü

İçlerinde anlatımı ve anlaşılması en kolay olan döngüdür. While döngüsü, döngü sayısının belli olmadığı zamanlarda kullanılır.
while ( koşul )
Komut; While döngüsü, içinde bulunan ifade doğru olduğu sürece altındaki komut veya komut bloğu yürütülür. Eğer yanlış ise kontrol bir sonraki komut veya komut bloğuna geçer.
While döngüsü daha genel şekliyle:

while ( ifade )
{
komut;
komut;
komut;
.
.
.
} Burada bir şeye dikkat etmenizi istiyorum. Çoklu komutlar kullandığımızda ” { } “parantezleri gereklidir.
// while1.cpp
// while döngüsünü kullandık
// girdiğimiz sayıdan 100 e kadar olan sayıları topladık

#include <iostream.h>

main()
{
int x, y;
y= 0;
cout<< ” Bir Sayı Giriniz ( Sayı 100 den küçük olucak ) : “;
cin>>x;
while (x< 101)
{

y =y+x;
x =x+1;

}

cout<< “Toplam= “<< y;
} Burada önce x ve y yi tanımladık. y=0 değerini verdik. Sonra klavyeden girilen değerin x olduğunu yazdık. while (x< 101) işte burada ifademiz x< 101. Şimdi bu koşul sağlanıncaya kadar döngümüz devam edecek. While’ den sonraki bloğa geçtiğimizde ise. y` ye x i ekliyoruz ve x in değerini her seferinde 1 arttırıyoruz. Sanırım bu basit örnekte döngünün basit yapısını ve mantığını anlamış oldunuz.
Döngünün verilen ifade veya koşula göre sağlanması döngülerin en önemli konusudur. Eğer bir döngüden çıkılmazsa o döngü sonsuza gider. Buna da “sonsuz döngü” denir. Döngüler konusunda en çok rastlayacağımız hata da budur.Şimdi buna bir örnek verelim. Fakat, şimdiden uyarıyorum, sonsuz döngü yapıldığında bilgisayarınız kilitlenebilir. Onun için buna şimdiden hazır olun. Zaten bir sefer denediğimizde ne demek istediğimi anlayacaksınızdır.
//sonsuz.cpp
//while döngüsü ile sonsuz bir döngü yaptık

#include <iostream.h>

main()
{
int x=1;
while(x)

cout<< “x= “<< x++<< endl;

} Burada neden sonsuz bir döngü oldu? Evet işte x ifadesini koşula bağlamadık. Şayet while(x<10) demiş olsaydık. 1,2,3,4,5,6,7,8,9 a kadar x sayısı sıralanacaktı.
//klavye.cpp
//while döngüsü ile klavyeden girilen sayı

#include <iostream.h>

main()
{
int x, y = 0;

while (y< 20)
{
cin>>x;
y = y+x;
}
cout<< “Toplam= “<< y ;
} Bu programda da klavyeden girilen sayıların toplamı 20′ den büyük olunca program Toplam olarak söylüyor. Sanırım basit While yapısını anladınız. Şimdi birazda karmaşık programcıklar yapalım.
1. Örnek: Girilen altı not’un ortalamasını alıyor.
//ortalama.cpp
// while döngüsü ile girilen notların ortalamasını aldık.

#include <iostream.h>

int main()
{
int toplam,
sayac,
not,
ortalama;

toplam = 0;
sayac = 1;

while ( sayac <= 6 )
{
cout << “Notu giriniz: “;
cin >>not;
toplam = toplam + not;
sayac = sayac + 1;
}

ortalama = toplam / 6;
cout << “Sınıf ortalaması = ” << ortalama << endl;

return 0;

} Bu örneğimizde yine toplam, sayac, not, ortalama gibi değişkenleri tanımladık. ( toplam =0 ; ve sayac = 1; ) de değişkenlere ilk değerlerini atadık. While döngüsünün içinde sayac değişkenimizi altı defa işlemesini söyledik. Sonra alttaki toplam ve sayac bölümlerinde ise toplam a not’ u ekliyoruz, her seferinde de sayac değerini bir arttırıyoruz ve sayac değeri 6′ ya gelince while döngümüz duruyor. Program sonra toplamı alıp altıya böler bu sayede ortalamayı alır, sonrada çıktısını gerçekleştirir.
2. Örnek:
//faktoriyel.cpp
// while ile faktoriyel hesaplama

#include <iostream.h>
int main()
{
int sayi;
long int faktoriyel=1;
cout << “Bir sayı giriniz: “;
cin >> sayi;
cout << sayi << ” `in Faktöriyeli: “;
while (sayi > 1)
faktoriyel *= sayi–;

cout << faktoriyel << endl;
return 0;
} Burda while (sayi>1) şeklinde koşulumuzu belirttik. Bir altında ise faktoriyel *= sayi–; evet burda da daha önce gördüğümüz gibi eşitleme operatörü olan ( *= ) i kullandık. Yani faktoriyel’e faktoriyel*sayi– nin değeri atanır. Matematiğini düşünürseniz; 7 sayısının faktöriyeli 7 *= 7– gibi. yani 7 ye devamlı 7– oda 6 demektir. 6 ile carpımı eklenir, bu 6– ile devam eder. En basit anlatımı bu Sonrada tüm while döngüsü bittikten sonrada faktoriyel’ in sonucu çıktı olarak ekrana gelir. Bu örnekte negatif sayıların faktöriyelini de 1′e eşit tutuyor. Dikkat ediniz. Negatif sayıların faktöriyeli alınmaz şartını koymadık. Şayet siz koymak isterseniz bir if else bloğu yerleştirmelisiniz if(sayi>=0) faktoriyel al yoksa faktoriyel alma gibi.
3. Örnek:
// maas.cpp
// while if-else ile bir maas vergi uygulaması

#include <iostream.h>

int main( )
{
unsigned long maas, net, vergi = 0.0; // maas net vergi bunları tanımladık

cout<< “Lütfen maaşınızı giriniz: “; // maası giriyoruz
cin>> maas; // maası programa alıyoruz

while( maas >= 0.0 ) // maaşın koşlunu yazıyorus döngüye
{
if( maas <= 250000000 ) // maaş 250 milyondan az ise
vergi = 0.0;
else // vergi yok
if( maas < 500000000 ) // maas 500 den az ise
vergi = maas * 0.10; // vergi %10
else // 500 den fazla ise
vergi = maas * 0.20; // vergi %20

net = maas – vergi; // net maaşımız vergi düşünce çıkar
cout<< “Ödenmesi Gereken vergi ” << vergi << endl; // vergi ekranda
cout<< “Net maaşınız: ” << net << endl; // geriye kalan maaşımız

cout<< “Lütfen maaşınızı giriniz: “; // bir dahaki ayki yeni maaşımız
cin>> maas; // maaşı program alıyor

}
return 1;

} Bu örnekte sanırım fazla açıklama yok. Sizden istediğim, üç kişinin maaşını girdikten sonra onların alacağı toplam maaş ve ödemeleri gereken toplam vergiyi bulmanız. Bunu yaparsanız buraya kadar olanlardan bir şeyler anlamışızdır.

Do-while Döngüsü

Do – while Döngüsü:

Bu döngü while döngüsünün biraz değiştirilmiş halidir. Do-while döngüsünde karşılaştırma işlemi, döngünün sonunda gerçekleşir. Bunun sonucu olarak döngünün içine en az bir defa girilmiş olur. Yapısı aşağıdaki gibidir.
do

cümle

while ( koşul ); do’ nun altındaki cümle kısmındaki komut satırları birden fazla olursa diğer döngülerde olduğu gibi ” { } ” içine alıyoruz. Bunu kullanmamız kodları okuma da ve ayırma da daha çok işimize yarayacaktır.
do
{
cümle
cümle
cümle
…
}
while ( koşul ); Şimdi yukarıda demek istediğimizi standart kod satırı üzerinde anlatalım. Kodları yazdığımızda, komut sırası do’ya geldiği zaman, do’ dan sonraki komutun döngünün başı olduğunu belirtiyor. Diğerlerinden farklı ( for, While ) olarak döngüye giriş yapıyor, yani hiçbir kontrol yapmadan en az bir defa döngünün içine girmiş oluyoruz. While’e geldiğinde ise koşulu kontrol ediyor, eğer doğru ise döngünün başındaki komuta giderek yeniden komutları işliyor. Eğer koşul kontrolü yanlış ise while’den bir sonra ki komutu veya komutları işleyip döngüden çıkıyor. Şimdi bu söylediklerimizi örnek üzerinde gösterelim.
//do.cpp
// number echoer
//do-while döngüsünü kullandık

#include <iostream.h>

int main ()
{
unsigned long x;
do {
cout<< “Bir sayı giriniz ( Durdurmak için 0 ) : “;
cin>> x;
cout<< “Girdiğiniz sayı: ” << x << “\n”;
}
while (x != 0);
return 0;
} Örneğimizde de görüldüğü gibi önce do dan sonraki komutlar işleniyor. Şayet 0 girersek while işlemeye başlıyor. Do-while döngüsü C++ da çok fazla kullanılmaz bunun yerine biz for’ u kullanacağız çünkü for döngüsü çok daha güçlüdür.

For Döngüsü

For döngüsünün çalışması, döngünün kontrol değişkenine başlangıç değerinin atanması ile başlar. Aşağıda vereceğimiz ilk değer atama cümlesinden kastımızda budur. Yani bu kısımda başlangıç tanımları yapılır. For döngüsünün başlangıç adımıdır. Bu kısımda yapılan bir değişken tanımındaki değişkenin ömrü, for döngüsünün sonunda biter. Sonra döngü koşul kısmına gelinir ve bu test edilir. Şayet değeri !0, doğru (1) olduğunda döngü içindeki komutlar uygulanır. Arttırma ise for döngüsü işleminin sonunda meydana gelir. for içindeki tüm deyimler meydana geldikten sonra uygulanır.
Genel yapısı:
for ( ilk değer atamalar, koşul, arttırma)
cümle Bunu daha da genellersek, diğerlerinde de olduğu gibi cümleler birden fazla olduğunda komut bloğu arasına alınacaktır.
for ( ilk değer atamalar, koşul, arttırma)
{
cümle1
cümle2
cümle3
…
} Bu söylediklerimizi bir örnek üzerinde izah edelim.
//for.cpp
// for döngüsüyle bir örnek.

#include <iostream.h>
int main ()
{
for (int n=10; n> 0; n–)
{
cout << n << ” -> “;
}
cout<< “Bitti!”;
return 0;
} Ben sadece for (int n=10; n>0; n–) bu kısmı anlatacağım, diğer kısımlar apaçık gözüküyor zaten. For diyip () imizi açtık. Sonra içine ilk basamağımız olan değişken tanımlamamızı yaptık. İnt n=10; Bu bizim yukarıda bahsettiğimiz ilk değer atamalar kısmı. Daha sonra koşulumuzu yazdık. n>0; bunu test ettik ve !0 yani doğru (1) çıktı. Sonrada n– yi yazdık. Genel tanımda yazdığımız arttırma kısmı. Aslında buna yenileme komutları desek daha doğru olur. Biz bu örnekte örneğin azaltma yaptık. Neyse umarım bu for örneğini anlamışsınızdır.
C++ da yapacağımız çoğu örnekte for u kullanacağız. C++ ‘nın en güçlü yanlarından biriside for döngüsüdür. For döngüsünün başında yani ilk değer atama kısmında birden çok değişken tanımlayıp değer atıyorsak bunları virgül ( , ) ile bir birinden ayırmalıyız. İlk değer atamadan koşul bölümüne geçtiğimizde ve koşul bölümünden arttırma ya geçerken noktalı virgül ( ; ) kullanmalıyız. Tabi kullandığımız bu üç kısım seçimlidir istersek boş bırakabiliriz. Fakat, noktalı virgüller ( ; ) konulması zorunludur.
1.Örneğimiz:
//factoriyel_for.cpp
//for döngüsüyle faktöriyel hesap.

#include <iostream.h>

int main()

{
int fac, sayi;

cout<<”Sayıyı giriniz: “;
cin>>sayi;
fac=1;

for (int j=1; j<=sayi; j++)
{
fac=fac*j;
}

cout<<”Sonuc: \a”<< fac;
return 0;

} Bu örneğimiz oldukça basit. Bildiğimiz matematiksel faktöriyel işlemini C++ kodları olarak yazdık. (\a yı kullandım bip! demesi için ).
2.Örneğimiz:
//carpim_for.cpp
// iç içe for döngüsüyle çarpım tablosu

#include <iostream.h>

main()
{
cout<<”Çarpım Tablosu! \n”<<endl;
int x,y;
for (x=1; x<=10; x++)
{
for (y =1; y<=10; y++)
cout<<” “<<x*y;
cout<<”\n”;
}
} Görüldüğü gibi ilk for döngüsünde, birinci bileşen olan x i önce 1 e eşitledik sonra birer arttırarak 10′ a kadar götürdük. Sonraki for da da aynısını y için yaptık ve bu iki bileşeni çarparak ekrana yazdırdık. Son derece basit bir örnek.
3.Örneğimiz:
//asal_for.cpp
// for , if ve while ile asal sayı bulma

#include <iostream.h>

int main()
{
int sayi;
cout << “Bir sayı girinizr: “;
cin >> sayi;

for (int sayac=1; sayac< sayi; sayac++)
{
int asal, test;
test = sayac;
asal = 1;
while (test–> 2)
if ((sayac % test) == 0)
asal = 0;
if (asal == 1)
cout<< sayac << ” bir asal sayıdır!\n”;
}
return 0;
} Bu örneğimizde ikinci örneğimize benziyor. İçinde for, while ve if de var. While ve if’ in içindeki matematiksel ifadeleri biliyorsak örnek gayet basit gelicektir

Break Komutu

Break komutunu, swtich komutundan çıkmak için önceki derslerimizde görmüştük. Komutun kendine özgü bir kullanımı daha vardır. Break komutu bir döngünün içinde çalıştırılırsa o an o döngü biter. Bir goto gibi işlem gördüğünü de söyleyebiliriz. Break kullanınca program döngüyü bitirir ve döngünün sonundaki satırdan çalışmaya devam eder. Bir örnek verelim.
//break.cpp
//break komutunu kullandik.

#include <iostream.h>

main()

{

for (int x = 1; x <= 10; x++) {
if (x == 7) {
break;
}
cout<< x << ” “;
}
} İşte örneğimizde gördüğünüz gibi. X 7′ye eşit olunca break; döngüyü bitiriyor ve döngüden sonraki satırı çalıştırmaya başlıyor.

Continue Komutu

Continue komutu bir döngü içinde çalıştırılırsa , o döngü içinde bulunan tur sona erer ancak döngü devam eder. Diğer bir deyişle, gövdenin içinde bulunan continue komutundan sonra gelen cümleleri atlayarak, döngüyü devam ettirir. Bunu bir örnekle açıklayayım.
//continue.cpp
//continue ve break komutunu kullandik.

#include <iostream.h>

main()

{

for(int i=0; i <= 9; i++)
{
if(i==5)
break;
cout<<i<< endl;
}

for(int x=0; x <= 9; x++)
{
if(x ==3)
continue;
cout<< x;
}

} Bu örnekte break ve continue’yu birlikte kullandım. Hem continue’yu hem de break ve continue karışımını bir arada vermiş oluruz diye düşünüyorum. Örneğimizi inceleyecek olursak. Break olan kısımda görüleceği gibi 5′e kadar döngü devam ediyor, döngü bitiyor ve ondan sonraki cümleye geçiliyor. Sonra yine bir for döngüsü başlıyor ve bu sefer x 3′ e eşit olana kadar devam ediyor. 3′e eşit olunca da if içindeki x==3 koşulunu sınıyor ve continue ye olduğu için bunu atlıyor. Zaten ekran çıktısını aldığınızda ne demek istediğimi daha rahat anlayacaksınız.
Benim size tavsiyem break ve continue komutlarını yapmış olduğunuz basit programlarda kullanmanızdır.

Exit Fonksiyonu

Hayati hata durumlarını ele almak için exit() fonksiyonundan yararlanılır. Bu hatalar main() fonksiyonunu return ile normal olarak sonlandırılmadan önce oluşabilir. Exit() fonksiyonu, durum değerini bir tam sayı parametre olarak döndürür.
Exit() ile özel bir değerin gönderilmesi bazı işlemler yapması için kullanılabilir. Örneğin program komut satırında kullanılıyorsa ve durum değeri bazı hataları gösteriyorsa, işletim sistemi bunları mesaj olarak yazabilir. Exit() fonksiyonu programı sonlandırmanın yanında, tüm bekleyen yazma işlemlerini tamamlar ve açık tüm dosyaları kapatır.
Exit() fonksiyonunu kullanırken kullanmamız gerek kütüphaneler ise process.h ve stdlib.h tır.

Örnekler 1

İşte en güzel kısımlar,eğer buraya kadar birşeyler öğrenebildiyseniz bunları yapmak size çok büyük bir mutluluk verecektir.
-Xazax-

1) //ASCII kodu x olan karakteri buluyorus

#include <iostream.h>
#include <stdio.h>

int main()
{
int ch;

ch = 85;

cout<<”ASCII kodu 85 olan karakter :”;
putc(ch, stdout);
cin>>”\n”;
return (0);
}

2) //Derecenin sin,cos,tan değerlerini bulma
#include <iostream.h>
#include <math.h>

int main()
{
double x; //x i tanımladık

x = 45.0; // 45 derece
x *= 3.141593 / 180.0; // Dereceyi radyal değere döndürme
cout<<”45 derecenin sinusu: “<< sin(x)<<endl;
cout<<”45 derecenin kosinusu: “<< cos(x)<<endl;
cout<<”45 derecenin tanjantı: “<< tan(x)<<endl;
return (0);
}

3) // Haftanın günleri
//switch ve caseleri kullanıyorus.
#include <iostream.h>
#include <stdio.h>

int main()
{
int gun;

cout<<”Lutfen bir karakter giriniz!\n”;
cout<<”(Karakter 1 ile 7 arasında olsun):\n”;
gun = getchar();

switch (gun){
case ‘1′:
cout<<”Pazartesi \n”;
break;
case ‘2′:
cout<<”Salı \n”;
break;
case ‘3′:
cout<<”Çarşamba \n”;
break;
case ‘4′:
cout<<”Perşembe \n”;
break;
case ‘5′:
cout<<”Cuma \n”;
break;
case ‘6′:
cout<<”Cumartesi \n”;
break;
case ‘7′:
cout<<”Pazar \n”;
break;
default:
cout<<”Girdiginiz karakter 1-7 arasında olsun.\n”;
break;
}
return 0;
}

4) //mantıksal operatörler için
#include <iostream.h>

int main()
{

char cocuk, para, araba;

cout << “Çoçuğunuz varmı? (Y/N) “;
cin >> cocuk;

cout << “Çok paranız varmı? (Y/N) “;
cin >> para;

cout << “Spor araba severmisiniz? (Y/N) “;
cin >> araba;

//seçenekleri ben kafadan attım
//maksat burda mantıksal operatörlerin işleyişini görmek
if ((cocuk == ‘Y’) && (para == ‘Y’) && (araba == ‘N’))
cout << “Sizin için en uygun araba Kamyonet ” << endl;
else if ((cocuk == ‘Y’) && (para == ‘Y’) && (araba == ‘Y’))
cout << “Sizin için en uygun araba Toros” << endl;
else if ((cocuk == ‘Y’) && (para == ‘N’))
cout << “Sizin için en uygun araba Renault” << endl;
else if ((cocuk == ‘N’) && (para == ‘Y’) && (araba == ‘N’))
cout << “Sizin için en uygun araba Jeep” << endl;
else if ((cocuk == ‘N’) && (para == ‘Y’) && (araba == ‘Y’))
cout << “Sizin için en uygun araba Bisiklet” << endl;
else if ((cocuk == ‘N’) && (para == ‘N’))
cout << “Sizin için en uygun araba Subaru İmpreza WRX” << endl;

}

5) //sort.cpp
#include <iostream.h>
#include <iomanip.h>
int main()
{
int x[10] = {1, 37, 3, 7, 4, 9, 2, 33, 19, 5};
int counter;
cout << “S\x{0131}ralamadan önce:\n\n”;
cout << “Eleman” << setw(10) << “\x{0130}çerik” <<endl;

// \x{015E}u anki dizinin içeri\x{011F}ini
//gosterir.

for (counter=0; counter<10; counter++)
cout << setw(7) << counter << setw(10) << x[counter] << endl;

// Diziyi s\x{0131}rala

for (int outer=0; outer<10; outer++)
for (int inner=outer+1; inner<10; inner++)
if (x[inner] < x[outer])
{

// De\x{011F}erlerin yerlerini
//de\x{011F}i\x{015F}tir

int temp = x[inner];
x[inner] = x[outer];
x[outer] = temp;
}
cout << “S\x{0131}ralamadan sonra:\n\n”;
cout << “Eleman” << setw(10) << “\x{0130}çerik” <<endl;

// S\x{0131}ralanm\x{0131}\x{015F} dizinin
//içeri\x{011F}ini gösterir.

for (counter=0; counter<10; counter++)
cout << setw(7) << counter << setw(10) <<
x[counter] << endl;
return 0;
}

6) //y=aX^n+bx^(n-1)+…..+zX^0 denkleminin bir noktada türevini bulma

#include <stdio.h>
#include <math.h>

void main(void)
{

int max=11,t,i,denklem[11];
float x,r;

while(max>10)
{
printf(“En büyük X değerinin üst ünü giriniz:”);
scanf(“%d”,&max);
}

for (i=max;i>=0;i–)
{
printf(“X^%d nin katsayını giriniz :”,i);
scanf(“%d”,&denklem[i]);
}

printf (“Türevi hesaplanacak noktayı giriniz :”);
scanf(“%f”,&x);

r= (max*denklem[max]) * pow(x,(max-1));
for (i=(max-1);i>1;i–)
{
r=r + ((i*denklem[i]) * pow(x,(i-1)));
}
r=r + denklem[1];
printf(“Sonuc = %f”,r);
}

Örnekler 2

7) #include <iostream.h>
#include <stdlib.h>
#include <ctype.h>
int main()
{
int idariPersonel=0, yazilimciKadrolu=0, yazilimciProje=0;
double netMaasToplam=0, cesitliKesintiToplam=0, saglikKesintiToplam=0;
//programın en sonunda hesaplayacağı toplamlar.

while(1)
{
cout<<”Personel türü:”<<endl;
cout<<”A-İdari”<<endl;
cout<<”B-Yazılımcı (Kadrolu)”<<endl;
cout<<”C-Yazılımcı (Proje)”<<endl;
cout<<”X-Programdan Çıkış”<<endl;
char tur;
cin>>tur;
tur=toupper(tur);
if(tur==’X') {break;}
switch (tur)
{
case ‘A’ : {
int saat=0, saatUcreti=0;
const int NORMAL=22*8;
double brut=0, net=0, kesinti=0;
cout<<”Toplam çalışma süresini (saat) giriniz: “;
cin>>saat;
cout<<”Saat ücretini giriniz: “;
cin>>saatUcreti;
brut=(double)(NORMAL + 1.5*(saat-NORMAL))*saatUcreti;
//bu satır hem normal hemde fazlamesai de çalışır
net=brut*0.8; kesinti=brut*0.2;
//artık bordor yazılabilir.
cout<<”Bordor bilgileri:”<<endl;
cout<<”Toplam çalışma sürtesi:”<<saat<<”saat.”<<endl;
cout<<”Brüt ücret: \t”<<brut<<”TL.”<<endl;
cout<<”Kesintiler: \t”<<kesinti<<”TL.”<<endl;
cout<<”Net ücret: \t”<<net<<”TL.”<<endl;
//genel hesaplara ilişkin yenilemeler
netMaasToplam+=net; cesitliKesintiToplam+=kesinti;
idariPersonel++;
//switchden çıkıyorus.
break;
}
case’B':{
int saat=0, saatUcreti=0;
const int NORMAL=22*10;
double brut=0, net=0, kesinti=0, saglik=0;
cout<<”Toplam çalışma süresi (saat) giriniz: “;
cin>>saat;
cout<<”Saat ücretini giriniz: “;
cin>>saatUcreti;
brut=(double)(NORMAL+1.5*(saat-NORMAL))*saatUcreti;
//bu satır hem nromal hem de fazla mesai de çalışır.
net=brut*0.65;
kesinti=brut*0.2;
saglik=brut*0.15;
//artik bordro yazılabilir
cout<<”Bordro bilgileri: “<<endl;
cout<<”Toplam çalışma süresi:”<<saat<<”saat.”<<endl;
cout<<”Brüt ücret: \t”<<brut<<”TL.”<<endl;
cout<<”Kesşntiler: \t”<<kesinti<<”TL.”<<endl;
cout<<”Sağlık kesintileri: \t”<<saglik<<”TL.”<<endl;
cout<<”Net ücret: \t”<<net<<”TL.”<<endl;
//genel hesaplara ilişkin yenilemeler.
netMaasToplam+=net;
cesitliKesintiToplam+=kesinti;
saglikKesintiToplam+=saglik;
yazilimciKadrolu++;
//switch den çıkıyoruz.
break;
}
case’C': {
int modul;
double temel=0, modulBasi=0;
double net=0;
cout<<”Temel ücreti girin: “;
cin>>temel;
cout<<”Teslim edilen modül sayısını girin: “;
cin>>modul;
cout<<”Modül başı ücreti girin: “;
cin>>modulBasi;
net=(double) temel+modul*modulBasi;
//artık bordro yazılabilir.
cout<<”Bordor bilgileri:”<<endl;
cout<<”Bitirilen Modül sayısı: “<<modul<<endl;
cout<<”Net ücret: \t”<<net<<”TL.”<<endl;
//genel hesaplara ilişkin yenilemeler
netMaasToplam+=net; yazilimciProje++;
//switch den çıkıyorus
break;
}
default: {
cout<<”Geçersiz personel türü. Yeniden Deneyin.”<<endl;
}
}//switch

cout<<”Başka bir personelin maaşını hesaplamak istiyormusunuz?(E/H)”;
char secenek;
cin>>secenek;
secenek=toupper(secenek);

if(secenek==’H') {break;} //bu while den çıkartır.
else if (secenek==’E'){} //birşey yapma
else {cout<<”Geçersiz seçenek. Ana menüye dönüyor…”<<endl;

//acaba ekranı nasıl temizlerdik?
//Böylece daha güzel görünümlü olan bir programımız olurdu

}//while

cout<<”Oturum İçin Genel Bilgiler:”<<endl;
cout<<”————————————–”<<endl;
cout<<”Toplam İdari Personel: \t”<<idariPersonel<<endl;
cout<<”Toplam Yazılımcı (Kadrolu): \t”<<yazilimciKadrolu<<endl;
cout<<”Toplam Yazılımcı (Proje): \t”<<yazilimciProje<<endl;
cout<<”————————————–”<<endl;
cout<<”Toplam Net ödeme: \t\t”<<netMaasToplam<<”TL.”<<endl;
cout<<”Toplam Cesitli Kesintiler: \t”<<cesitliKesintiToplam<<”TL.”<<endl;
cout<<”Toplam Sağlık Sigortası Kesintisi: \t”<<saglikKesintiToplam<<”TL.”<<endl;
cout<<”————————————–”<<endl;

system(“PAUSE”);
return 0;
} Bu örnek Bora GÜNGÖREN`e ait olan C++ İLE NESNE TABANLI PROGRAMLAMA kitabından alınmıştır.

Fonksiyonlar

1. Fonksiyonlar

Bundan sonraki bölümlerdeki kullanacagimiz derleyici Borland Turbo C++ 4.5 tir. Fazla zorlanmayacaginizi umut ediyorum. Kolay anladiginiz yerlere lütfen dikkat ediniz. Hata yapma olasiliginiz daha da çok artmaktadir. Yapacaginiz hatalar programin çökmesine, belki de sistemin zarar görmesine sebep olabilir. Lütfen vermis oldugum uyarilara ve tavsiyelere uymaya çalisin. Sizin de tavsiyeniz olursa bana bildiriniz. Haydi kolay gelsin…
1. Fonksiyonlara Giris:

Fonksiyonlarin programlama hayatina girmesi ile daha büyük boyutta sistemlerin tasarimi mümkün hale gelmistir. Fonksiyonlar ile alakali derslerimizde, fonksiyonlarin tanimlanmasi ve kullanimi hakkinda bilgi edineceksiniz. Fonksiyonlar konusu size her ne kadar ilk bakista “Fonksiyon” adi altinda bir konu gibi gelse de, aslinda bir alt programdir. Hatta programimizin içine, kodlamamizin daha kolay ve gelistirilebilir hale gelmesini saglayan programciklar da diyebiliriz.
Daha önce baska bir programlama dili gördüyseniz (yüksek seviyeli diller), bu konuda fazla zorlanmayacaksinizdir. Diger yüksek seviyeli dillerdeki fonksiyon kullanimina çok benzemektedir. Hiç bilmediginizi farz ederek konuya giris yapalim.
Fonksiyon Nedir? Örnegin, y=F(x) fonksiyonu; Bu matematiksel fonksiyon parametre olarak aldinan deger üzerinde bir islem gerçeklestirip, bir sonuç degerini döndürür. Mesela F(x)=x^3+5 seklinde bir fonksiyonumuz olsun, x=2 için F(x)=13 olur. Burada x fonksiyonun parametresi, 13 ise fonksiyonun geri döndürdügü degerdir. Simdi de bu matematiksel ifadeyi kodlarimizla yorumlayalim.
Int x;
x=F(2,5)
//buradan da ” int f(2,5) ” gibi görebiliriz… Dikkat edersek ikinci satirda, daha önce islemedigimiz bir kod var. Int x, F(2,5) degerine esitlenmistir. Simdi bir fonksiyonun nasil yazildiginin kalibini çikartabiliriz.
<Döndürdügü deger> <Fonksiyonun adi> ( <parametre listesi> ) {

<ifadeler>
} Buradaki parantezlere ve küme isaretlerine dikkat ediniz. Simdi yukarda yazdigimiz kalibi biraz açalim.
<Döndürdügü deger> : Fonksiyon her hangi bir tipte deger döndürebilir. Bu bilesen fonksiyonun döndürecegi degerin tipini ifade eder. (örnegin, int, dounle, float v.s v.s )
<Fonksiyonun adi> : Yapmak istedigimiz islemin adidir. Örnegin bir asal sayi fonksiyonu yazacagiz. Burada yazacagimiz fonksiyonun adini belirtiyoruz. Benim size tavsiyem AsalSayi veya asal_sayi seklinde kullanmanizdir. Okunabilirlik açisindan size avantaj saglayacaktir.
<parametre listesi> : Fonksiyonun kullanacaga parametrelerin tipleri ile siralanir. Örnegin, FonksiyonAdi(int x, double y) gibi.
<ifadeler> : Fonksiyonun kullanacagi tanimlamalar ve kodlardan olusan kisimdir. Nasil biz main() { kodlar } seklinde kullaniyorsak. Bunu da ona benzetebiliriz. Ama main() i bunlarla karistirmayiniz.
Simdi bu fonksiyon kalibina uygun bir kod yazalim. Örnegin, Faktoriyel bulma islemini ele alalim. Biz bir sayinin Faktörüyelini nasil bulurduk?
n!=n(n-1)(n-2)…1 Yani, 1 den n e kadar olan sayilarin çarpimidir.
long Faktoriyel(int n) {
return n*Faktoriyel(n-1);
} Evet, burada fonksiyonumuzu tanimladik. Sanirim yukaridaki blokla karsilastirinca, ne kadar kolay oldugunu sizde görmüssünüzdür. Simdi bu Faktoriyel fonksiyonumuzu nasil bir programda kullanacagiz? Hemen devamini yazayim.
long Faktoriyel(int n) {
return n*Faktoriyel(n-1);
}
void main() {
cout<<”5! (Bes Faktoriyel)= “<<Faktoriyel(5);
} Iste gördügünüz gibi ne kadar basit degil mi? J Fonksiyonumuzu tanimladik. Sonra programimizda n`e 5 degerini verdik. Faktoriyel fonksiyonu hesaplayip bize söyledi.
Biraz da yaygın yapılan hatalardan ve dikkat etmemiz gereken noktalardan bahsedelim. Kodlama yaparken fonksiyon adini belirttigim sekilde yazarsaniz 30-40 sayfalik kodlarda hata bulmaniz ve de fonksiyonlarin yerini belirlemeniz açisindan büyük kolaylik olucaktir. Yukarida verdigimiz x=F(2,5) fonksiyonununu göz önünde tutalim. Görüldügü gibi F(2,5) degeri x e atanmistir. Hiç bir zaman Fonksiyonun aldigi deger sola yazilmaz. Ayrica bir Fonksiyon çagrisi, baska bir fonksiyonun çagrisi olabilir. Örnegin, x=F(a,F(a,5) gibi. Burada F Fonksiyonun iki parametresi vardir a ve F(a,5) dir. Bu durumda öncelikle parametreler hesaplananacagi için F(a,5) in degeri ile a nin degeri F te parametreler olarak kullanilir.

Tanımlayıcının Görünürlüğünün Kontrolü ve Kendini Çağıran Fonksiyonlar

2. Tanımlayıcının Görünürlüğünün Kontrolü ve Kendini Çağıran Fonksiyonlar

Bir değişkenin görünürlüğü değişkenin etki dizinini gösterir. Bir yerel değişken, tamamen, bir fonksiyon içinde kullanılır. Onun görünürlüğü fonksiyonun içi ile sınırlıdır. Değişkenin görünürlüğü ve ulaşılabilirliğinden sadece fonksiyonun içinde bahsedilebilir. Buna “Scope Kuralları” da denir. Şimdi bunu bir örnek ile izah edelim;
#include <iostream.h>
void main(){
int i=5;
{
int i=1;
cout<<”İçerideki i: “<<i<<endl;

cout<<”Dışarıdaki i: “<<::i<<endl;
}
} Görüldüğü gibi İçerdeki i:1, Dışarıdaki i:5 şeklinde bir çıktı verecektir. Main ide bir fonksiyon gibi görürsek (gerçi özel bir fonksiyondur), denilmek isteneni anlayacaksınızdır.
Kendini tekrarlama, bir fonksiyon kendini çağırdığında oluşur. Başlangıçta bu sonsuz döngü gibi gözükür, ancak öyle değildir. C++ kendini çağırmayı destekler. Bunu bir fonksiyonun döndürdüğü değeri bulabilmesi için içindeki bir parametrenin de fonksiyon olması gibi değerlendirebiliriz. Hani başta vermiştik ya: F(x,F(x,y) gibi…

İnline Fonksiyonlar

3. İnline Fonksiyonlar

C++ `ın C ye ek olarak getirmiş olduğu bir özellikte inline fonksiyonlardır. Anlamak için basit bir örnekle başlayalım. Örneğin öyle bir program yazıcağız ki, aşırı miktarda kare alma işlemi yapmamız gerekecek ve bunun için herhangi bir fonksiyon çağırmıyor olalım. Bu durumda define komutu ile derleyiciye şu şekilde bir komut veririz:
#define kare(x) x*x İşlemin sonunda ; olmamasına dikkat ediniz. Kullanımına gelince de,
y=kare(x); bu durumda derleyici derleme aşamasında bütün kare(x) `leri x*x olarak yorumlayacaktır. Burada dikkat edilmesi gereken yer, #define topla(x,y) x+y ve kullanımda da z=topla(x,y)*topla(x,y); işte işlem sırasının vermiş olduğu hatayı görüyorsunuzdur. Tabi bunu da parantezlerle ayıracağız. Şimdi bunu C++ tam uyarlarsak, inline kelimesini, bir direktif olarak yada C++ derleyicisine fonksiyonu tek satıra koyması önerisi olarak düşünebiliriz. Derleyici bir çok nedenden dolayı bunu kabul etmeyebilir. Mesela, Fonksiyon çok uzun olabilir, Döngü içeren bir fonksiyon, değişken tanımı içeren bir fonksiyon, kendini çağıran bir fonksiyon her zaman inline olmaz.
//kup.cpp
//Kupun hacmini bulma
#include <iostream.h>

//inline fonksiyonumuz
//——————
inline double kup( const double x)
{

return x * x * x;

}
//———————

int main()
{
cout << “Kübün bir kenar uzunluğunu giriniz: “;

double kenar;

cin >> kenar;
cout << “Kenar” << kenar << “olan kübü

Fonksiyon Yüklemesi ve Prototipleri

4. Fonksiyon Yüklemesi ve Prototipleri

Şimdi C++ `ın getirmiş olduğu başka bir özellikten daha bahsedeceğiz. Aynı isimli fonksiyonların farklı işlemler yapabilmesi. Aynı şekilde çağrılacaklardır, fakat derleyici bunların farklı fonksiyonlar olduğunu anlayacaktır. Tabi bunun şartları var. Fonksiyonların tipleri yada bunların sıraları farklı olmalıdır. Fonksiyonların başında kalıbın tanımını yaparken, parametre listesinden bahsetmiştik. Bu parametreler belli değerler döndürürler, işte derleyicide bu döndürdüğü değerlere yani imzalarına göre bunların farklı fonksiyonlar olduğunu anlayacaktır. Tabi bunların sıraları da farklı fonksiyonlar gibi gözükmelerini sağlayacaktır. Hemen olayı anlamak için örnek verelim.
double Ortalama(int *dizi, int uzunluk){
//kodlar
}
double Ortalama(double*dizi, int uzunluk){
//kodlar
} Görüldüğü gibi bu iki fonksiyon da bir birinden farklıdır. Her ne kadar isimleri aynı olsa da…
Fonksiyon tanımlamasının fonksiyon kullanılmadan önce yapılmış olması gerekmektedir. Fonksiyonlarımızı header başlığı altından çağırabiliriz. Mesela ben daha önce bir Faktoriyel fonksiyonu yazip bunu Fakt.h olarak saklıyorum. Programımı yazarken #include <Fakt.h> diyerek bunu çağırıyorum ve programda yazdığım “5′in faktoriyelini al” dediğim zaman direk Fakt.h taki fonksiyonda işlemi yapıp aldığı değeri programa verir. Mümkün olduğunda C++ ın kendi kütüphanelerindeki hazır fonksiyonları kullanmaya çalışacağız. Var olan bir fonksiyonu yeniden yazmanın pek bir anlamı olmaz. İleride kütüphanelerdeki fonksiyonları da mümkün olduğunca göreceğiz.

n hacmi = “
<< kup (kenar) << endl;
return 0;
}

ORACLE nedir?Temel Kavramlar

                                                                                   ORACLE
İlişkisel Veritabanı Yönetim Sistemleri (Relational Database Management Systems – RDBMS) büyük miktarlardaki verilerin güvenli bir şekilde tutulabildiği, bilgilere hızlı erişim imkanlarının sağlandığı, bilgilerin bütünlük içerisinde tutulabildiği ve birden fazla kullanıcıya aynı anda bilgiye erişim imkanının sağlandığı programlardır. Oracle veritabanı da bir ilişkisel veri tabanı yönetim sistemidir.
Oracle veritabanının özellikleri şunlardır:
Büyük miktarda veri tutabilmekte ve verilerin depolandığı alanları ayarlama imkanı vermektedir.
Aynı anda çok sayıda kullanıcıya verilerin bütünlüğünü bozmadan hizmet verebilmektedir. Oracle 8 sürümü ile birlikte on binlerce kullanıcıya hizmet verebilmektedir.
Günün 24 saati ve haftalar boyu hiç kapatılmadan çalışabilmektedir.
İşletim sistemi, veri erişim dilleri ve ağ iletişim protokolleri standartlarıyla uyumludur.
Yetkisiz erişimleri engelleme ve kontrol edebilme imkanı sağlamaktadır.
Bütünlüğü veritabanı düzeyinde sağlayabilmektedir, böylece daha az kod yazılmaktadır.
İstemci/Sunucu mimarisinin bütün avantajlarını kullanabilmektedir.
Oracle ile ilk defa karşılaşan kullanıcılar genellikle Delphi, Visual Basic gibi görsel programlama dillerine benzeyen uygulamalarla karşılaşmayı umarlar. Oysa ki yukarıda da belirttiğimiz gibi Oracle bir ilişkisel veritabanı yönetim sistemidir. Yani bir programlama dili değildir. Fakat Oracle tarafından geliştirilen ve Oracle’ın kendi uygulama geliştirme araçları içerisinde kullanılan bir programlama dili vardır. Oracle ürünleri genellikle büyük çaplı veri kontrolünü gerektiren uygulamalarda kullanılır. Öncelikle bir ağda Oracle veritabanı sadece sunucu olarak adlandırılan bilgisayara yüklenir. Bu sunucu Oracle’ın desteklediği herhangi bir işletim sistemiyle çalışıyor olabilir. Yani Oracle’ın faklı işletim sistemleri için farklı sürümleri vardır. Bu sunucu bilgisayara kurulan veritabanı üzerinde tablolar, indeksler, eşanlamlar,tablo uzayları ve ihtiyaç duyulan kayıtlı prosedürler oluşturulur. Bunlar raporun sonraki bölümlerinde anlatılmaktadır. Oracle’ın bu veritabanına erişerek uygulama programı geliştirmeye yarayan diğer ürünleri de istemci bilgisayarlara kurulur. Tabi sunucu bilgisayara da isteğe bağlı olarak bu ürünler kurulabilir. Şimdi Oracle ürünlerini daha ayrıntılı olarak inceleyelim.
Oracle Ürünleri
Aşağıda şu an kullanımı en güncel olan değişik Oracle ürünleri tanıtılımıştır.
Oracle RDBMS
Oracle ilişkisel veritabanı yönetim sistemi Oracle şirketinin ana ürünüdür. Bu ürünün şu an en yeni sürümü Oracle9i RDBMS’dir. Biz bu çalışmada bir önceki sürüm olan Oracle8i’yi esas alacağız. Oracle 8i’den bir önceki sürüm Oracle 7 ve onun bir önceki sürümü de Oracle 6’dır.
Oracle Uygulama Geliştirme Araçları
Oracle’ın veritabanı uygulamaları geliştirmek için görsel ürünleri bu grupta yer alır. Oracle’ın program geliştirmek için kullanılan bu ürünlerinin eski adı Oracle Power Objects idi. Daha sonra Oracle Developer 2000 ve sonra da Oracle Developer 6 ürünleri geliştirildi. Developer 2000 ve Developer 6 içerisinde Form Builder, Report Builder, Graphics Builder, Procedure Builder ve Schema Builder ürünlerini içerir. Form Builder kullanıcıya sunulacak arayüzlerin geliştirildiği programdır. İşte bu uygulama görsel bir programlama dilinin uygulama geliştirme ortamına benzer. Report Builder ürünü veritabanından elde edilen bilgiler ile raporlar hazırlamaya yarar. Özellikle banka ve kamu kuruluşlarının ihtiyacı olan fatura, evrak gibi belgelerin hazırlanıp, çıktı alınması için geliştirilmiş bir programdır. Procedure Builder sürekli kullanılacak kodların prosedürler halinde oluşturulup, kütüphaneler olarak kaydedilmesi işlemine yarayan bir programdır. Schema Builder ise veritabanı nesnelerinin görsel olarak oluşturulabilmesi için geliştirilmiş bir uygulamadır. Burada tablo, görüntü, eşanlam oluşturma, tablolar arası ilişki kurma,tablo kısıtlamaları oluşturma işlemleri görsel olarak yapılabilir.
SQL*Plus
SQL*Plus, Oracle veritabanında sorgulama yapmak ve SQL komutlarını çalıştırmak için kullanılan bir araçtır. SQL*Plus’da SQL komutlarının yanısıra PL/SQL komutları da kullanılabilmektedir. Bu çalışmanın diğer bölümlerinde anlatılan SQL komutları SQL*Plus kullanılarak hazırlanmıştır.
PL/SQL
PL/SQL (Procedural Language/SQL), yapısal dillere ait özelliklerin standart SQL’e eklenmesiyle ortaya çıkan Oracle’a has bir dildir. PL/SQL Oracle firmasının piyasaya sürdüğü her üründe önemli bir yere sahiptir. Kullanıcılar PL/SQL’i kullanarak programlarına bir çok yeni özellikler katmaktadırlar. Bunlar arasında;
PL/SQL tabanlı kaydedilmiş yordamlar(stored procedures) ve veritabanı tetiklemeleri(triggers) ile önemli iş kurallarını programlamak
Oracle Developer ürünleri ile güçlü ve kolay kullanılabilir görsel ortamlarla programları detaylandırmak ve daha rahat kontrol etmek
Oracle tabanlı uygulamalarda nesne-tabanlı(object-oriented) tasarımlar yapma Web sayfalarından Oracle veritabanlarına link yapma
PL/SQL’in belki de en önemli özelliği istemci-sunucu ortamları tasarlama ile ağ üzerinde dağıtık işlemler yapma ve bir çok sorguyu çalıştırma imkanı sunmasıdır. PL/SQL dili Ada dilinden sonra tasarlanmıştır. PL/SQL’de en gelişmiş yordamsal dillerde olan veri tipleri, blok yapısı, şartlara bağlı ve bağlı olmayan kontrol cümleleri, bir çok döngü tipi, hata durumlarında kullanılacak yordamlar ve kullanıcı tarafından tanımlanabilecek nesneler yer almaktadır.
Net8
Net8 Oracle’ın bir ağ ürünüdür. Farklı bilgisayarların veritabanına bağlantı kurması ve ve istemci-sunucu arasında veri alışverişinin sağlanabilmesi Net8’in ana görevidir. Net8 ağdaki her bilgisayara kurulur. Ağ bağlantısı sağlandığında NET8 istemci ile sunucu arasında bir veri taşıyıcısı gibi işlem görür.

Ağ üzerinde bir istemcinin sunucudaki veritabanına erişebilmesi için, sunucuda bir ağ servis adının(Net Service Name) ve bir dinleyicinin(LISTENER) oluşturulması gerekir. Oracle Enterprise Edition ile birlikte gelen Net8 Assistant ile bu gerçekleştirilebilir. Ağ servis adları, veritabanı gibi bir servisi ağda tanımlamak amacıyla basit bir yöntem olarak kullanılır. Bir kullanıcı ağ servis adını kullanarak bağlantısını şöyle sağlar:
Connect kullanıcı_adı/şifre@ağ_servis_adı
Aşağıda Ne8 Assistant görüntüsü verilmiştir. Verilen şekilde ağ erişimi oluşturmak için gereken işlemler oldukça basittir. Bir ağ servis adı oluşturmak için “Ağ Servis Adları” dizininin üzerine gelip, yandaki artı işaretini tıklamak gerekir. Bundan sonra bazı bilgiler girmemiz istenir. Önce kullancağımız ağ servis adı bilgisi girilir, sonra iletişimde kullanılacak TCP/IP, SPX gibi protokollerden uygun olanın seçilmesi işlemi tamamlanır. Bundan sonra ana bilgisayar adı ve port numarası girilir. Ana bilgisayar adı veritabanının yüklü olduğu bilgisayarın adıdır. Port numarası ise Oracle’ın veritabanları için kullandığı standart numara olarak 1521 girilir. Bu işlemden sonra veritabanın sürümü seçilir ve veritabanı oluşturulurken girilen SID adı bilgisi verilir. Girilecek tüm bilgiler bu kadardır. Erişimin sağlanıp sağlanmadığını anlamak için “Test” butonu ile bağlantı denemesi yapılır. Ağ servis adları TNSNAMES.ORA adlı dosyaya haydedilir. Bu dosyada yaptığımız bir kayıt şu şekilde yer alır.
OGR =
(DESCRIPTION =
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST = bavenoglu)(PORT = 1521))
)
(CONNECT_DATA =
(SERVICE_NAME = ogr)
) )
Ağ erişimi dinleyici(LISTENER) adı verilen bir yardımcı programla sağlanır. Net8 Assistant içerisinde bir dinleyici oluşturulabilir. Bir istemci sunucuya bağlanmak istediğinde bu isteği dinleyici karşılar ve istemcinin konfigürasyon bilgileri ile kendi bilgilerini karşılaştırır eğer uygunsa bağlantı sağlanır. Dinleyicinin konfigürasyonu ile ilgili bilgiler LISTENER.ORA dosyasında saklanır.

SQL*Net
SQL*Net Net8’in yardımcı programıdır. Bir istemci bilgisayara Oracle Forms ürününün yüklendiğini düşünelim. Bunun için istemci bilgisayar SQL*Net ile oluşturulan veritabanı takma adını(alias) kullanır. Yukarıda Net8 konfigürasyonunun istemci bilgisayarlarda da yapılması gerektiğini söylemiştik. İşte bu konfigürasyon istemci bilgisayarlarda SQL*Net sayesinde yapılır. Burada veritabanına verilecek takma isim, protokol adı, ana bilgisayar adı(veritabanının bulunduğu) ve veritabanının SID olarak girilen ismi bilgileri girilerek düzenleme yapılır.
Oracle8i Enterprise Edition ve Gerekli Donanım
Bu rapor Oracle8i Enterprise Edition for Windows NT Release 8.1.5 sürümü üzerine düzenlenmiştir. Oracle8i Enterprise Edition CD’sinde üç farklı ürün yer almaktadır:
Oracle8i Enterprise Edition (Server)
Oracle8i Client
Oracle Programmer

Oracle8i Enterprise Edition(Windows NT)

Yükleme Türü Açıklama
Typical Tam anlamıyla bir veritabanı kullanmak isteyenler için tavsiye edilen yükleme türüdür. Bir başlangıç veritabanı, ağ servisleri, Oracle yardımcı ürünleri ve yardım dokümanları yüklenir.720 MB yer kaplar. Pentium 133 ya da Pentium 166 işlemci ile kurulabilir. Önerilen işlemci Pentium 200 dür. 96 MB RAM ile çalışabilir. Tavsiye edilen bellek ise 128 MB ‘tır.
Minimal Minimum veritabanı paketi kullanmak isteyenler için önerilir. Bir başlangıç veritabanı, ağ servisleri ve bazı yardımcı ürünleri içerir. 520 MB yer kaplar. Pentium 133 ya da Pentium 166 işlemci ile kurulabilir. Önerilen işlemci Pentium 200 dür. 64 MB RAM ile çalışabilir. Tavsiye edilen bellek ise 96 MB ‘tır.

Oracle8i Client(Windows NT ve Windows 95/98)

Yükleme Türü Açıklama
Typical Veritabanı yöneticileri için veritabanına bağlanma ve veritabanı yönetim işlerini gerçekleştirme araçlarını yükler. 299 MB yer kaplar. Intel 80486 işlemci ile çalıştırılabilir. Tavsiye edilen Pentium 133 ya da Pentium 166 dır. En az 32 MB RAM ile çalıştırılabilir. Önerilen 64 MB’tır.

Oracle Programmer(Windows NT ve Windows 95/98)

Yükleme Türü Açıklama
Typical Veritabanına erişebilen geliştirme araçları ve ara yüzlerini yükler. Bu paket, ön derleyicileri(precompilers), ağ servislerini ve yardım dokümanlarını içerir. 267 MB yer kaplar. Intel 80486 işlemci ile çalıştırılabilir. Tavsiye edilen Pentium 133 ya da Pentium 166 dır. En az 32 MB RAM ile çalıştırılabilir. Önerilen 64 MB’tır.

Oracle8i Enterprise Edition Kurulumu
Kuruluma başlamadan önce Windows NT sistemine “Administrator” olarak girin.
Eğer sistemde Oracle’ın daha önceki sürümleri varsa StartàControl PanelàServices içerisinde tüm Oracle ile başlayan servisleri seçip, sağ tıklayın ve açılan menüden “Stop” seçeneğini seçin.
CD-Rom’u takın ve otomatik olarak çalışmasını bekleyin. Eğer çalışmazsa cd-rom sürücü dizinine geçip Setup.Exe dosyasını çalıştırın.
Şimdi “Oracle Universal Installer“ olarak adlandırılan ürün yükleme sihirbazının çalışmış olması gerekir. Bu ana pencerede “Install/Deinstall Products” seçeneğini tıklayın.
İlk karşınıza gelen tanıtım penceresidir. Burada daha önce yüklenmiş ürünlerin listesi görülebilir. Yeni yükleme için “İleri” butonunu tıklayın.
“Dosya Yerleşimleri” penceresinde kaynak ve hedef dizin ve dosya adları belirtilir. Kaynak dizin E:\STAGE\PRODUCTS.JAR şeklinde otomatik olarak belirtilir. Bu dizin adı değiştirilmemelidir.
Hedef olarak bir Oracle giriş dizini adı ve yolu girmeniz beklenir. Otomatik olarak giriş dizini adı için “OraHome81” ve yolu içinde “C:\Oracle\Ora81” belirtilir. Bu alanlar değiştirilmeden “İleri” butonu tıklanabilir.

Ürün bilgileri listesinin yüklenmekte olduğunu belirten bir pencere geldikten sonra karşınıza “Yüklenebilecek Ürünler” penceresi gelir. Yukarıda da anlattığımız gibi burada üç ürün vardır. Oracle8i Enterprise Edition seçeneğini işaretleyerek “İleri” butonuna basın.
“Yükleme Türleri” penceresinde tipik, minimum ya da özel seçeneklerinden biri seçilerek “İleri” butonuna basılır.
Eğer tipik yükleme, ya da özel yükleme seçildiyse burada Oracle yardım dosyalarını diskten ya da CD-Rom’dan çalıştırma seçeneklerinden birini seçmeniz beklenir. Eğer diskte yaklaşık 133MB boş yeriniz varsa diske yükleme seçeneğini seçebilirsiniz.
Bilgisayarınızda daha önceden yüklü bir Oracle veritabanı varsa bu kısımda bunu güncellemek isteyip istemediğinizi soran bir pencere gelir. “Migrate an Existing Database” kutusunu işaretlerseniz yüklemeden hemen sonra “Oracle Data Migration Assistant” programı çalışır ve eski veritabanınızı yeni sürüme terfi ettirir.
“İleri” butonunu tıkladığınızda karşınıza “Database Identification” penceresi gelir. Burada “Global Database Name” ve “SID” alanlarını doldurmanız istenir. Buraya vereceğiniz isim veritabanının adı olacaktır. Bu alanlardan birini doldurduğunuzda diğeri de aynı değeri otomatik olarak alır.

“İleri” butonunu tıkladığınızda genel ayarlar, ürün dilleri, alan gereksinimleri ve yeni yüklenecek ürünleri kapsayan bir liste gelir. Listede değişiklik yapılamaz. Sadece bildiri amaçlı bir listedir.
“İleri” butonunu tıkladığınızda ürünler yüklenmeye başlar. Oracle8i Enterprise Edition sürümünün tipik olarak yüklenmesi minimum donanım ayarlarında yaklaşık yarım saat sürer.
Dosyaların kopyalanması bittikten sonra “Konfigürasyon Penceresi” gelir.Veritabanının oluşturulması, başlatılması ve ağ ayarlarının yapılması burada otomatik olarak yapılır. Veritabanı oluşturma işlemleri bittikten sonra karşınıza giriş şifrelerinin ve veritabanı ile ilgili bazı bilgilerin verildiği bir pencere gelir. Buradaki şifreler daha sonra veritabanı yönetimi için kullanılacak şifreler olduğundan, önemlidir.

Bu işlemler tamamlandıktan sonra “Universal Installer” kapatılabilir.
Oracle8i Enterprise Edition Ürününü Kaldırma
Bu ürünü kaldırmadan önce StartàControl PanelàServices seçilerek çalışan tüm Oracle servisleri kapatılmalıdır.(“Oracle” kelimesi ile başlayan tüm servisler)
“Start > Programs > Oracle Installation Products > Universal Installer” seçilerek yükleme asistanı çalıştırılmalıdır.
Burada “Yüklü Ürünler” butonu tıklanır.
Kaldırmak istenilen ürünlerin solundaki kutular tıklanarak boşaltılır ve “Kaldır” butonuna basılır.
Ekrana bu kaldırılacak ürünlerin listesi gelir ve kaldırmak için son kez onay istenir.
“Evet” butonuna tıklanırsa seçili ürünler kaldırılır. Sonra “Universal Installer” kapatılabilir.
Oracle Veritabanı Yapısı
Oracle veritabanının, işletim sistemi tarafından bakıldığında, biri fiziksel diğeri mantıksal olmak üzere iki bölümü vardır. Fiziksel bölüm, işletim sisteminden görünen kısımdır. Bunlar Data File(Veri Dosyası), Control File(Kontrol Dosyası) ve Log File(Log Dosyası) ‘dan oluşmaktadır. Mantıksal Bölüm, bir ya da daha fazla tablo uzayı(Tablespace) ve tablolar(table), görüntüler(view), sıralar(sequence), eşanlamlar(synonym), indeksler(index), kümeler(cluster), veritabanı bağlantıları (database link), prosedürler(procedure), fonksiyonlar(function), ve paketlerden(package) oluşan şema nesnelerinden oluşmaktadır. Fiziksel bölüm işletim sistemi tarafından görülebilmesine rağmen, mantıksal bölüm ancak Oracle’a bağlanıp, SQL komutları çalıştırılarak görülebilmektedir. Yani, Oracle kurulu herhangi bir makinede, SQL bilgisi olmayan bir insan, Oracle’ın sadece fiziksel bölümünü görebilmektedir.
Oracle veritabanındaki her nesnenin bir sahibi(kullanıcı olarak bahsedilir) vardır. Her kullanıcı bir veya daha fazla tablo uzayına sahip olabilir. Her nesne, ait olduğu kullanıcının herhangi bir tablo uzayında (mantıksal olarak) bulunur. Her tablo uzayı da, kendisine sahip olan kullanıcının nesnelerini tutmak için işletim sisteminde bir veya daha fazla veri dosyasına sahip olabilmektedir.
Sonuç itibariyle, veritabanındaki her nesnenin bir kullanıcısı vardır ve bu nesneler mantıksal olarak o kullanıcının sahip olduğu tablo uzaylarının herhangi birinin (hangisi olduğu komutlarla öğrenilebilir) içerisinde, fiziksel olarak da o kullanıcının sahip olduğu tablo uzayının herhangi bir veri dosyasında bulunur. Fakat, o veri dosyasının içerisine işletim sisteminden bu nesneyi bulmak için bakılamaz. Bu nesnenin sahibi ve mantıksal yeri “DML”(veri işleme dili) komutları ile bulunabilmektedir.
Fiziksel Bölüm
Fiziksel bölüm veritabanını oluşturan işletim sistemi dosyalarıdır. Bir Oracle veritabanı fiziksel olarak bir ya da daha fazla veri dosyası, iki ya da daha fazla log dosyası, bir ya da daha fazla kontrol dosyasından oluşur.
Veri Dosyaları(Data Files)
Veri dosyaları veri tabanındaki tüm verileri tutan dosyalardır. Tablo, indeks gibi mantıksal veritabanı yapılarının içerisindeki veriler fiziksel olarak veri dosyalarında tutulurlar. Bir veri dosyası kendisi için ayrılan alan dolduğunda, kendi sahip olduğu alanı artırabilecek özelliklere sahiptir. Bir ya da daha fazla veri dosyası mantıksal bir veritabanı depolama ünitesi olan bir tablo uzayını oluşturular.
Normal veritabanı işlemleri boyunca bir veri dosyası içerisindeki veriler okunur ve Oracle için ayrılan belleğe getirilirler. Örneğin bir kullanıcının veritabanındaki bir tablonun verilerine erişmek istediğini varsayalım. Eğer istenilen veriler bellekte yer almıyorsa, ancak o zaman uygun veri dosyasından okunur ve belleğe getirilirler.
Değişikliğe uğrayan veriler ya da yeni eklenen veriler veri dosyalarına hemen yazılmazlar. Sabit diske erişimi azaltmak ve böylece sistemin performansını artırmak için veriler bellek havuzunda tutulur ve gerektiğinde hepsi birden uygun veri dosyalarına kaydedilirler. Bunu Oracle artalan işlemleri belirler.
Kontrol Dosyaları(Control Files)
Tüm Oracle veritabanları kontrol dosyasına sahiptir. Bir kontrol dosyası veritabanı adı, veri dosyaları ve log dosyalarının adı ve diskteki yeri, veritabanının oluşturulma tarihi vb. veritabanı ile ilgili bilgileri tutar.
Her veritabanı oturumu açıldığında Oracle bu dosyayı kontrol ederek gerekli bilgileri alır. Eğer veritabanında fiziksel bir değişme olursa(yeni bir log dosyası ya da veri dosyası oluşturulması gibi), yapılan değişiklikler Oracle tarafından otomatik olarak kontrol dosyalarına yansıtılır.
Log Dosyaları(Log Files)
Redo Log dosyaları olarak bilinen bu dosyaların amacı veriler üzerinde yapılan tüm değişiklikleri kaydetmektir. Eğer veri dosyalarına kalıcı olarak kaydedilmiş olan, değişikliğe uğramış kayıtlarda bir bozukluk olursa yapılan değişiklikler redo log dosyalarından sağlanabilir ve işlemler kaybolmaz. Birden fazla tekrarlanan bozukluk durumlarında redo log dosyalarının da bozulmasını engellemek için Oracle farklı diskler üzerinde redo log dosyalarının birden fazla kopyasının alınmasına olanak sağlar.
Bir veritabanı işlemi sırasında elektrik kesilirse, bellekteki veriler veri dosyalarına kaydedilmeyecek ve verilerin kaybolması durumuyla karşılaşılacaktır. Oracle veritabanı tekrar açıldığında redo log dosyalarında yapılan son değişiklikler veri dosyalarına yansıtılarak verilerin kaybolması engellenir.
Mantıksal Bölüm
Oracle veritabanının mantıksal yapısı tablo uzaylarını(tablespaces), şema nesnelerini(schema objects), veri bloklarını(data blocks), genişlemeleri(extents) ve parçaları(segments) içerir.
Tablo Uzayı(TableSpace)
Bir veritabanı, ilişkili mantıksal yapıların gruplanmasını sağlayan ve tablo uzayı olarak bilinen mantıksal depolama ünitelerine bölünmüştür.

Yukarıdaki şekil veritabanı, tablo uzayı ve veri dosyaları arasındaki ilişkiyi açıklamaktadır. Buna göre:
Bir veritabanı bir ya da daha fazla tablo uzayına bölünmüştür.
Tablo uzayı içerisindeki tüm mantıksal yapıları fiziksel olarak depolayabilmek için, her tablo uzayı bir ya da daha fazla veri dosyasına sahip olabilir.
Tablo uzaylarının toplam kapasitesi, sahip oldukları veri dosyalarının toplam kapasitesine eşittir.(Yukarıdaki şekil için SYSTEM tablo uzayı 2MB, USERS tablo uzayı 4MB).
Tablo uzaylarının toplam kapasitesi veritabanının toplam kapasitesini belirler.(6 MB)
Bir tablo uzayı açık ya da kapalı olabilir. Tablo uzayı kapalı olduğunda bu tablo uzayının içerisindeki nesnelere erişilemez. Bir tablo uzayı yönetim amaçlı olarak kapalı duruma alınabilir.
Veri Tabanı Şema Nesneleri
Şema nesneleri mantıksal veri depolama yapıları olarak bilinir. Veritabanı üzerinde kullanıcının belirli işleri yapabilmesi için tanımlanan bu yapılar tablolar, görüntüler, sıralar, eşanlamlar, indeksler, kümeler, veritabanı bağlantıları, prosedürler, fonksiyonlar, ve paketlerdir. Bir şema ise bu nesnelerin oluşturduğu gruptur.

Küme(CLUSTER)
Aynı anda sorgulanan birden fazla tablonun bir arada kaydedilmesine “cluster” denir. Bu yapı, beraber sorgulanan tablolarda hız kazanmak için çok önemlidir. Örneğin “isci” tablosu ile “bolum” tablosunun(bu tabloların yapısı için SQL bölümüne bkz.) her ikisi de ortak olarak “bolum” ve “bolumno” alanlarını içermekte. Yani “isci” tablosundaki “bolum”, “bolum” tablosundaki “bolumno” alanına karşılık geliyor. Burada oluşturulacak bir cluster’da her iki tablo veritabanında yan yana getirilerek aynı veri bloğu içerisine kaydedilir.Böylece daha hızlı erişim sağlanır.
İndeks(INDEX)
İndeksler tablo ve cluster’lar için kullanılan veri tabanı nesneleridir. Burada amaç aranılan bir kayda daha hızlı erişimdir. Özellikle üzerinde çok arama yapılan alan veya alanlar üzerinde indeks oluşturmak çok etkilidir. İndeks oluşturulduğunda ilgili tablonun kayıtları yer değiştirmez. Sadece ilgili kayıtların kayıt numaraları olarak adlandırılan “rowid” ‘ler alınarak sıralama yapılır.
Bir tablo üzerinde oluşturulabilecek indeks sayısı sütunların kombinasyonları farklı olduğu müddetçe sınırsızdır. Bir sütun diğer sütunlarla değişik kombinasyonlarda kullanıldığı müddetçe birden fazla indeks içerisinde yer alabilir. Aynı sütun kombinasyonlarının indeksi, faklı indeks ismi kullanarak oluşturulmaya çalışılsa bile gerçekleştirilemez.
İndeksleme işleminin gerçekleştirilmesinde Oracle çoğunlukla B-tree indeksleme metodunu kullanır. Bunun yanında “hash cluster indexes”, “reverse key indexes”, ve “bitmap indexes” yöntemlerini de kullandığı bilinmektedir.
İndeksler mantıksal ve fiziksel olarak oluşturuldukları tablodan bağımsızdırlar. Eğer bir indeks silinirse, ilgili tablo zarar görmez, çalışmaya devam eder. Fakat indeks olmadığı için veri erişim süresi artacaktır.
Oracle bir indeks oluşturulduğunda onu otomatik olarak kullanmaya başlar ve indeksin oluşturulduğu tablodaki silme, güncelleme ve ekleme işlemleri indekse otomatik olarak yansıtılır.
Rol(ROLE)
Oracle veritabanında her nesnenin ait olduğu bir kullanıcı vardır. Bir kullanıcı bir başka kullanıcının nesneleri üzerinde işlem yapmak isterse buna hakkı olması gerekir. Bir nesne üzerinde işlem yapabilme yetkisine hak denir. Örneğin veritabanına bağlanma, tablo oluşturma, bir başkasına ait tablodan kayıt listeleme, bir başkasının prosedürünü çalıştırma birer haktır. Bu haklar kullanıcılara atanmak suretiyle kullanıcıların bu işlemeleri gerçekleştirmeleri sağlanır. Hakların kullanıcılara atanması iki şekilde olabilir. Birinci olarak bir tabloya kayıt ekleme, kayıt silme vb. haklar bir kullanıcıya ya da kullanıcılara ayrı ayrı atanır. İkinci şekilde ise verilmek istenen haklar bir rol altında birleştirilir ve bu rol istenen kullanıcılara aktarılır.
Haklar “sistem hakları” ve “nesne hakları” olmak üzere ikiye ayrılır. Sistem hakları veritabanı ile ilgili olarak önceden tanımlanmış rollerdir. Oracle’da 60’tan fazla sistem hakkı tanımlanmıştır. Nesne hakları ise veri tabanı nesneleri üzerinde işlem yapma haklarıdır. “Create Table”, “Create TableSpace”, “Drop Any Index” gibi haklar sistem haklarına örnek olarak verilebilir. Nesne hakları ise 8 çeşittir. “Select”, “Insert”, “Update”, “Delete”, “Alter”, “Index”, “Execute”, “References”, “All” çeşittir. “All” ayrı bir hak olarak adlandırılmaz. Diğer tüm hakları kapsar. Bu haklar sırayla kayıt seçme, kayıt güncelleme, kayıt silme, nesnelerin yapısını değiştirme, indeks oluşturma, alt program çalıştırma, yabancı anahtar tanımlayabilme işlemlerini içerirler. Rol tanımlama ve hak verme komutları ileride ayrıntılı olarak işlenecektir.
Geri Alma Parçası(ROLLBACK SEGMENT)
Oracle veritabanının güvenliği açısından “Select”, “Insert”, “Update”, “Delete” gibi işlemlerin yedeğini almaktadır. Alınan bu yedeklerin konulduğu yerlere geri alma parçası denir. Kullanıcı bu tip işlemleri yaptıktan sonra “Rollback” komutunu uygularsa, yaptığı değişiklikler geri alma parçalarından getirilir ve böylece kayıtlar eski haline dönmüş olur. Kullanıcı “Commit” komutunu verirse yaptığı değişiklikler geri alma parçalarından geri getirilemez. Her veritabanında bir ya da birkaç tane geri alma parçası olabilir.
Sıra(SEQUENCE)
Tablolardaki kayıtlar için otomatik sıra numarası verilmesi isteniyorsa sıra nesnesi kullanılabilir. Bu sıra numarası veritabanı tarafından otomatik olarak üretilir. Özellikle çok kullanıcılı ortamlarda tekil olarak numara üretilmek istendiğinde çok kullanışlıdır. Birden fazla kullanıcı aynı anda böyle bir sayı üretmek isterse bunun program koduyla yapılması işlem hızını yavaşlatır. Çünkü bir kullanıcı diğeri işini bitirene kadar beklemek zorundadır. Sıra nesnesi bu işi otomatik olarak ve çok seri bir şekilde başarır.
Sıra numaraları Oracle’da tanımlı 38 rakama kadar tamsayılardan oluşur. Bir sıra tanımlaması sıranın adını, artan ya da azalan olacağını, iki sayı arasındaki fark miktarını içerir. Oracle tüm sıra numarası tanımlarını SYSTEM tablo uzayının içerisindeki bir veri sözlüğü tablosuna kaydeder. SYSTEM tablo uzayı sürekli çalışır durumda olduğu için tüm sıra numaraları da aktiftir. Sıra numaraları tablolardan bağımsız olarak üretilir. Yani bir sıra numarası bir ya da daha çok tablo için kullanılabilir.
Kayıtlı Fonksiyonlar(STORED FUNCTION) ve Kayıtlı Prosedürler(STORED PROCEDURE)
Bir grup SQL ya da PL/SQL komutunun belli bir işi gerçekleştirmek için bir araya getirilip veritabanına kaydedilmesi kayıtlı prosedürler ve fonksiyonlar sayesinde olur. Birden fazla uygulama programı içerisinde aynı işi yapan kodları sürekli yazmak yerine kayıtlı prosedür ve fonksiyonlar bir kere yazılır ve tüm uygulamalar tarafından kullanılır. SQL*Plus, Oracle Forms ya da Oracle Reports içerisinden bu prosedürler çağrılabilir. Prosedürler geriye birden fazla değer döndürebilirken, fonksiyonlar sadece bir değer döndürürler.
Eşanlam(SYNONYM)
Eşanlam bir tablo, görüntü, sıra, prosedür, fonksiyon ya da paket için “alias” olarak adlandırılan bir takma isimdir. Eşanlam bir takma isim olduğu için veri sözlüğü içerisindeki tanımının kapladığı yer haricinde, veritabanında yer kaplamaz. Eşanlamlar güvenlik ve daha rahat kod yazma amacıyla kullanılırlar. Bir eşanlam kullanıldığında ilgili nesnenin adı ve sahibi gizlenir ve SQL komutu içerisinde kullanımı kolaylaşır.
Eşanlamlar genel(Public) ve özel(Private) olarak tanımlanabilirler. “Genel” olarak tanımlanan eşanlamlara tüm veritabanı kullanıcıları erişebilir. “Özel” olarak tanımlanan eşanlamlara sadece ilgili nesnenin sahibi ve sahibi tarafından hak verilmiş bir başka kullanıcı erişebilir.
Bir nesnenin adı değiştirilmek istendiğinde ya da silinmek istendiğinde, bu nesneyi kullanan tüm uygulama programları değiştirilmek zorundadır. Oysa ki bu nesnenin bir eşanlamı oluşturulursa ve uygulama programları bu eşanlamı kullanırsa, eşanlam üzerinde yapılacak değişikliklerle bu silme vb. işlemlerden uygulama programlarının etkilenmesi önlenebilir.
Bir kullanıcı bir başka kullanıcının nesnesini kullanmak istediğinde “kullanıcı_adı.nesne_adı” şeklinde bir yazım kuralına uymak zorundadır. Eğer bir “genel” olarak bir eşanlam tanımı yapılırsa tüm kullanıcılar direk eşanlam ismini kullanarak işlemlerini gerçekleştirebilirler.
Tablo(TABLE)
İlişkisel Veri Tabanı Yönetim Sistemleri’nde veriler tablolar içerisinde yer alır. Her tablo bir isimle tanımlanır ve her biri bir “kayıt” olarak adlandırılan satırlar ile bu kayıtlardaki verilerin özelliklerini belirleyen sütunlardan oluşur. Her tablo bir ya da daha fazla sütuna sahip olabilir. Her sütunun bir adı ve veri tipi vardır.
Bir tablo oluşturulduğunda Oracle verileri depolamak için bir tablo uzayı içerisinde bir veri segmenti ayırır. Veri segmentinin değerleri değiştirilerek bir tablo için ayrılacak yer miktarı da değiştirilebilir.
Görüntü(VIEW)
Görüntü bir ya da birkaç tablodan istenilen alanların alınmasıyla oluşturulan sanal bir tablodur. Görüntü bu tablolar üzerinde gerçekleştirilen bir sorgu sonucu oluşturulur. Bir görüntü üzerinde silme, güncelleme gibi işlemler yapılamaz. Çünkü görüntü oluşturulduğu tabloların sadece o anlık görüntüsüdür ve veritabanında kendi tanımının kapladığı yer haricinde yer kaplamaz.
Veri Blokları(Data Blocks), Genişlemeler(Extents),Parçalar(Segments)
Oracle veritabanında verilerin depolandığı en küçük birim veri bloğu olarak adlandırılır.Bir veri bloğu veritabanının depolama alanı üzerindeki belli bir byte uzunluğuna karşılık gelir. Veri bloğunun uzunluğu veritabanı oluşturulurken belirlenir.
Veri bloklarının bir üst birimi genişleme olarak adlandırılır. Bir genişleme art arda olan belirli sayıda veri bloğundan oluşur.
Genişleme’lerin bir üst birimi de parça’lardır. Parçalar belli bir mantıksal yapı için ayrılmış bir dizi genişleme’den oluşurlar. Farklı amaçlar için kullanılan parçalar vardır. Bunlar veri parçaları(data segments), indeks parçaları(index segments), geri alma parçaları(rollback segments) ve geçici parçalardır(temporary segment).
Bir tablo bir veri parça’sından oluşur. Tablonun verileri bu parça içerisindeki genişlemelere kaydedilir.(Oracle8i ile birlikte gelen yeni bir özellik olan bölümlenmiş tablo yapısında her bölüm bir veri parça’sına karşılık gelir.). Yine bir küme(cluster)’de bir veri parça’sından oluşur ve küme içerisindeki tüm tablolar o kümenin veri parça’sında yer alır.
Her bir indeks’te bir indeks parçasından oluşur ve indeks’in bütün verileri indeks parça’sında yer alır. Bir veritabanında, veritabanı kurtarma işlemleri(database recovery) ve yapılan değişkilikleri geri alma işlemleri(rollback) için bir ya da daha fazla geri alma parça’ları yer alır. Geçici parça’lar Oracle tarafından SQL komutları işletilirken ihtiyaç olduğunda oluşturulur ve SQL komutu işlemini bitirdiğinde bu parça tekrar sistemin kullanımına bırakılır.
Aşağıda veri blokları, genişlemeler ve parça ilişkisini gösteren bir şekil yer almaktadır.

Bellek Yapısı(Memory Structure) ve Arka Plan İşlemleri(Background Processes)
Bu bölüm Oracle veritabanının yönetiminin sağlanmasında kullanılan işlemleri ve bellek yapılarını içermektedir. Tüm bellek yapıları veritabanının oluşturulduğu bilgisayarın ana belleğinde yer almaktadır. Bu bölüm birden fazla kullanıcının aynı anda veritabanına erişip işlemlerini gerçekleştirmesinin nasıl olduğunu anlamak açısından önemlidir. Aşağıdaki şekil bu bölüm için temel alınacaktır.

Bellek Yapıları
Oracle işlemlerini gerçekleştirmek için bellek yapıları oluşturur ve bunları kullanır. Örneğin bellek çalışan program kodlarını ve kullanıcılar arasında paylaşılan verileri depolar. Oracle’da birkaç adet bellek yapısı mevcuttur: SGA(System Global Area), veritabanı tamponları(database buffers), redo log tamponları(redo log buffers) ve paylaşım havuzunu(shared pool) içerir.
SGA(System Global Area)
SGA bir oracle veritabanı oturumu için gerekli verileri ve kontrol bilgilerini içeren paylaşımlı bellek bölgesidir. SGA ve Oracle arka plan işlemleri bir Oracle veritabanı oturumunu oluşturur. Veritabanı oturumu başladığında Oracle SGA’yı oluşturur ve veritabanı kapatıldığında yok eder. Her bir veritabanı oturumunun kendine ait bir SGA ‘sı vardır. Oracle’a bağlanan kullanıcılar SGA içerisinde verileri paylaşımlı olarak kullanırlar. Yüksek performansın sağlanabilmesi için SGA’nın olabildiğince büyük olması gerekir. SGA büyük olursa bu alanda daha fazla bilgi depolanabilir ve sabit diske erişim sayısı azalır. SGA içerisinde depolanan bilgi veritabanı tamponları, redo log tamponları ve paylaşım havuzunu içeren birkaç tip bellek yapısına bölünmüştür. Bu alanlar sabit büyüklüktedir ve veritabanı açılırken oluşturulurlar.
Veritabanı Tampon Belleği(Database Buffer Cache)
En son kullanılan veri blokları SGA içerisinde veritabanı tamponu denilen yerde depolanır. Bu veritabanı tamponlarının hepsi veritabanı tampon belleğini oluşturur. Veritabanı tampon belleği değiştirilmiş ve değiştirilmemiş bilgileri içerir. Son kullanılan verilerin ya da çok kullanılan verilerin bellekte depolanması sayesinde sabit disk erişim işlemleri azalır.
Redo Log Tamponu(Redo Log Buffer)
SGA’nın redo log tamponu veritabanı verileri üzerinde yapılan son değişiklikleri depolar. Redo log tamponunda depolanan değişiklik bilgileri veritabanı kurtarma işlemlerinde gerekli olan redo log dosyalarına kaydedilirler.
Paylaşım Havuzu(Shared Pool)
Paylaşım havuzu SGA’nın paylaşımlı SQL alanları gibi bellek yapılarını içeren kısmıdır. Paylaşımlı SQL alanı veritabanına girilen her farklı SQL komutunu işlemek için gerklidir. Her bir paylaşımlı SQL alanı aynı komutu işleyen birden fazla uygulama tarafından kullanılır. Burada amaç diğer kullanıcılar için daha fazla paylaşımlı bellek alanı bırakabilmektir.
Geniş Havuz(Large Pool)
Geniş havuz SGA içerisinde isteğe bağlı bir alandır. Bu alan yedekleme, yapılan işlemleri geri yükleme, sunucunun giriş/çıkış işlemleri vb. işlemlerde daha geniş bellek ihtiyacı için kullanılan alandır.
Program Genel Alanı(PGA)
PGA sunucu işlemleri için veri ve kontrol bilgilerini içeren bellek tamponudur. Bir sunucu işlemi başlatıldığında PGA Oracle tarafından otomatik olarak başlatılır. Genellikle PGA bir kullanıcı ya da bağlantı için ayrılan belleğe denir. Bu bellek üç bölümü içerir: Birincisi yığın uzayı’dır(Stack Space). Yığın bir her bir bağlantıya ait değişkenleri, dizileri vb. yapıları tutan bellektir. İkincisi bağlantı bilgisi’dir(Session Information). Bağlantı bilgisi, “multitheraeded” sunucu olarak adlandırılan bir bilgisayarda çalışılmıyorsa PGA alanında, aksi halde SGA da depolanır.(“multithreaded” uygulamalar aynı kod ve data segmenti kullanıp, farklı program sayacı, kayıtlık ve yığın kullanan uygulamalar için kullanılır.) Üçüncüsü Özel SQL alanıdır. Bu alanda farklı amaçla kulanılan bazı değişkenleri tutmak için kullanılır.
İşlem Yapısı(Process Architecture)
İşlem, işletim sistemlerinde, belli bir işi yapmak için bir adımlar dizisinin çalıştırılması olarak adlandırılmaktadır. Normalde her işlemin çalışabilmesi için bellekte kendine özel bir yeri vardır. Oracle’da da iki tür işlem vardır. Kullanıcı işlemleri(User Processes) ve Oracle İşlemleri(Oracle Processes).
Kullanıcı İşlemleri(User(Client) Processes)
Bir kullanıcı işlemi bir uygulama ya da yazılımın çalıştırlmasını sağlamak için oluşturulur. Kullanıcı işlemleri program arayüzü(program interface) yoluyla sunucuyla iletişim işlemlerini sağlar.
Program arayüzü bir kullanıcı işlemlerinin sunucu ile ileitişim kurmasında kullanılan mekanizmalar olark bilinir. Program arayüzü veritabanı ile bir Oracle Forms ya da Reports programı arasında iletişim standartlarını sağlar.
Oracle İşlemleri(Oracle Processes)
Oracle işlemleri diğer işlemler tarafından işlemin belli adımlarını gerçekleştirmesi için çağrılırlar. Oracle işlemleri de sunucu işlemleri(Server Processes) ve arka plan işlemleri(Background Processes) olarak ikiye ayrılır.
Sunucu İşlemleri(Server Processes)
Oracle, veritabanına bağlanan bir kullanıcının isteklerini gerçekleştirebilmek için sunucu işlemlerini başlatır. Örneğin bir kullanıcının, o an SGA’nın veritabanı belleği’nde yer almayan bir bilgiyi sorgulaması, veri bloklarının veri dosyalarından okunup SGA’ya getirilmesini sağlayan sunucu işlemini başlatır. İstemci/Sunucu mimarili sistemlerde kullanıcı işlemleri ve sunucu işlemleri ayrı bilgisayarlarda çalıştırılır.
Arka Plan İşlemleri(Background Processes)
Oracle her veritabanı için ayrı olarak bir dizi arka plan işlemleri oluşturur. Oracle veritabanına bir anda birden fazla kullanıcının bağlandığını ve belli programları çalıştırdığını düşünelim. Oracle programlar tarafından oluşturulan bu kullanıcı işlemleri’ni gerçekleştirmek için arka planda bazı işlemler gerçekleştirir. Her bir veritabanı kendi arka plan işlmelerine sahiptir. Şimdi bu arka plan işlmelerinin neler olduğuna bakalım:
Veritabanı Yazıcısı(Database Writer- DBWn)
Veritabanı yazıcısı, veritabanı tampon belleğindeki değiştirilmiş veri bloklarını veri dosyalarına yazmakla görevlidir. Normalde tek bir veritabanı yazım işlemi bir çok sistemde yeterli olmasına rağmen, birden fazla yazım işlemi tanımlanabilir. Bu işlemlere DBW0…DBW9 şeklinde isim verilir. Veritabanı açılırken bu DB_WRITER_PROCESSES parametresi ile veritabına bildirilir.
Bir kullanıcı yaptığı değişiklikleri “commit” komutuyla onayladığında veritabanı yazıcısı bu değişiklikleri hemen veri dosyalarına kaydetmez. Veritabanı yazıcısı veri dosyalarına yazma işlemini kendi belirler ve ya SGA içerisine çok miktarda başka verilerin alınması gerektiği zaman ya da çok az veritabanı tamponu kaldığı zaman yazma işlemini gerçekleştirir. Veri dosyalarına yazım işlemi en son kullanılan verilerden başlanarak gerçekleştirilir.
Log Yazıcısı(Log Writer LGWR)
Log yazıcısı SGA’nın redo log tamponundaki bilgileri diske kaydetmek için kullanılır. LGWR tampondaki bilgileri o an kullanımda olan bir redo log dosyasına sıra ile yazar. Bu yazma işlemi veritabanının sahip olduğu birden fazla redo log dosyasına da yapılabilir.
Değişme Noktası(Checkpoint- CKPT)
Belirli zamanlarda SGA içerisindeki değişikliğe uğramış veritabanı tamponları DBWn tarafından belleğe yazılır. Bu işlem değişme noktası işlemi olarak adlandırılır. Değişme noktası işlemi DBWn’e değişme anlarını haber vermekten ve veritabanındaki bütün veri dosyalarını ve kontrol dosyalarını yeni değişme noktasından haberdar etmek için güncellemekten sorumludur.
Sistem Analizi(System Monitor-SMON)
Sistem Analizi veritabanı oturumu açılırken oturum için kurtarma yapar, yani kontrol dosyalarını kontrol ederek geri alınması gereken bir işlemin olup olmadığına bakar, eğer varsa geri allma işlemini gerçekleştirir. Birden fazla veritabanı oturumunun olduğu ortamlarda SMON aynı zamanda bozulan sistemler içinde ayrı ayrı kurtarma yapar. SMON aynı zamanda kullanılmayan geçici parçaları(temporary segment) temizlemekte ve herhangi bir problemden dolayı bozulan işlemleri kurtarmaktadır. Bozulan işlemlerin sorgu komutları SMON tarafından tablo uzayı ve veri dosyası tekrar aktif hale getirildikten sonra kurtarılır. Son olarak SMON veritabanında daha fazla boş yer açılsın diye boş genişlemeleri birleştirmektedir.
İşlem analizi(Process Monitor-PMON)
İşlem Analizi herhangi bir kullanıcı işlemi bozulduğunda o işlemin kurtarılmasını yapmaktadır. PMON işlemin kullandığı belleği ve kaynakları temizlemekten sorumludur. PMON aynı zamanda dispatcher(ileride anlatılıyor) ve sunucu işlemlerini kontrol eder ve kapandıklarında yeniden çalıştırır.
Yedekleyici(Archiver-ARCn)
Yeekleyici o an kullanılmakta olan redo log dosyalarını, doldukları zaman yedek depolama ünitelerine kopyalar. Tüm sistemler için bir ARC0 işleminin olması yeterli olsa da birden fazla işlem gerçekleştirilebilir. Bu LOG_ARCHIVE_MAX_PROCESSES parametrsei ile belirlenir. ARCn işlemi veritabanı ARCHIVELOG modda çalışırken kullanılır.
Geri Kurtarıcı(Recoverer-RECO)
Geri kurtarıcı dağıtık veritabanında sistem veya ağ hatalarından dolayı bekleyen işlemleri düzenler. Belli aralıklarla, yerel RECO uzaktaki veritabanına bağlanıp yereldeki dağıtık işlemlerle ilgili “commit” ve “rollback” işlemlerini yapmaktadır.
Dispatcer(Dnnn)
Dispatcher’lar çoklu ortamlarda isteğe bağlı olarak çalıştırılmaktadırlar. Her iletişim protokolü için en az bir dispatcher işlemi (D000,….,Dnnn) oluşturulmaktadır. Her dispatcher işlemi kullanıcı işlemlerinden gelen istekleri sunucu işlemlerine yönlendirmekte ve gelen cevapları da uygun kullanıcılara tekrar döndürmekten sorumludur.
Kilit(Lock-LCKO)
Kilit işlemleri birden fazla veritabanı oturumunun çalıştığı sistemlerde veritabanları arasında gereken bir takım kilitleme işlemlerini gerçekleştirir.
İş Kuyruğu(Job Queue-SNPn)
Dağıtık veri tabanı uygulamalarında 38 adetten fazla (SNP0,…,SNP9,SNPA,….SNPZ) iş kuyruğu işlemi tablo snapshot’larını otomatik olarak güncelleyebilir. Bu işlemler periyodik olarak başlatılır.
Oracle’ın Çalışmasına Bir Örnek
Aşağıdaki örnek bir istemcinin ağ üzerinden sunucudaki veritabanına erişip bir sorgulama yapmasının adımlarını içermektedir.
Oracle veritabanı “host” ya da “database server” olarak adlandırılan bilgisayarda çalışıyor vaziyettedir.
Bir kullanıcı istemci bilgisayarda kullanıcı işlemlerini gerçekleştiren bir uygulama programını çalıştırmaktadır. İstemci bilgisayar sunucu bilgisayar ile bağlantısını uygun Net8 sürücüsünü kullanarak gerçekleştirir.
Sunucu bilgisayarda da uygun bir Net8 sürücüsü çalışıyor vaziyettedir. Sunucu uygulama programından gelen bağlantı isteğini tespit eder ve kullanıcı işlemine karşılık gelen sunucu işlemini oluşturur.
Kullanıcı bir SQL komutu çalıştırır ve yaptığı değişikliği “commit” eder, yani onaylar.Örneğin kullanıcı bir tablo içerisindeki bir kaydı değiştirir.
Sunucu işlemi komutu alır ve paylaşım havuzunda bu SQL komutuna benzeyen bir paylaşımlı SQL alanı olup olmadığına bakar. Eğer böyle bir alan bulunursa sunucu işlemi kullanıcının bu SQL cümlesini çalıştırma haklarını kontrol eder. Eğer böyle bir alan yoksa yeni bir paylaşımlı SQL alanı oluşturulur ve SQL komutu çalıştırılır.
Sunucu işlemi bu SQL komutu için gerekli verilerin SGA’da olup olmadığına bakar. Eğer burada yoksa ilgili veri dosyasından verileri alıp SGA’ya getirir.
Sunucu işlemleri komutun gereklerine göre SGA’daki verileri değiştirir. DBWn değiştirilmiş veri bloklarını gerekli olduğu zaman kalıcı olarak diske kaydeder. SQL komutu onaylandığı için LGWR işlemi yapılan SQL işlemini redo log dosyalarına kaydeder.
Eğer SQL komutunun çalıştırılması başarılı olduysa sunucu işlemi ağ üzerinden istemcideki uygulamaya mesaj gönderir. Eğer başarılı olmadıysa uygun hata mesajını gönderir.
Tüm bu işlemler yapılırken veritabanı sunucusu diğer kullanıcıların aynı ya da farklı veriler üzerindeki işlemlerini de yürütür. Bu işlemlerin yapılabilmesi ve performansın artırılması için örneğimiz içerisinde anlatılmayan başka arka plan işlemleride gerçekleştirilir.
Veri Tanımlama Dili Komutları
SQL’de veritabanı nesnelerini oluşturma, silme, yapısını değiştirme işlemleri için kullanılan komutlara veri tanımlama dili komutları denir. Bu komutlar “create”, “alter”, “drop”, “grant”, “revoke”, “analyze”, “audit”, “comment” komutlarıdır. Şimdi bu komutları kullanarak veritabanı nesneleri ile işlemler yapacağız.

—

Veri Sözlüğü
Veri sözlüğü, Oracle veritabanı ile ilgili bilgilerin yine Oracle veritabanında tablolar ve görüntüler halinde saklanmasıyla oluşur. Veritabanı ile ilgili bu bilgiler kullanıcılar, haklar, veritabanı nesneleri, tablo kısıtlamaları vb. bilgilerinden oluşur. Veri sözlüğü Oracle veritabanın en önemli bölümüdür. Veritabanı hakkındaki tüm bilgiler veri sözlüğünden SQL komutları yazarak öğrenilebilir.
Veri sözlüğü, veritabanı kurulurken standart olarak oluşturulur ve yapılan değişiklikler otomatik olarak veri sözlüğüne yansıtılır. Örneğin bir kullanıcı bir tabloya bir alan eklerse, veri sözlüğünde o tabloya ilişkin yapı kullanıcı farketmeden değiştirilir böylece veri sözlüğünden veritabanı hakkında sürekli olarak güncel ve sağlıklı bilgi almak mümkün olur. Veri sözlüğü içerisindeki bilgiler SQL komutlarıyla sorgulanıp görülebilir. Fakat hiçbir kullanıcı veri sözlüğünü değiştiremez, ekleme yapamaz ve kayıt silemez. Veritabanı oluşturulurken oluşturulan veri sözlüğü tabloları SYS adlı kullanıcıya aittir. Veri sözlüğü tabloları için görüntüler oluşturulmuştur. Tüm kullanıcılar hakları olduğu müddetçe bu görüntülerden bir ya da birkaçını sorgulayabilirler. Veri sözlüğü görüntüleri, başlarındaki ön eklerine göre üç gruba ayrılır:
USER_xxx : Veritabanına o an bağlı olan kullanıcının sahip olduğu nesneler ile ilgili görüntülerdir.
ALL_xxx : Veritabanına o an bağlı olan kullanıcının sahip olduğu ve başkalarına ait olan ve kendisine kullanma hakkı verilmiş olan tüm nesnelerle ilgili görüntülerdir.
DBA_xxx : DBA(veritabanı yöneticisi) veya DBA hakkına sahip kullanıcıların görebileceği görüntülerdir.

Görüntü İsimleri Açıklama
USER_TABLES Kullanıcıların sahip olduğu tabloların yapısını gösteren görüntüdür.
USER_SEQUENCES Kullanıcının sahip olduğu sıralar hakkında bilgi içeren görüntüdür.
USER_VİEWS Kullanıcının sahip olduğu görüntüler hakkında bilgi içeren görüntüdür.
ALL_OBJECTS Kullanıcının erişebileceği bütün nesneler hakkında bilgi içeren görüntüdür.
DBA_USERS Veritabanındaki bütün kullanıcılar hakkında bilgi içeren görüntüdür.
DBA_TABLESPACES Veritabanındaki bütün tablo uzayları hakkında bilgi içeren görüntüdür.

SCOTT kullanıcısının bütün nesnelerini görmesi
SELECT * FROM USER_OBJECTS
Bir kullanıcın kendine ait bütün tabloların adlarını listelemesi
SELECT TABLE_NAME FROM USER_TABLES
Bir kullanıcının tüm indeks bilgilerini listelemesi
SELECT INDEX_NAME,TABLE_NAME,TABLESPACE_NAME FROM ALL_INDEXES

Veritabanı Nesneleriyle İlgili Komutlar
CREATE TABLE
Tablo oluşturma komutunu anlatırken bir örnekle başlayalım.
CREATE table tbl_ogr
(OgrNum NUMBER(11) NOT NULL,
Ad VARCHAR2(15),
Soyad VARCHAR2(15),
Dogyer NUMBER(2),
CONSTRAINT cst_OgrNum PRIMARY KEY(OgrNum)
CONSTRAINT cst_dogyer FOREING key(dogyer) REFERENCES il(ilkod))
Bu komut “tbl_ogr” adında bir tablo oluşturuyor. Tablonun dört alanı var. Bunlardan biri özel anahtar(Primary Key) olarak tanımlanmış. Bu alanın değeri boş olamaz ve tabloda aynı iki değer bulunamaz.. Bir tablo ile başka bir tablo arasında ilişki kurulacaksa bu ana tabloda PRIMARY KEY tanımıyla, diğer tabloda FOREIGN KEY tanımıyla yapılır. Yani doğum yeri alanı için buradaki tablomuz ana tablo değil. Çünkü aynı yerde doğmuş kişilerin kaydı tablomuzda olabilir. Böylece aynı il kodu birden fazla kayıtta yer alabilir. İlişki kurulan diğer tablonun adını yukarıdan çıkarabiliriz. Bu tablo “il” isminde. Her il bu tabloda kayıtlı ve her birinin bir kodu var. Bu tabloda bir ilin kaydı iki sütunda yer alamaz. Bu yüzden “ilkodu” alanı “il” tablosu için PRIMARY KEY olarak tanımlanmış.
PRIMARY KEY, NOT NULL gibi bildirimler kısıtlamalar olarak tanımlanır. Bir tabloda farklı şekilde kısıtlamalar yapılabilir. Kısıtlama için kullanılan bildirimler 5 adettir.
NOT NULL : Bu kısıtlamanın konulduğu bir alanın mutlaka bir değeri olmak zorundadır.
UNIQUE : Bu kısıtlamanın konulduğu bir alan bir değerden sadece bir adet içerebilir. Bu kısıtlamaya sahip alan NOT NULL ile tanımlanmadıysa NULL değer alabilir.
PRIMARY : Bu kısıtlama bu alanın özel anahtar olmasını sağlar. Bu alan boş geçilemez ve yine tablo içerisinde bir değer iki kayıtta bulunamaz.
FOREIGN KEY : Bu kısıtlama başka bir tablonun PRIMARY KEY olan alanıyla ilişki kurmak için gerekir.
CHECK : Bu kısıtlama ile birlikte bir şart kullanılır. Tabloya kayıt girilirken değerlerin bu şarta uyması beklenir.

ALTER TABLE
Daha önceden oluşturulmuş bir tablonun yapısını değiştirmek için ALTER TABLE komutu kullanılır.
ALTER TABLE tablo_adı
ADD | MODIFY | DROP (<sütun ismi> veri tipi <sütun kısıtlaması>)
ENABLE ifade1
DISABLE ifade2
ALTER komutuyla tablolara yeni bir alan ve kısıtlama eklenebilir, var olan alan ve kısıtlamaların durumu değiştirilebilir veya tablodan ksıtlamalar düşürülebilir. Fakat ALTER komutuyla var olan sütunlar düşürülemez. Bir alanın değeri büyültülebilir, fakat küçültülemez.

ALTER TABLE tbl_ogr
ADD CONSTRAINT cst_Bolum
FOREIGN KEY(Bolum)
REFERENCES usr_gazi.tbl_bol(BolKod);

Yukarıdaki örnekte tbl_ogr adlı tablonun yapısı değiştiriliyor. Bir başka kullanıcının bir tablosu ile ilişki kuruluyor.

ALTER TABLE tbl_ders
MODIFY dersad varchar2(40);
Bu örnekte de tbl_ders tablosunun bir alanının uzunluğu değiştiriliyor.
DROP TABLE
Daha önceden oluşturulmuş bir tablonun düşürülmesi için kullanılan komuttur. Kullanımı:
DROP TABLE <tablo_ismi> [CASCADE CONSTRAINTS]
Köşeli parantez içerisindeki tanım kullanılırsa master-detay ilişkili tablolarda master tablo düşürülünce detay tabloların da otomatik olarak düşürülmesi sağlanır. Eğer bu seçenek kullanılmazsa diğer tablolarla ilişkisi bulunan bir tablo silinemez. Ancak bu ilişkiler kaldırıldıktan sonra tablo silinebilir.
DROP TABLE tbl_ogr CASCADE CONSTRAINT
CREATE VIEW
Görüntü oluşturmak için bir SELECT cümlesi kullanmak gerekir. Bir görüntü bir ya da daha fazla tablodan oluşturulabileceği gibi, bir başka görüntüden de oluşturulabilir.Aşağıdaki örnekte üç farklı kullanıcnın aynı yapıdaki tabloları birleştirilip bir görüntü oluşturuluyor.

CREATE VIEW vi_ogr
AS SELECT * from usr_esef.tbl_ogr
UNION ALL
SELECT * FROM usr_tef.tbl_ogr
UNION ALL
SELECT * FROM usr_gef.tbl_ogr;

CREATE TABLESPACE
Tablo uzayı kullanıcılara ait olan nesnelerin veritabanında mantıksal olarak tutulduğu yere denmektedir. Bir tablo uzayı oluştururken, bu tablo uzayının verilerinin hangi veri dosyasına konulacağı ve bu dosyanın dizini ile büyüklüğü bildirilmelidir.
CREATE TABLESPACE tbs_esef
DATAFILE ‘c:\orasql\tbs_esef.dat’ SIZE 10M
DEFAULT STORAGE (INITIAL 10K NEXT 50K
MINEXTENTS 1 MAXEXTENTS 999)
ONLINE;
SIZE bildirisi veri dosyasının diskte kaplayacağı yeri belirler. Burada 10M, 5K gibi değerler girilebilir. INITIAL bildirisi tablo uzayı oluşturulduğunda, ik alacağı genişleme’nin büyüklüğünü belirler. Next tablo uzayı oluşturulduktan sonra alacağı genişlemelerin büyüklüğünü belirler. MINEXTENTS tablo uzayı oluşturulduğunda ilk olarak alacağı minimum genişleme sayısının belirtildiği bölümdür. MAXEXTENTS bir tablo uzayının ilk olarak aldığı genişleme de dahil olmak üzere alabileceği maksimum genişleme sayısının belirtildiği bölümdür.
CREATE USER
Kullanıcı veritabanı nesnelerinin sahibidir. Kullanıcılar, nesneleri oluşturur, kullanır ve silerler. Oracle veritabanı ilk kurulduğunda standart olarak üç kullanıcı tanımlanır. Bunlardan bir SYS kullanıcısıdır. SYS kullanıcısı veri sözlüğünün sahibi olan kullanıcıdır. Tüm nesneleri oluşturma hakkına sahiptir ve diğer bütün kullanıcların nesnelerine erişebilir. SYS kullanıcısının ilk şifresi “change_on_install” olarak belirlenmiştir. İkinci kullanıcı SYSTEM kullanıcısıdır. SYSTEM kullanıcısı veri sözlüğünü kullanma hakkına sahiptir. Önemli nesneleri oluşturma hakkına da sahiptir. İlk şifresi “manager” olarak belirlenmiştir. Diğer kullanıcıların nesnelerine erişme hakkına da sahiptir. Üçüncü kullanıcı SCOTT kullanıcısıdır. SCOTT kullanıcısı veritabanına başlangıçta yüklenen demo tabloların sahibidir. Bu kullanıcının nesneleri kullanılarak SQL denemeleri yapılabilir.
“CREATE USER” komutunu SYS ve SYSTEM kullanıcıları standart olarak kullanabilir. Bu hak diğer kullanıcılara da verilebilir. Her kullanıcının nesnelerini tutmak için bir tablo uzayı oluşturmak sistemin performansı açısından gerklidir. Kullanıcı oluşturulurken bu tablo uzayı o kullanıcıya atanır.
CREATE USER usr_esef
IDENTIFIED BY esef
DEFAULT TABLESPACE tbs_esef
QUOTA UNLIMITED ON tbs_esef
Yukarıdaki örnekte usr_esef adında bir kullanıcı oluşturuluyor. Kullanıcının şifresi IDENTIFIED BY ile “esef” olarak bildiriliyor. Kullanıcının kendi nesnelerini oluşturacağı tablo uzayı için ise “tbs_esef” tablo uzayı bildiriliyor. Kullanıcının bu tablo uzayındaki tüm alanı kullanabileceği QUOTA UNLIMITED ile belirleniyor.
CREATE ROLE
Rol veritabanındaki hakların toplanmış haline denir. Veritabanı yöneticisi rolleri kullanarak sistemin güvenliğini daha kolay sağlayabilir. Roller Oracle tarafından önceden tanımlanmış roller ve kullanıcı tanımlı roller olarak iki şekilde düşünülebilir. Oracle tarafından önceden tanımlanan roller beş tanedir:

Rol Atanmış Haklar
CONNECT ALTER SESSION,CREATE CLUSTER, CREATE DATABASE LINK, CREATE SEQUENCE, CREATE SESION, CREATE SYNONYM, CREATE TABLE, CREATE VIEW
RESOURCE CREATE CLUSTER, CREATE PROCEDURE, CREATE SEQUENCE, CREATE TABLE, CREATE TRIGGER
DBA “WITH ADMIN OPTION” ile birlikte bütün sistem hakları
EXP_FULL_DATABASE SELECT ANY TABLE, BACKUP ANY TABLE, SYS.INCVID, SYS.INCFIL ve SYS.INCEXP tablolarına INSERT, UPDATE veDELETE hakkı
IMP_FULL_DATABASE BECOME USER, WRITEDOWN

CREATE ROLE tabloma_bak
GRANT SELECT ON tbl_ogr TO tabloma_bak
Yukarıdaki örnekte tabloma_bak adında bir rol oluşturuluyor. Daha sonra bu role tbl_ogr tablosu üzerinde listeleme işlemi yapma hakkı veriliyor. Böylece bu rolün atandığı kullanıcı tbl_ogr tablosu üzerinde “SELECT” komutunu çalıştırabilecek.
CREATE INDEX
Daha öncede bahsedildiği gibi indeks tablodaki kayıtlara daha hızlı erişim için kullanılan nesnelerdir. Bir indeks oluşturabilmek için “CREATE ANY INDEX” sistem hakkına sahip olmak gerekir. İndeks bir tablonun bir alanı üzerinde tanımlanabileceği gibi birden fazla alan üzerinde de tanımlanabilir.
CREATE INDEX indeks1 ON tbl_ogr(ogrnum,ad)
CREATE SEQUENCE
Sıra, sıralı olarak artan alanlar için veritabanında tutulan nesnedir. Örneğin birden başlayan ve birer birer artan bir sıra yaratmak için:
CREATE SEQUENCE sira1 START WITH 1 INCREMENT BY 1
CREATE ROLLBACK SEGMENT
Geri alma parçaları SELECT, INSERT, DELETE, UPDATE gibi komutlarla yapılan işlemlerin gerektiğinde geri alınabilmesi için veritabanında ayrılan alanlara denir. “tbsp_esef” tablo uzayını kullanan, kayıt parametrelerinden ilk parçanın büyüklüğü 10M, sonraki genişlemelerin büyüklüğü 1M, minimum genişleme sayısı 2, maksimum genişleme sayısı 121 ve ortalama değeri 30M olan ve ismi “rol_seg” olan bir geri alma parçası şöyle oluşturulabilir:
CREATE ROLLBACK SEGMENT rol_seg
TABLESPCE “tbsp_esef”
STORAGE( INITIAL 10M
NEXT 1M
MINEXTENTS 2
MAXEXTENTS 121
OPTIMAL 30M)
GRANT
Sistem ya da nesne haklarının kullanıcılara veya rollere atanması için kullanılan komuttur.
GRANT DELETE ON tbl_ogr TO usr_gef
Yukarıdaki örnekte usr_gef kullanıcısına tbl_ogr tablosunda silme yapma yetkisi verilir.
REVOKE
Sistem ya da nesne haklarının kullanıcılardan veya rollerden geri alınnması için kullanılan komuttur.
REVOKE DELETE ON tbl_ogr FROM usr_gef
Yukarıdaki örnekte usr_gef kullanıcısından tbl_ogr tablosunda silme yapma yetkisi geri alınır.

** Veritabanı nesnelerinin yönetilmesiyle ilgili daha bir çok veri tanımlama dili komutu vardır. Bu komutların diğerleri burada anlatılmayacaktır. Bir nesneyi oluşturmak için “CREATE”, silmek için “DROP”, değiştirmek için “ALTER” komutlarının kullanıldığının bilinmesi diğer komutlar için bir temel teşkil edecektir. Komutlar içerisinde kullanılan parametreler Oracle yardım dokümanlarında ayrıntılı olarak verilmektedir.
Yedek Alma ve Geri Getirme
Oracle, verileri her ne kadar güvenli tutsa da, fiziksel sebeplerden(disk hataları), kullanıcı hatalarından veya benzer durumlardan dolayı yedeklere ihtiyaç duyulmaktadır. Yedek alma, veritabanı yöneticisinin yapacağı önemli işlerden birisidir.
Oracle’da, yedek almayla ilgili değişik yöntemler vardır. Veritabanı yöneticisi, kendi veritabanının durumuna göre, yedek almayla ilgili bir veya birden fazla yöntemi kullanmaya karar vermelidir. Bu kararı vermede, yönetici, yedeği kimin alacağı, hangi tür depolama ünitesine alınacağı, ne kadar sıklıkla alınacağı, alınan yedeklerin büyüklüğü, veritabanında küçük de olsa bir kayıba tahammül olup olmadığı gibi çok değişik sebepleri gözönünde bulundurmak zorundadır.
Fiziksel Yedek Alma
Fiziksel yedek alma veri dosyalarının, redo log dosyalarının ve kontrol dosyalarının yedeklerinin alınması işlemidir. Bir veritabanı ARCHIVELOG ve NOARCHIVELOG olmak üzere iki farklı modda çalışabilir. ARCHIVELOG modunda yapılan tüm işlemler redo log dosyalarına otomatik olarak kaydedilir. Bunun anlamı veritabanındaki değişikliklerin sürekli dosyalara kaydedilmesidir. Kaydedilen bu dosyaların hangileri olduğu ve nerede bulundukları gibi bilgiler init<SID>.ora dosyası içerisinde yer alır. ARCHIVELOG modda çalışan bir veritabanında veri kaybı söz konusu değildir. Eğer veritabanı NOARCHIVELOG modda çalışıyorsa yapılan değişiklikler bir yere kaydedilmeyecektir. Bu yüzden sistemin bozulması durumunda ancak son alınan yedekler geri getirilebilir. Yani son alınan yedekten sonra yapılan değişiklikler kaybolur. İşletim sistemi yedeği alma olarak ta bilinen fiziksel yedek alma işleminin dezavantajı, yedek alma işlemi boyunca veritabanının kapatılması gereğidir.
NOARCHIVELOG Modunda Yedek Alma
Bu modda yedek almak için komut moduna geçilerek aşağıdaki işlemleri yapmak gerekir. Bundan önce SQL*Plus içerisinde yedeği alınacak dosyaların tespiti yapılmalıdır.

Burada kullanılan V$LOGFILE, V$CONTROLFILE ve DBA_DATFILES dosyaları veri sözlüğündeki görüntülerdir. Bu görüntüleri sorgulayarak yedeklememiz gereken dosyaları ve bunların nerede bulunduklarını öğreniyoruz. Burada yapacağımız iş veritabanı oturumunu kapattıktan sonra, bu dosyaları bir başka depolama ünitesine kopyalamak. Veritabanını Windows NT veya Windows 2000 içerisinde, Denetim Masası’na girip “Sevices” simgesine çift tıkladıktan sonra burada “Oracle” ile başlayan tüm servisleri durdurarak kapatabiliriz. Bu işlemler komut modundan da yapılabilir. Bunun için veritabanı yüklenirken belirtilen dizin içerisindeki “Svrmgrl” programı çalıştırılır. Eğer varsayılan dizini seçtiyseniz bu “c:\oracle\ora81\bin” dizinidir. Komut modunda şu adımlar gerçekleştirilir:
>svrmgr
svrmgr>connect internal
svrmgr>shutdown immediate
svrmgr>exit
>lsnrctl stop
Buradaki işlemlerde önce sunucu yöneticisine(server manager) bağlanılıyor ve sonra da veritabaını kapatılıyor. En sonda da Dinleyici(Listener) durduruluyor. İlgili dosyalar kopyalandıktan sonra :
>svrmgr
svrmgr>connect internal
svrmgr>startup
Bu dosyları bir bozulma anında tekrar geri yüklemek için veritabanını kapatıp dosyaları geriye kopyalamak ve sonra yeniden veritabanını açmak gerekir. İşte burada son yapılan değişiklikler kaybolur.
ARCHIVELOG Modunda Yedek Alma
Bu modda yapılan değişiklikler otomatik olarak redo log dosyalarına yazıldığı için dosyaları tek tek kopyalamak gerekmez. Fakat bu değişikliklerin kaydedildiği dosyaları yedeklemek yararlı olabilir. Veritabanında bir bozukluk durumunda yapacağımız iş veritabanını kapatıp “Recover Database” komutunu kullanmak ve sonra veritabanını yeniden açmak. “Recover Database” komutunu kullanmak için veritabanı “Mount” modunda açılır.
>svrmgr
svrmgr>connect internal
svrmgr>shutdown immediate
>exit
>lsnrctl stop
>svrmgr
svrmgr>connect internal
svrmgr>startup mount
svrmgr>recover database

Mantıksal Yedek Alma
Oracle’da mantıksal yedek alma denince Export ve Import anlaşılır. Bunlar Oracle firmasının geliştirdiği komut modunda çalışan yardımcı programlardır. Bu tür yedek alma veritabanı nesnelerinin yedeklenmesi olduğu için mantıksal yedek olarak adlandırılır. Yani export ile log dosyalarının ya da kontrol dosyalarının yedeği alınmaz.
Export
Export Oracle’ın mantıksal yedek alma işlemleri için geliştirdiği bir üründür. Mantıksal yedek alma veritabanının kapatılmaması gerektiği zaman kullanılan bir yedek alma türüdür. Bu yöntemle farklı modlarda yedek alınabilir. Bunlar aşağıda açıklanacaktır. Export ile alınan yedekler ancak Import ile geri yüklenebilir. Export kullanılarak bir veritabanının yapısı veriler olmadan yedeklenebilir, belli tablolar verilerle birlikte ya da sadece yapıları ile yedeklenebilir, yani yedeklenecek veritabanı nesnelerinin seçimi yapılabilir.
Export almada 4 mod vardır: Birincisi Tablo Modu(Table Mode)’dur. Bu modda kullanıcılar kendi tablolarının yedeklerini alabilirler ya da hakkı olan kullanıcı bir başka kullanıcnın tablolarının yedeklerini alabilir. İkincisi Kullanıcı Modu(User Mode)’dur. Bu modda bir kullanıcının nesnelerinin yedeği alınabilir. Üçüncüsü Tam Veritabanı Modu’dur(Full Database Mode). Bu modda tüm veri tabanının yedeği alınabilir. Bu modu gerçekleştirmek için kullanıcının bazı özel haklara sahip olması gerekir. EXP_FULL_DATABASE rolüne sahip olan kullanıcı ya da DBA rolüne sahip olan kullanıcılar bu modu kullanabilir. Dördüncüsü Tablo Uzayı Modu’dur. Bu modda da tablo uzaylarının yedeği alınır.
Export yardımcı programını çalıştırmak için komut moduna geçilmelidir. Exp.exe dosyası Oracle8i kurulurken varsayılan dizin adı kabul edildiyse “c:\oracle\ora81\bin” dizini içerisinde bulunabilir. Aşağıdaki örnekler bu dizine geçip komut modunda yazılarak çalıştırılabilir.
Tam Veritabanı Modu örnekleri:
>exp system/manager full=Y file=deneme.dmp
Yukarıdaki komut tüm veritabanının yedeğini alır. Eğer tüm veritabanı içerisinde istenilen belli özelliklerin yedeği alınmak istenirse etkileşimli metod kullanılır(aşağıdaki gibi).
>exp system/manager
……..
Enter array buffer size:4096>(return) ‘veri tamponunun büyüklüğü
Export file:EXPDAT.DMP>deneme.dmp ‘varsayılan yedekleme dosyası ismi EXPDAT.dmp
E(ntire databese), U(sers), T(ables):U>e ‘tüm veritabanı mı? Kullanıcı ya da Tablo yedeği mi?
Export grants(Y/N):Y>y ‘kullanıcı haklarının yedeği alınsın mı?
Export Table Data(Y/N):Y>y ‘ veriler kopyalansın mı?
…….

Kullanıcı Modu Örnekleri:
>exp scott/tiger file=scott.dmp
Scott kullanıcısının tüm nesneleri ve verileri scott.dmp dosyasına yedeklenir. Etkileşimli mod için yine “>exp scott/tiger” şeklinde komut girilir.
Tablo Modu Örnekleri:
>exp system/manager tables(a,scott.b,ahmet.d) rows=n
System kullanıcısı kendisine ait olan a tablosunu, scott kullanıcısına ait olan b tablosunu ve ahmet kullanıcısına ait olan d tablosunu yedekliyor. “rows=n” bildirisiyle tablo verilerinin alınmamasını sadece tablonun yapılarının kopyalanmasını sağlıyor.
Import
Export ile yedeklenen veriler Import yardımcı programıyla geri getirilebilir. Yedeklenmiş dosyanın tamamı ya da bir kısmı yedekleyen kullanıcı için geri getirilebildiği gibi bir başka kullanıcıya da aktarılabilir.
>imp system/manager file=deneme.dmp fromuser=usr_esef tables=(isci,bolum)
usr_esef kullanıcısının dneme.dmp tablosuna yedeklediği isci ve bolum tabloları geri getirlir.
>imp system/manager file=scott.dmp fromuser=scott touser=esef tables=(*)
scott kullanıcısının scott.dmp ismli yedek dosyasındaki tüm tablolar esef kullanıcısına aktarılır. Tüm tablolar için “*” işareti kullanılır.

SQL( Structured Query Language )
Açılımı “Structured Query Language” yani “Yapısal Sorgulama Dili” olan SQL, veritabanı işlemleri ile ilgili komutlardan oluşan bir programlama dilidir. Burada veri tabanı işlemleri denilenler veritabanının kendisini oluşturmaktan, tablo, indeks, kullanıcı oluşturmak gibi veri tanımlama dili komutlarına ve kayıt ekleme, silme, düzeltme gibi veri işleme dili komutlarına kadar uzanır. Buradaki yapısal sözcüğü Pascal, C ve benzeri dillerdeki fonsiyon ve prosedür oluşturarak bir program yazmaktan biraz farklıdır. Yani kullanıcı SQL kullanırken fonksiyon ve prosedür yazmaz. SQL tarafından tanımlı komutları gerekli parametreleri vererek bir komut modu uygulamasındaymış gibi çalışır. Yine SQL kullanımında şartlı ifadeler ve dallanmalar yoktur. Yani kullanıcı Pascal, C vb. dillerdeki İf, Case gibi ifadeler kullanmaz. SQL’in akış kontrolü yapabilen bir modeli ISO/IEC tarafından kabul edilmiştir, fakat yaygın olarak kullanılmamaktadır. Oracle’ın geliştirdiği PL/SQL(Programming Language/SQL) işte bu prosedür, fonksiyon ve if,case,for..next gibi programlama için gereken işlemleri kullanmayı olanaklı kılar. Fakat PL/SQL sadece içerisinde SQL komutları kullanılabilen bir dildir. Yani SQL’in yapısını değiştirmemiştir. Komut modunda yazdığınız bir SQL cümlesini alıp PL/SQL blokları arasına yazabilirsiniz. Oracle sirketi geliştirdiği tüm uygulamalarda SQL kullanmayı esas alır. Kullanıcının Oracle ürünlerini kullanarak yaptığı tüm işlemlerin arkasında SQL komutları çalıştırılır. SQL’in veritabanı işlemleri için kullanılan komutları 5 kategoride toplanabilir:
Veri sorgulama komutları
Tabloya veri ekleme,değiştirme ve silme komutları
Veritabanı nesneleri oluşturma,değiştirme ve silme komutları
Veritabanına ve veritabanı nesnelerine erişimi kontrol etme komutları
Veritabanının tutarlılığını ve bütünlüğünü koruma komutları
SQL’in Tarihi :
Dr. E.F. Codd ‘un “Communications of The ACM(Association of Computer Machinery)” adlı dergide 1970 Haziranında yayınladığı “A Reletional Model of Data for Large Shared Data Banks”(Büyük ve Paylaşımlı Veri Bankaları İçin İlişkisel Model) adlı makale bugün ilişkisel veri tabanı yönetim sistemleri(RDBMS) için kabul edilen model olmuştur. IBM şirketi Dr.Codd ‘un bu modelini kullanarak “Structured English Query Language (“SEQUEL”)” denilen bir dil geliştirmiştir. 1979 yılında o zamanki adı “Relational Software” olan Oracle şirketi ticari olarak ilk defa SQL kullanmaya başlamıştır. Bugün SQL, ilişkisel veritabanı yönetim sistemlerinin standart dili olarak kabul edilmektedir.
Oracle’da Kullanılan Veri Tipleri:
CHAR(sayı): Sabit uzunluktaki alfasayısal verilerin tutulabildiği alanlar için kullanılır. Oracle 7 ve daha önceki sürümler için bu alanın uzunluğu en fazla 255 karakter olabilir. Oracle 8 ve sonrasında 2000 karakter uzunluğundadır. Eğer, sayı ile ifade edilen numaradan daha kısa uzunlukta veriler girilirse Oracle kaydın sonuna boşluk ekleyerek sabit uzunluğa kadar getirir. Örnek char(20).
VARCHAR2(sayı): Değişken uzunluklu alfasayısal verilerin tutulduğu alanlar için kullanılır. Oracle 7 ve önceki sürümlerinde 2000 karakter, Oracle 8 ve sonraki sürümlerinde 4000 karakter uzunluğunda bilgi girilebilir. Örnek varchar2(30).
NUMBER(n,p): Tamsayı ve Gerçel sayılar için kullanılan sayısal veri tipidir.Tam kısım en fazla 38 basamak olabilir. Ondalık kısmın basamak sayısı da –84 ile 127 arasında değişmektedir. Number veri tipinden türetilmiş int[eger], dec[imal], smallint ve real veri tipleri de kullanılabilmektedir.
DATE: Tarih tutan alanlar için kullanılır. Bu tip alanlarda, tarih bilgileri ve saat bilgileri tutulabilir. Tarih formatları Oracle yüklerken seçtiğiniz dile göre değişir. Amerikan standartı için ‘DD-MON-YY’ dir. Yani bir tarih ’03-MAY-01’ şeklinde görünür. NLS_DATE_FORMAT parametresi ile tarih formatı değiştirilebilir. Tarihsel alanlar üzerinde aritmetiksel işlemler yapılabilir. Sistem tarihi SYSDATE fonksiyonu kullanılarak öğrenilebilir. Sayısal veya karakter olarak tanımlı bir alandaki veriler TO_DATE fonksiyonu ile tarih tipine çevrilebilir.
LONG: 2 GB ‘a kadar bilgi tutabilen karakter alanlar için kullanılır. Bir tabloda bu tipten ancak bir adet alan tanımlanabilir. Long veri tipine sahip alanlar için index oluşturulamaz.
Not: Oracle’da boolean veri tipi yoktur. Bunun için char(1) ya da number(1) şeklinde tanımlama yapılıp kullanılabilir.
Not: Bir tablonun alanları kendi veri tipine uygun değerler alabildiği gibi bir de NULL değer alabilirler. NULL değeri sayısal olarak 0’dan ve karakter olarak ta boş karakterden(‘ ‘) faklıdır.
SQL bölümünün bundan sonraki kısmında SQL komutları örnek tablolar üzerinde anlatılacaktır. Oracle veritabanı ilk yüklendiğinde bir “SCOTT” adlı kullanıcı oluşturulur ve bu kullanıcıya ait demo tablolar da oluşturulur. Bu kullanıcı ve tabloları tamamen deneme amaçlıdır. Biz de raporumuzda bu kullanıcının tablolarını Türkçe’ye çevirip kullanacağız. Rapora ek olarak verilen disketteki demobld.sql dosyası bu tabloları oluşturmak için gereken komutları içermektedir. Disketteki bu dosya SQL*Plus komut satırından çalıştırılmalıdır. Tabi ki bu işlemleri yapabilmek için Oracle 8i veritabanı önceden yüklenmiş olmalıdır. Aşağıda kullandığımız komutları bu tablolar üzerinde deneyebilirsiniz.
Bu amaçla öncelikle tablolarımız hakkında bilgiler verelim. Oluşturduğumuz tablolar bir iş yerindeki işçi kayıtlarını, bolum adlarını tutmak için kullanılan tablolardır. Birinci tablo “isci” tablosudur. Bu tablo iscino:number(4), isciadi:varchar2(10), isi:varchar2(9), muduru:number(4), isbastar:date, ucret:number(7,2), bolum:number(2) alanlarından oluşmaktadır. Tablo da isçilerin numarası, adı, görevi, işe başlama tarihi, aldığı ücret ve işçinin müdür kodu yer almaktadır.

İkinci tablo “bolum” tablosudur. “Bölüm” tablosu bolumno:number(2), bolumadi: varchar2(14), yer: varchar2(13) alanlarından oluşmaktadır. Bu tabloda işçilerin çalıştıkları bölüm kodları,bölüm adları ve bölümün bulunduğu il adı yer almaktadır.

Üçüncü tablo “ucretoran” tablosudur. Bu tabloda derece:number(5), endusuc:number(5), enyukuc:number(5) alanları yer almaktadır. Tablo işçilerin alabilecekleri kıdem numaralarını ve bu numara için en düşük ve en yüksek ücret miktarlarını göstermektedir.

Sorgular
Veri tabanı içerisindeki tablolardan veri seçip listeleme ,kayıt ekleme, silme, değiştirme ile ilgili komutları bu başlık altında anlatacağız. Burada SQL ile ilgili olarak en çok kullanılan komut şekilleri anlatılmaya çalışılacaktır.

SQL/1
Bir tablonun yapısını görmek için DESC[IRIBE] komutu kullanılır.

SQL/2
Bir tablodan istenilen özellikteki verileri veri seçip listeleme için “SELECT” komutu kullanılır. Komutun yapısı:
SELECT [ DISTINCT | ALL ] <sütun(lar)> FROM <tablo adı>
[ WHERE <şart> ]
[ GROUP BY <sütunlar>]
[ HAVING < grup kısıtlaması>]
[ ORDER BY <sütun(lar) [ ASC | DESC ]> ]

SQL/3
Tablo içerisinde istediğimiz bir şarta uygun kayıtları elde etmek istiyorsak “WHERE” yardımcı sözcüğünün yanına gerekli şartı yazmalıyız. Ayrıca select sözcüğünün yanına sadece istediğimiz alanların listelenmesi için alan adları yazabiliriz.

SQL/4
İşi ‘tezgahtar’ olan ve aldığı maaş 900’den büyük olan işçi kayıtların listesi.

SQL/5
İşçi tablosunda maaşı 1000 ile 1400 arasında olan kayıtların işçi adı ve numaralarının listesi.

SQL/6
İşçi tablosunda adı ‘m’ ile başlayan kayıtların listesi.

Burada “_” alt tire işareti tek bir karaktere ve ‘%’ işareti birden fazla karaktere karşılık gelir. Birinci sorguda iki alt tire işareti kullanıldığında 3 adet kayıt listelenmiş, ikinci sorguda alt tire işareti üçe çıkarıldığında iki kayıt listelenmiştir. Çünkü ikinci sorguda istenen kayıtların isciadi alanının uzunluğu en az 5 karaktere çıkarılmış oluyor.

SQL/7
İşçi tablosundan numarası ‘79’ ile başlayan kayıtların isciadi alanına göre tersten sıralanmış listesi. Burada to_char fonksiyonu iscino sayısal alanını karaktere çevirmek ve substr fonksiyonu da soldan ilk iki karakterini alıp karşılaştırma yapabilmek için kullanılmıştır.

SQL/8
Eğer tablodan listelenecek kaydın bir alanının içeriği tam olarak bilinmiyorsa ilgili kelimenin yakın telaffuzu yazılarak “soundex” fonksiyonu ile listeleme yapılabilir.

SQL/9
Months_between(tarih1,tarih2) fonksiyonu iki tarih arasındaki farkı ay olarak verir. Aşağıdaki sorgu komutu bunu gerçekleştirmektedir. Burada işleme sokarak elde ettiğimiz bir alana isim verme(bu örnekte FARK) işlemi de görülmektedir. Bu isim verme işlemi her alan için virgülden önce yapılabilir.

SQL/10
COUNT(* | [ DISTINCT | ALL ] açıklama) fonksiyonu sorgu sonucu dönen kayıt miktarını göstermektedir. Eğer parametre olarak “*” girilirse tablodaki tüm kayıt sayısını verir. Parametre olarak bir sütun adı verilirse, o sütundaki içeriği NULL olmayan tüm kayıt sayısını verir.

SQL/11
“GROUP BY” yardımcı sözcüğü bir alana göre kayıtları guruplamak için kullanılır. Aşağıdaki örnekte isci tablosu içerisinde bir bölümde çalışan toplam kişi sayısı bulunuyor ve listelemede bolum alanı içerisindeki grup sayısı kadar kayıt yer alıyor. Yani bizim isci tablosunda 10,20,30 olmak üzere üç farklı bölüm numarası olduğundan 3 kayıt listeleniyor. Bölüm adı ve kodlarını tutan bölüm tablosunda toplam 4 adet kayıt olduğu, halde 40 nolu bölüm koduna sahip hiç bir işçi için “isci” tablosuna kayıt yapılmamış olduğu buradan anlaşılabilir.

SQL/12
“HAVING” yardımcı sözcüğü “GROUP BY” yardımcı sözcüğü ile gruplanan kayıtlar üzerinde kısıtlama yapma işine yarar. Aşağıdaki örnekte isci tablosunda ikiden fazla kişi tarafından yapılan işlerin listesini veren komut gösterilmiştir.

SQL/13
Bir işçinin adının ve çalıştığı yerin isminin(kodunun değil) listelenmesini istiyorsak, o işçinin çalıştığı yer kodunun adını bolum tablosundan getirmeliyiz. Bu tip işlemler “tablo birleştirme” işlemleri olarak adlandırılır. Verdiğimiz bu örneğe “eşit birleştirme” denir. Eşit birleştirme işlemlerinde bir tablodaki değere, diğer tabloda da mutlaka bir değer karşılık gelir ve “=” operatörü eşit birleştirme işlemlerinde kullanılır.

SQL/14
Bu örnek her bir bölümde belli bir işi yapanların ortalama maaş miktarlarının listesini verir. Örneğin satış bölümünde satış görevlisi olanların aldıkları maaşların ortalaması. Buna göre satış bölümünde 3 kişi varmış ve bunların maaşlarının ortalaması 1450.

SQL/15
Birleştirme işlemlerinde “eşit olmayan birleştirme” de vardır. Buna göre bir tabloda ki bir değer diğer tablodaki iki değer arasında yer almaktadır. Örneğin aşağıdaki örnek isci tablosundaki işçilerin ücretlerini ucretoran tablosundaki en düşük ve en yüksek ücret alanları ile karşılaştırılıp, bu işçilerin kıdemlerini bulmayı sağlıyor. Dikkat edilirse “from” sözcüğünden sonra yazılan tablo adları için bir boşluk bıraktıktan sonra kısa bir isim verilebiliyor. Böylece uzun tablo adını sürekli yazmaktansa o tablo adı için “alias” olarak adlandırılan kısa isim kullanılabiliyor.

SQL/16
Birleştirme işlemleri yapılırken karşımıza şöyle bir problem çıkmaktadır. Birleştirme yapılan tablolardan ikinci tabloda birinci tablodaki her kaydın karşılığı olmazsa, karşılığı olmayan kayıtlar sorgu sonucunda sadece olmayan kayıtlar değil bilakis hiç kayıt gelmez. Bunun için “dış birleştirme” kullanılır. Dış birleştirme işlemi, kayıtları eksik olan tablonun şart tarafına “(+)” işareti konularak yapılır. Örneğin isci tablomuzda çalıştığı bölüm kodu 40 olan hiçbir kayıt yoktu, fakat bolum tablosunda 40 kodlu bir bölüm vardı. Bu tablolardan tüm bölümlerde çalışan işçilerin listesini veren komutun şöyle yazıldığını düşünelim:

Dikkat edilirse 40 nolu bölümden işçi tablosunda hiç kimse olmadığı için böyle bir bölümün var olduğu bu sorgudan anlaşılamıyor. Bu komut şöyle yazılsaydı daha doğru olacaktı:

SQL/17
Bazen bir tablonun içindeki alanlar birbirleri ile ilişkili olabilir. Örneğin isci tablosunda bir işçinin müdürünün kodu tutulmakta ve bu müdürün kaydı da ayrı bir kayıt olarak yine isci tablosunda yer almakta. Burada “kendine birleştirme”(self-join) kullanılır. Aşağıda bununla ilgili bir örnek verilmiştir.

SQL/18
Birkaç tablo üzerinde yapılan sorgular üzerinde birleştirme ya da fark alma işlemleri yapılabilir. Bunun için UNION, INTERSECTION ve MINUS operatörleri kullanılır. Aşağıdaki örnekte isci tablosundan yapılan iki sorgu UNION operatörü ile birleştirilmiştir.

SQL/19
Aşağıdaki sorgu ile çalıştığı bölüm kodu 30 olan ve müdür olmayan işçiler listelenmiştir.

SQL/20
Aşağıdaki sorgu ile işi “satış gör” olan ve müdür kodu 7698 olan kayıtlar listelenmiştir.

SQL/21
SQL*Plus kullanırken kullanıcıdan alınan bir bilgiye uyacak şekilde sorgulamalar yapılabilir.Örneğin aşağıda kullanıcının girdiği işçi numarasına ait bilgileri listeleyen bir sorgu yer almaktadır:

SQL/22
SQL’de bir sorgunun çıktısı diğer bir sorgu için girdi olarak kullanılabilir. Bunu göstermek için isci tablosu içerisinde maaşı, tüm kayıtların ortalama maaşından az olan kayıtların, listesini veren bir sorgu gösterilmiştir.

SQL/23
SQL’de bir tabloya yeni bir kayıt eklemek için “INSERT INTO” komutu kullanılır. Aşağıda isci tablosuna yeni bir kayıt ekleme komutu gösterilmiştir.
INSERT INTO tablo-adı (sütun1,sütun2,…….) VALUES (değer1,değer2,….)

SQL/24
SQL’de bir tablodan kayıt silmek için ‘DELETE FROM’ komutu kullanılır.
DELETE FROM tablo-adı WHERE şart

SQL/25
SQL’de bir tablodaki bir kayıtta değişiklik yapma komutu ‘UPDATE’ tir. UPDATE tablo-adı SET sütun-adı=değer WHERE şart

PL/SQL
Oracle ürünleri başlıklı kısımda genel bilgi olarak anlattığımız PL/SQL’in burada ayrıntılarına ineceğiz.
PL/SQL Bloklarının Yapısı
PL/SQL blok yapılı bir dildir. Her bir blok bir program ünitesini oluşturur. Pl/SQL blokları prosedür, fonksiyon ve normal blok olarak üçe ayrılır. Prosedür ve fonksiyon yapısı ileride ele ele alınmıştır. Şimdi burada normal bir blok yapısı işlenecektir. Bir PL/SQL bloğu seçimlik bir tanımlama bölümü, PL/SQL cümlelerinin yazıldığı bir bölüm ve hata yakalama bölümünden oluşur. Bloklara isim vermek zorunlu değildir. Eğer hazırlanan bir blok yeniden kullanılmak istiyorsa .sql uzantılı dosyalara saklanıp yeniden kullanılabilir.
* “[“ ve “]” işaretleri arasındaki alanların yazılması zorunlu değildir.

[<blok başlığı>]
[DECLARE
<sabitler>
<değişkenler>
<imleçler>
<kullanıcı tanımlı hata yakalama isimleri>]
BEGIN
<PL/SQL komutları>
[ EXCEPTION
<hata durumu komutları>]
END;
Blok başlığı PL/SQL bloğunun prosedür, fonksiyon veya bir paket bloğu olup olmadığını belirler. Eğer bir başlık tanımlanmazsa bu isimsiz blok(anonymous) olarak adlandırılır. “Declare” kısmı diğer programlama dillerinde olduğu gibi değişken ve sabitlerin tanımlandığı kısımdır.
PL/SQL blokları içerisinde kullanılan tüm sabitler, değişkenler, imleçler ve kullanıcı tanımlı hata durumları “declare” kısmında tanımlanmalıdır. Burada sabit ve değişkenler şöyle tanımlanabilir:
<değişken adı> [constant] <veri tipi> [not null] [:= <ilk değer>];
SQL’de kullanılan tüm veri tipleri(SQL bölümünde anlatılmıştı) ve Boolean veri tipi burada kullanılabilir. Boolean tipte bir değişken “true”, “false” ve “null” değerlerini alabilir. “not null” yan cümlesi değişkenin mutlaka bir değer alması gerektiğini bildirir. Burada tanımlanan değişkenlere “:=” operatörü ile ilk değer atanabilir. Eğer bir ilk değer atanmazsa değişkenlerin alacağı ilk değer “null” ‘dur. Eğer “constant” ile tanımlama yapılırsa değişkenin değeri değiştirilemez.

DECLARE
isbastar date; /* ilk değeri “null” */
isi varchar2(80) := ‘tezgahtar’;
isci_bulundu boolean; /* ilk değeri “null” */
maas_artisi constant number(3,2) := 1.5; /* sabit */
BEGIN … END;

Tanımlama kısmında değişkenlere bir veri tipi vermek yerine bir tablodaki bir alanın veri tipi değişkene aktarılabilir. Örneğin “isci.iscino%TYPE” şeklinde bir tanımlama ilgili değişkenin “isci” tablosundaki “iscino” değişkeni ile aynı veri tipinde olmasını sağlar. Tek bir değişken için tablonun bir alanının veri tipini almak yerine tablonun tüm alanlarının veri tipleri bir değişkene aktarılabilir. Örneğin “isci%ROWTYPE” ile istenen değişkene tablonun yapısı aynen aktarılabilir. Buna tıpkı Pascal’daki gibi “record” veri tipi denir. Burada eğer “tablo isci%ROWTYPE” şeklinde bir tanımlama yapılırsa tablo.iscino ya da tablo.isciadi şeklinde değişkenler kullanılabilir. Bu tür bir tanımlama imleç kullanırken kolaylık sağlar.
PL/SQL blokları içerisinde gerçekleştirilecek işlemler begin..end kelimeleri arasına yazılır. Burada dikkat edilmesi gereken bir husus vardır: PL/SQL blokları içerisinde veri tanımlama dili komutları(yani Create Table, Alter TableSpace, Drop User gibi) ve veri kontrol dili komutları(grant ve revoke gibi) kullanılamaz. Pl/SQL blokları içerisinde veri işleme dili komutları kullanılabilir. (Select, Update, Delete, Insert gibi) .
Hata durumları ya da aykırı durumlar olarak adlandırılan “exceptions” kısmında PL/SQL blokları arasında gerçekleşen bazı hataları kullanıcıya yansıtmadan kontrol etme ve gerekli işlemleri yapma olanağı vardır. Oracle tarafından tanımlanmış hata durumları olduğu gibi programcılar da hata durumları tanımlayabilirler.
PL/SQL Akış Kontrolü
Pl/SQL blokları içerisinde kosullu-koşulsuz dallanmalar ve döngüler kullanılabilir. Bu amaçla kullanılan yapıları burada inceleyeceğiz. PL/SQL’de iki tip kontrol yapısı vardır. Brincisi “IF” kontrol yapısı ve diğer “LOOP “ kontrol yapısı.
IF Kontrol Yapısı
PL/SQL içerisinde üç tip “IF” yapısı kullanılır:
1-) IF şart THEN 2-)IF şart THEN 3-)IF şart THEN
Komutlar komutlar komutlar
END IF ELSE ELSEIF şart
Şartın gerçekleşmemesi komutlar
halindeki komutlar ENDIF
END IF

LOOP Kontrol Yapısı
PL/SQL içerisinde temel LOOP, FOR ve WHILE döngüleri vardır.
LOOP
Komut1
…..
KomutN
GOTO etiket adı
EXIT [WHEN şart]
END LOOP

FOR sayac IN [REVERSE] başlangıç..bitiş
LOOP
Komut1
…
KomutN
EXIT [WHEN şart]
END LOOP

WHILE şart LOOP
Komut1
…
KomutN
END LOOP

İmleçler
Birden fazla kaydın hafızaya getirilme işlemlerine imleç(cursor) açma denir. İmleç açma, özellikle veritabanındaki tablolardan kayıtların teker teker getirilmesinde faydalı olmaktadır. Kayıtlar teker teker getirilerek üzerinde işlemler yapılıp tekrar veritabanına kaydedilebilmektedir. Oracle, hafızada bu tip işlemleri yapabilmek için yer ayırmaktadır. İki çeşit imleç vardır:
Kapalı İmleçler(Implicit Cursors): Yazılan her SELECT, INSERT, UPDATE ve DELETE komutları için veritabanı tarafından otomatik olarak açılan imleçlerdir. Yazılan her SQL için, SQL’in yazım kontrollerini yapmak ve SQL’i çalıştırmak için hafızadan bir yer ayrılır. Bu ayrılan yer için standart olarak tanımlanan imlece kapalı imleç denir.PL/SQL blokları arasında yazılan SQL komutları için, tanımlanan kapalı imlece ait özellikler geçerli olmaktadır. Yazılan her SQL için tanımlanan kapalı imleçlerin şu özellikleri kullanıma açıktır:
SQL%ISOPEN : SQL sonucu eğer imleç açık ise “true” değeri, kapalı ise “false” değeri döndürür.
SQL%ROWCOUNT : SQL cümlesi tarafında işlem gören kayıt sayısnı görüntüler.
SQL%FOUND : SQL sonucu en az bir kayıt işlem görmüşse “true”, hiç kayıt işlem görmemişse “false” döndürür.
SQL%NOTFOUND : SQL sonucu eğer hiçbir kayıt işlem görmemişse “true”, en az bir kayıt işlem görmüşse “false” değeri dödürür.

DECLARE
Silinen_kayit_sayisi number(5);
BEGIN
delete from isci
where bolum=10;
silinen_kayit_sayisi:=SQL%ROWCOUNT;
END;
DECLARE
delete from isci
where bolum=10;
if SQL%FOUND then
commit;
else
rollback;
END;
Açık İmleçler(Explicit Cursor): Kullanıcı tarafından belirli bir işi yapabilmek için açılan imleçlerdir. Özellikle fazla sayıda kayıtların bulunduğu tablolarda, silme, güncelleme ve benzer işlemlerde çok kullanışlı program parçalarıdır.

DECLARE
CURSOR <imleç adı> [(<parametre listesi>)] IS
SQL cümlesi
Kayıt_tipi_değişkeni <imleç adı>%ROWTYPE
Değişken_1 NUMBER;
Değişken_2 NUMBER;
BEGIN
OPEN <imleç adı>
LOOP
FETCH <imleç adı> INTO kayıt_tipdeğişkeni;
EXIT WHEN <imleç adı>%NOTFOUND;
……..
komutlar;
END LOOP;
CLOSE <imleç adı>;
END;
Burada imleç adı PL/SQL blokları içerisinde başka bir değişken adı olarak kullanılıyor olmamalıdır. Parametreler “<parametre adı> <veri tipi>” şeklinde bildirilmelidir. PL/SQL içerisinde kullanılan tüm veri tipleri parametreler için kullanılabilir.(char, varchar2, number, date, boolean ya da number veri tipinin integer, real gibi alt veri tipleri). Aşağıda farklı şekillerde açılmış imleç örnekleri verilmiştir:
CURSOR c1 IS SELECT iscino, isciadi, isi, ucret FROM isci WHERE ucret > 2000;
CURSOR c2 RETURN bolum%ROWTYPE IS SELECT * FROM bolum WHERE bolumno = 10;
CURSOR c3 (verilen_tarih DATE) IS
SELECT iscino, ucret FROM isci WHERE isbastar > verilen_tarih;

Eğer bir imleç açıldığında kayıtlar üzerinde değişiklik yapılacaksa, imleç tanımından sonra “for update[(<sütun(lar)>)]” şeklinde tanımlama yapılmalıdır. Böyle bir tanımlama yapıldığında imleç içerisindeki kayıtlar kilitlenir ve “commit” komutu uygulanana kadar diğer kullanıcılar bu kayıtlara erişemez.
Hata Durumları
Hata durumları normalin haricindeki durumlarda nelerin yapılacağının tanımlandığı bölümdür. Belirtilen özel durum oluştuğunda Oracle, PL/SQL komutlarını çalıştırmaya devam etmemekte, onun yerine o özel durumda yapılması tanımlanan işlemleri yapmaya çalışmaktadır. Hata durumları iki türlüdür: Oracle tarafından önceden tanımlanmış hata durumları ve kullanıcı tanımlı hata durumları.
EXCEPTION
WHEN <önceden tanımlanmış hata durumu> THEN
Komutlar

Oracle tarafından tanımlı çok kullanılan hata durumları:

DUP_VAL_ON_INDEX Tekil olması gereken bir alana bu durumu ihlal eden bir kayıt eklenmeye çalışıldığında ortaya çıkar.
INVLAID_CURSOR “OPEN” komutu ile açılmamış bir imleç ile işlem yapılmaya çalışıldığında ortaya çıkar.
INVALID_NUMBER Değişkenin tanımından daha büyük bir sayı değişkene atanmak istendiğinde ortaya çıkar.
NO_DATA_FOUND SQL sonucu kayıt dönmediği zaman ortaya çıkar.
ZERO_DIVIDE Sıfıra bölme işleminde ortaya çıkan durumdur.
TOO_MANY_ROWS Bir kayıt dönmesi gereken SQL ‘den birden fazla kayıt döndüğünde ortaya çıkan durumdur.
VALUE_ERROR Numerik veya karakter tipli bir değişkenin diğerinin yerine kullanılmaya çalışıldığı durumdur.
CURSOR_ALREADY_OPEN Açık bir imlecin tekrar açılmaya çalışıldığı durumdur.
LOGIN_DENIED Veritabanına yanlı kullanıcı adı ve şifre ile bağlanılmaya çalışıldığı durumdur.
NOT_LOGGED_ON Veritabanına bağlanmadan SQL cümlesi çalıştırıldığında ortaya çıkan durumdur.
OTHERS EXCEPTION bölümünde yazılan hata durumlarından hiç biri oluşan hatayla eşleşmediğinde bu durum işleme girer.

Kullanıcıların tanımladığı hata durumları da önceden tanımlı hata durumları ile benzerdir. Farklı olarak kullanıcı bir prosedür çağırıyormuş gibi bu hata durumlarını da çağırmalıdır. Çağırmak için “RAISE” komutu kullanılır.

DECLARE
……
BEGIN
……
IF ucret<2000 THEN
RAISE dusuk_maas;
END IF;
……
EXCEPTION
WHEN dusuk_maas THEN
Message(‘Düşük maaşlı işçi’);
END;

PL/SQL Prosedürleri
Prosedürler belirli işlemleri gerçekleştirmek üzere oluşturulan özel bloklardır. PL/SQL’de prosedürler diğer programlama dillerinden biraz farklı olarak birden fazla değer döndürebilirler.

PROCEDURE isim [(parametre[, parametre, ...])] IS
[yerel tanımlamalar]
BEGIN
komutlar
[EXCEPTION
hata durumları]
END [isim];

parametre_adı [IN | OUT [NOCOPY] | IN OUT [NOCOPY]] veritipi
[{:= | DEFAULT} açıklama]

Bir prosedürün iki kısmı vardır: tanımlama ve gövde. Tanımlama kısmı PROCEDURE kelimesi ile başlar ve prosedür adı ya da parametre listesi ile biter. Parametre tanımlamaları zorunlu değildir. Parametre kullanılmayan prosedürler parantez kullanmadan yazılabilirler.
Prosedürün gövde kısmı IS anahtar kelimesi ile başlar ve END anahtar kelimesi ile biter. Prosedürün gövdesi de üç kısma ayrılır: değişkenlerin tanımlandığı kısım, komut cümlelerinin yazıldığı kısım ve hata durumlarının kontrol edildiği kısım. Değişken tanımlama kısmı IS kelimesinden hemen sonra başlar. Burada DECLARE kelimesi kullanılmaz. Komut cümlelerinin yazıldığı kısım ise BEGIN anahtar kelimesi ile başlar ve EXCEPTION ya da END ile biter. Bu kısımda en az bir komut yazılmalıdır. Hata durumları kısmı zorunlu değildir. Prosedür END kelimesi ile son bulur. Bu anahtar kelimenin yanına prosedür ismi yazılabilir, zorunlu değildir.
Aşağıdaki maas_artir prosedürü bir işçinin maaşının verilen miktar kadar artırılmasını sağlar:

PROCEDURE maas_artir (isci_no INTEGER, miktar REAL) IS
gecerli_ucret REAL;
ucret_yok EXCEPTION;
BEGIN
SELECT ucret INTO gecerli_ucret FROM isci
WHERE iscino = isci_no;
IF gecerli_ucret IS NULL THEN
RAISE ucret_yok;
ELSE
UPDATE isci SET ucret = ucret + miktar
WHERE iscino = isci_no;
END IF;
EXCEPTION
WHEN NO_DATA_FOUND THEN
print ‘Yanlış İşçi Numarası’
WHEN ucret_yok THEN
print ‘Geçerli Maaş Miktarı Yok’);
END maas_artir;

Bu prosedür bir başka blok içerisinden şöyle çağırılabilir:
DECLARE
isci_no NUMBER;
miktar REAL;
BEGIN
…
maas_artir(isci_no, miktar);

PL/SQL Fonksiyonları
Bir fonksiyon bir değer hesaplayan alt programdır. Fonksiyon ve prosedür yapıları RETURN anahtar kelimesi haricinde benzerdir. Fonksiyonlar şöyle yazılabilirler:

FUNCTION isim [(parametre[, parametre, ...])] RETURN veri_tipi IS
[yerel tanımlamalar]
BEGIN
Komut cümleleri
[EXCEPTION
Hata durumları]
END [isim];

Parametre listesi şu düzende verilebilir:

parametre_ismi [IN | OUT [NOCOPY] | IN OUT [NOCOPY]] veri_tipi
[{:= | DEFAULT} açıklama]

Yukarıda prosedürler için anlatılan yapı kısmı fonksiyonlar içinde geçerlidir. Fark olarak burada fonksiyon tek bir değer döndürür ve bu değerin tipi RETURN anahtar kelimesinde sonra yazılır.
Aşağıdaki fonksiyon bir maaş miktarının istenen dereceye ait olup olmadığını bulur:

FUNCTION maas_ok (maas REAL, ucret_derece INTEGER) RETURN BOOLEAN IS
min_ucret REAL;
max_ucret REAL;
BEGIN
SELECT endusuc, enyukuc INTO min_ucret, max_ucret
FROM ucretoran
WHERE derece = ucret_derece;
RETURN (maas >= min_ucret) AND (maas <= max_ucret);
END maas_ok;

Bu fonksiyon bir başka blok içerisinden şöyle çağrılabilir:

DECLARE
yeni_ucret REAL;
yeni_derece NUMBER(5);
BEGIN
…
IF maas_ok(yeni_ucret, yeni_derece) THEN …

Kayıtlı Alt Programlar
Bir PL/SQL alt programını Oracle’ın tüm diğer ürünlerinde de kullanmak istiyorsak bu alt programı veritabanına kaydedebiliriz. Alt programları Oracle veritabanına kalıcı olarak kaydetmek için CREATE PROCEDURE ve CREATE FUNCTION komutları kullanılır.

Parametre Modları
Yukarıda fonksiyon ve prosedürler anlatılırken bunlara parametreler geçirilebileceği söylenmişti. Bir alt programa parametreler üç farklı modda geçirilebilir. Bunlar IN, OUT, IN OUT olarak adlandırılır. Bu üç mod her alt programda kullanılabilir. Fakat OUT ve IN OUT modlarının fonksiyonlarda kullanılmaması önerilir. Çünkü bir fonksiyonun amacı sıfır, bir ya da daha çok parametre alıp sonuçta tek bir değer göndermektir.
IN modunda alt programa geçirilen bir parametre bir sabit gibi davranır. Yani alt program içerisinde bu parametrenin değeri alınıp başka bir değişkene aktarılabilir, fakat değiştirilemez. Eğer parametre geçirirken hiçbir mod belirtilmezse, parametreler otomatik olarak IN modunda kabul edilir. IN modunda gönderilen parametre bir sabit, string, değişken ve matematiksel bir işlem olabilir.
OUT modunda gönderilen bir parametre alt program içerisinde bir değişken gibi davranır. Paramterenin değeri alnıbilir ve değiştirilebilir. Bu tip bir parametre mutlaka bir değişken olmalıdır. Yani bir sabit ya da matematiksel bir işlem bu modda gönderilemez. Burada alt programa gönderilen parametrenin değeri, alt programa geçtiği anda NULL değer olur. Bu yüzden alt programa OUT modunda gönderilecek bir parametre tanımlanırken NOT NULL kısıtlamasının getirilmemiş olmasına dikkat edilmelidir. Alt program bittikten sonra, alt program içerisinde değer atanmış olan OUT modu parametreleri bu değerlerini korurlar. Yani girişte NULL değer alıp çıkışta değerlerini korurlar.
IN OUT modunda gönderilen parametreler diğer iki modun yaptığını birleştirirler. Yani bir parametre bir ilk değer ile alt programa girer, alt program içerisinde bu değeri değişebilir ve değerini kaybetmeden alt programdan çıkar. IN OUT modunda gönderilen bir parametre bir değişken olmalıdır, sabit, string ya da matematiksel bir işlem olamaz.
PL/SQL Paketleri
Oracle’da paket olarak adlandırılan nesneler, birbiriyle ilişkili fonksiyon ve prosedürlerin bir isim altında gruplanmasıyla oluşturulur. PL/SQL paketleri sayesinde daha modüler programlar geliştirilebilir. Birden fazla uygulama tarafından kullanılan bir paket üzerinde değişiklik yapılarak, tüm bu uygulamaların güncellenmesi sağlanabilir. Bir paket içerisindeki bir alt program çağrıldığında, tüm paket belleğe alınır ve bu paketle ilişkili diğer alt programlar bu sayede hızlı çalıştırılabilir.
Bir paket tanımlama ve gövde kısımlarından oluşur. Tanımlama kısmı bir ara yüz gibidir. Veri tipleri, sabitleri hata durumları, imleçler ve alt programlar burada tanımlanır. Paket gövdesinde ise imleçlerin ve alt programların işlem satırları yer alır.
Aşağıda Oracle yardım dokümanları içerisinde verilmiş bir şema yer almaktadır. Burada anlatılmak istenen “kara kutu” olarak verilen gövde kısmında rahatlıkla değişiklik yapılabileceğidir. Tanımlamalar “specification” kısmında yer aldığına göre gövdede yapılan değişikliklerden uygulama programı etkilenmeyecektir.

Bir paket oluşturmak için CREATE PACKAGE komutu kullanılır:
CREATE [OR REPLACE] PACKAGE paket_ismi
[AUTHID {CURRENT_USER | DEFINER}] {IS | AS}
[tip_tanımı [tip_tanımı] …]
[imleç_tanımı [imleç_tanımı] …]
[{altprog_tanımı | çağrı_tanımı}[{altprog_tan | çağrı_tan}]…]
END [paket_ismi];

[CREATE [OR REPLACE] PACKAGE BODY paket_ismi {IS | AS}
[tip_tanımı [tip_tanımı] …]
[imleç_gövdesi [imleç_gövdesi] …]
[{altprog_tanımı | çağrı_tanımı} [{altprog_tan | çağrı_tan}]…]
[BEGIN
komut_cümleleri]
END [paket_ismi];]

Tanımlama kısmı genel tanımlamaları içerir ve uygulama programları tarafından görülür. Gövde kısmı ise program kodlarını, ayrıntıları ve özel tanımlamaları içerir. Uygulama programları buraya erişemez. Gövde de değişiklik yapıldığında uygulama programlarının yeniden derlenmesi gerekmez. Burada AUTHID kısmı paketi oluşturan kullanıcın adıdır.

CREATE OR REPLACE PACKAGE isci_islem AS — tanımlama
TYPE IsKayTip IS RECORD (isci_no INTEGER, ucret REAL);
CURSOR ucret_liste RETURN IsKayTip;
PROCEDURE isci_kayit (
İscino NUMBER
isciadi VARCHAR2,
isi VARCHAR2,
muduru NUMBER,
ucret NUMBER,
bolum NUMBER);
PROCEDURE isci_sil (isci_no NUMBER);
END isci_islem;

CREATE OR REPLACE PACKAGE BODY isci_islem AS — gövde
CURSOR ucret_liste RETURN IsKayTip IS
SELECT iscino, ucret FROM isci ORDER BY ucret DESC;
PROCEDURE isci_kayit (
İscino NUMBER,
isciadi VARCHAR2,
isi VARCHAR2,
muduru NUMBER,
ucret NUMBER,
bolum NUMBER) IS
BEGIN
INSERT INTO isci VALUES (iscino, isciadi, isi,
muduru, SYSDATE, ucret, bolum);
END isci_kayit;
PROCEDURE isci_sil (isci_no NUMBER) IS
BEGIN
DELETE FROM isci WHERE iscino = isci_no;
END isci_sil;
END isci_islem;

PL/SQL Tetiklemeleri
Tetiklemeler(PL/SQL Triggers) tıpkı prosedürler gibi veritabanına kaydedilir, fakat program kodu içerisinde çağrılarak işletilmezler. Tetiklemeler veritabanı tarafından otomatik olarak başlatılırlar. Tetiklemeleri başlatan bazı olaylar vardır. Bu olaylar INSERT, UPDATE, DELETE gibi veri işleme dili komutları, veri tanımlama dili komutları, veri tabanı açma-kapama işlemleri, bir kullanıcnın bağlanma ya da bağlantı kesme işlemleri gibi olaylardır. Bir tetikleme prosedürü üç bölümden oluşur:
Tetikleme olayı ya da komutu
Tetikleme kısıtlaması
Tetikleme işlem bölümü

Tetiklemelerin oluşturulmasını göstermek için bir örnek yapalım. “isci” tablomuzdaki herhangi bir işçinin maaşı arttığında maaşı 1000’i geçenleri başka bir tabloya kaydeden bir tetiklme yazalım. Burada işleme maaş artıktan sonra başlayacağız. Bu yüzden AFTER UPDATE kullanıyoruz. Tetiklemelerin bu kısmına AFTER ve BEFORE gibi kelimeler yazılır. AFTER INSERT OR UPDATE gibi iki olayı kapsayan şartlarda yazılabilir. Buraya ON DATABASE SHUTDOWN gibi sistem olaylarıda yazılabilir.

CREATE OR REPLACE TRIGGER maas_artisi
AFTER UPDATE ON isci
FOR EACH ROW
WHEN (new.ucret > 1000)
BEGIN
INSERT INTO isci_log (isci_no, artis_tarihi, yeni_ucret)
VALUES (:new.iscino, SYSDATE, :new.ucret );
END;

—

Veritabanı yapıları
Mantıksal (logical)
Fiziksel (physical)

Oracle Sistem Mimarisi
Dosyalar (files) Bellek yapıları (memory structures)
Sistem genel alanı (System Global Area – SGA)
Program Genel Alanı (Program Global Area – PGA)
Görevler (processes)
Kullanıcı (user) görevleri
Oracle görevleri
Oracle An ‘ı (instance)
Veritabanı Yapıları
Mantıksal Yapılar
Tablespaces

Veritabanı, tablespace olarak adlandırılan mantıksal saklama birimlerine bölünür. Tablespace, aralarında bir ilişki olan mantıksal yapıların gruplandırılmasında kullanılır.
Bir tablespace online(erişilebilir) ya da offline(erişilemez) olabilir. Normalde tablespace ‘ler üzerlerindeki bilgiye erişimin yapılabilmesi için online konumundadır. Fakat bazı özel amaçlarla tablespace ‘ler offline konumuna alınabilirler.

Şema ve Şema nesneleri
Şema, nesnelerden oluşan bir derlemdir. Şema nesneleri doğrudan veritabanının verilerine karşılık gelen mantıksal yapılardır.
Çizelge (Table): Oracle veritabanında verileri saklamak için kullanılan temel birimdir. Çizelgeler satırlar (rows) ve sütunlar (columns) olarak tutulurlar. Her çizelge, adı ve sütun kümesi (nitelik) ile tanımlanır. Her sütunun bir adı, türü ve genişlik ya da duyarlılığı verilir. Çizelge bir kez yaratıldıktan sonra içine geçerli satırlar konulabilir ve daha sonra da bu çizelgenin satırları sorgulanabilir, silinebilir ya da günlenebilir.
Görüntü (view): Bir ya da daha fazla çizelgedeki verilerin özel bir gösterimidir. Bir görüntü, saklanmış bir sorgu (stored query) olarak da düşünülebilir. Görüntüler, gerçekte veri içermezler. Verilerini, temel çizelgeler (base tables) olarak adlandırılan çizelgelerden ya da başka görüntülerden türetirler. Görüntüler, çizelgeler gibi, üzerlerinde bazı sınırlamalarla ekleme, silme, günleme ve sorgulama işlemlerine izin verirler. Görüntü üzerinde gerçekleştirilen tüm işlemler, görüntünün temel tablolarını da etkiler.
Seriler (sequences): Sequence, veritabanı çizelgelerinin numerik sutunları için biricik (unique) numaralar üretir. Çizelge satırları için otomatik olarak biricik numaralar oluşturmaya yarar. Sıra numaraları çizelgelerden bağımsızdır. Bu yüzden aynı sequence faklı çizelgelerce kullanılabilir.
Program birimleri (program units): Bu terim, yordam ve işlev (procedure and function) ile paketler (package) için kullanılır.
Yordam ve işlev: Belirli bir görevin yapılabilmesi için SQL ve PL/SQL deyimlerinin çalıştırılabilir bir birim halinde gruplandırılmasıdır.
paketpackage): İlgili yordamların, işlevlerin ve başka paketlerin veritabanı içinde bir birim olarak saklanması ve kılıflanması için bir yöntem sağlar.
Eşanlamlılar (synonyms): çizelge, görüntü, sequence ya da bir program birimi bir takma addır (alias). synonym ‘in kendisi bir nesne değildir, sadece gerçek nesneye bir referanstır. Şu amaçlarla kullanılır;
- Nesnenin gerçek adını ve sahibini gizlemek amacıyla,
- Nesneye, herkese açık (public) bir erişim sağlamak için,
- Uzak veritabanlarındaki nesnelere şeffaf bir erişim sağlamak için,
- SQL deyimlerini basitleştirmek için.

index, cluster ve hash cluster : çizelgelerle ilgil seçimlik ve veri erişimindeki performansı artırmaya yönelik yapılardır.

index: Aranan bilginin nerede olduğunun anahtar (key) değerinden yararlanılarak hızlıca bulunabilmesini sağlar. Mantıksal ve fiziksel olarak veriden bağımsızdır. Bir index, diğer index ‘leri ya da çizelgeleri etkilemeksizin yok edilebilir ya da yaratılabilir.

cluster: Aralarında ilişki olan verilerin disk ortamın fiziksel olarak ardışık olarak tutulmasını ve bu sayede disk erişim süresinde iyileştirme sağlar.

hash cluster(anahtarlama işlevi): Saklanacak verinin yerinin bir hash işlevi tarafından bulunduğu cluster yapısıdır. Hash işlevinden aynı sonucu veren veriler fiziksel olarak beraber saklanır.

database links: Bir veritabanından diğerine bir yol tanımlayan bir nesnedir.

Data Block, Extent ve Segment
Oracle datablock: Veritabanındaki verilerin saklandığı enküçük birimdir. Bir veri bloğu disk üzerinde belirli bir veritabanı alanına karşılık gelir ve bir bloğun kaç baytdan oluştuğu bilgisi, veritabanı yaratılırken verilir.
extent: Ardışık olarak sıralanmış veri bloğu sayısıdır.
segment: Belirli bir mantıksal yapı için ayrılmış extent ‘lerin kümesidir (data segment, index segment, rollback segment, temporary segment gibi).
Fiziksel Yapılar Oracle veritabanı, bir ya da daha fazla kontrol dosyasından, veri dosyalarından ve adları kontrol dosyalarında bulunan redo log dosyalarından oluşur.
Fiziksel Yapı Tanımı Veri Dosyaları (Data Files) Tüm veritabanı verilerini içerir. Mantıksal yapılar (table, index..) veri dosyaları içinde fiziksel olarak saklanır.
Redo Log Dosyaları (Redo Log Files): Kurtarma amacıyla kullanılmak üzere, veritabanına yapılan tüm değişiklikleri tutar.
Kontrol Dosyaları (Control Files): Veritabanının fiziksel yapısını ve durumunu kaydeder.

Oracle Sistem Mimarisi
Dosyalar (files)
Veri Dosyaları (Data Files)
Oracle veritabanı bir ya da daha fazla veri kütüğünden oluşur. Veri dosyaları;

Veritabanının kendisi hakkındaki bilgiyi saklayan veri sözlüğünü (data dictionary) ve kullanıcı verilerini içerir. Sql*Plus ya da Sql*DBA kullanılarak SQL deyimleri yardımıyla yaratılabilir ve mantıksal Oracle bloklarına bölünebilir.

Oracle, gerekli alanı işletim sistemi tarafından yaratılırken ayırılan büyük ve sabit boylu dosyalar kullanır. Her dosya, çizelge (table) ya da dizin (index) gibi bir çok nesne içerir. Dosya alanlarının yönetimi, veritabanı yöneticisinin (Database Administrator-DBA) başlıca görevlerinden biridir.

Günlük Dosyaları (Redo Log Files) Günlük dosyaları; veritabanında yapılan değişiklerin tutulduğu dosyalardır. Döngüsel bir biçimde yazılır gruplar halinde yapılandırılır. normal olamayan bir kapanış (abnormal shutdown) ya da sonra medya arızasından (media failure) sonra kurtarma (recovery) amaçlı kullanılır. Kullanıcı tarafından doğrudan okunamaz. SQL deyimleri ile oluşturulur.

Çoklanmış (multiplexed) Günlük Dosyaları Enaz iki tane redo log grubu olmalıdır. Redo log dosyaları için önerilen konfigürasyon her grup için herbiri farklı disklerde olan enaz iki üye gerektirir. Grup üyeleri aynı zamanda günlenir ve her grupta aynı sayıda üye vardır. Bir grubun tüm üyeleri aynı bilgiyi taşır.

Kontrol Dosyaları (Control Files)
Kontrol dosyası, veritabanının yapısını tarif eden küçük bir ikili (binary) dosyadır. Bu dosya;

- veritabanının açılması ve ona erişilmesi için gereklidir.
- veritabanı açıldığında Oracle ‘ın üzerine yazabilmesi sağlanmalıdır.
- tüm veri ve günlük dosyalarını tanımlar.
- veritabanının adını saklar.
- kurtarma için gerekli olan zamanuyumlama bilgisini sağlar.
- veritabanının yaratılması esnasında yaratılır.

Güvenlik için her biri farklı diskler üzerinde olan en az iki tane kontrol dosyası olmalıdır. Tüm kontrol dosyaları aynı bilgiyi içerir. Eğer biri kaybolacak olursa diğerleri kullanılır durumda kalacaktır. Kontrol dosyasının öngörülen ismi işletim sistemine bağlıdır.

Bellek Yapıları (memory structures)
Sistem Genel Alanı (System Global Area – SGA)
SGA ‘nın üç tane bileşeni vardır;

Database Buffer Cache Veritabanının yakın zamanlarda kullanılan veri bloklarının tutulduğu buffer ‘ların kümesidir. Bu buffer ‘lar, değişikliğe uğramış fakat diske henüz yazılmamış verilere sahip olabilirler. Sık kullanılan verileri tuttukları için de diske erişimi azaltıp performansı artırırlar.

Redo Log Buffer Veritabanında yapılan değişikliklerin tutulduğu buffer ‘lardır. redo log buffer ‘larında tutulan redo girişleri kurtarma gerekli olduğu anda kullanılmak üzere redo log dosyalarına yazılırlar.

Paylaşılmış SQL Alanı (Shared SQL Area) ve Paylaşılmış Havuz (Shared Pool) Paylaşılmış SQL Alanı, Oracle ‘ın özel SQL deyimlerini çalıştırmak için kullandığı bilgileri içerir. Bir SQL sorgusu işletilmeden önce ayrıştırılır ve bu sorgunun çalıştırılması için bir çalışma planı hazırlanır. İşletilen sorgular bu alanda saklanır. Aynı sorgu birkez daha işletilmek istenirse bu çalıştırma planı doğrudan uygulanabilir. Paylaşılmış SQL Alanı, SGA içindeki Paylaşılmış Havuz ‘un bir parçasıdır.
Paylaşılmış Havuz;
- SQL ve PL/SQL deyimlerini
- SQL ve PL/SQL deyimlerinin ayrıştırılmış hallerini
- SQL ve PL/SQL deyimleri için çalıştırma planlarını
- Veri sözlüğü (data dictionary) önbelleğini (cache) içerir.

Program Genel Alanı (Program Global Area – PGA) PGA, tek bir kullanıcı yada sunumcu görevi hakkındaki verileri yada kontrol bilgisini içeren yazılabilir fakat paylaşılmamış bir bellek alanıdır. Kullanıcı görevi Oracle veritabanına bağlandığı ve bir oturum (session) başlatığı zaman bu alan bellekte ayrılır (allocate). PGA yığıt alanı (stack space) oturum değişkenlerini ve dizileri tutmak için ayrılan bellek alanıdır. Kullanıcı oturum verileri (user session data) oturum için fazladan bellek alanıdır.

Görevler (processes) Kullanıcı ve Sunumcu Görevleri (User and Server Processes) UNIX sistemlerinde, kullanıcı bir uygulama programı çalıştırdığında Oracle bir kullanıcı görevi yaratır. Oracle ayrıca bağlanacak kullanıcı görevlerine hizmet verebilmesi için bir sunumcu görev yaratır. Sunumcu görev kullanıcı görevleri ile iletişim kurar.
Sunumcu Görev;
- SQL deyimlerini ayrıştırır ve çalıştırır.
- diskten veri bloklarını okur ve SGA ‘nın paylaşılmış alanına getirir.
- SQL deyiminin sonuçlarını kullanıcı görevine döndürür.
- Görevin Adı Tanımı ,Ayrıştırma (Parse) Sözdizim doğruluğu, erişim gizliliği, nesne çözünürlüğü ve eniyileme kontrolünü yapar. Ayrıştırım ağacını (Parse Tree) oluşturur.
- Çalıştırma (Execute) Ayrıştırım ağacını veriye uygular ve gereken fiziksel okuma ve yazmaları gerçekleştirir.
- Getirme (Fetch) SELECT deyiminin işletimi sırasında veriyi kullanıcıya geçirir.

DBWR Görevi
- DBWR görevi, kullanıcı görevlerinin her zaman boş bellek alanu bulabilmeleri için database buffer cache ‘i yönetir.
DBWR Görevi;
- Değişikliğe uğramış tüm verileri veri dosyalarına yazar.
- Yakın zamanda kullanılan veri bloklarını bellekte tutmak için LRU (Least Recently Used) algoritmasını kullanılır.
- Giriş/çıkış işlemlerini eniyileştirebilmek için bazı yazma işlerini erteler.

Veri, erişilmeden önce sunumcu (server) görev tarafından mutlaka database buffer cache içine getirilmelidir. Sunumcu görev sorguları işlemek için SGA içindeki paylaşılmış belleği kullanır.

Transactionların Günlüğe İşlenmesi (Log Transactions)
Oracle veritabanında yapılan tüm değişiklikleri redo log buffer içine kaydeder. LGWR (Log Writer) arka plan görevi redo log buffer içindeki bilgiyi diske yazar.

LGWR Görevi
LGWR, redo log buffer ‘larını şu durumlar oluştuğunda diske yazar;
- Commit görüldüğünde
- Redo log buffer doluluğu eşik değerine ulaştığı zaman.
- DBWR checkpoint için buffer blokların temizlemeye gerek duyarsa
- Time-out görülürse
Her Oracle instance ‘ı için bir tane LGWR görevi vardır. Bir transaction redo log dosyasına işlenmeden commit edilmiş sayılmaz.
DBWR görevi, veri bloklarını veritabanına geri yazmadan önce yapılan değişiklikleri korumak amacıyla LGWR görevine redo log buffer ‘larını boşaltması sinyalini gönderir.

Arch Görevi (arşivleyici) ARCH (archive – arşiv) görevi aslında seçimlik bir arka plan görevi olmasına rağmen bir çok sistem için özellikle tavsiye edilir. Eğer bu görev çalıştırılıyorsa veritabanı ARCHIVELOG kipinde çalışıyor demektir. Bu seçenek;
- Tablespace ‘lerin çevrim-içi (on-line) yedeklenmesine
- Medya failure ‘dan çevrim-içi kurtarmaya
- Günlük dosyalarının otomatik olarak arşivlenmesine izin verir.
- ARCH görevi, günlük dosyalarının kopyalarını, yerleri daha önce belirlenmiş disk yada teyp birimleri üzerine çıkarır.

PMon (Process Monitor) ve SMon (System Monitor) Görevleri
PMON
- Anormal bir şekilde kesilen bağlantıları temizler.
- Commit edilmemiş değişiklikleri eski haline getirir (rollback).
- İşletimi kesilen görevin tuttuğu kilitleri kaldırır.
- Çakılan görev için ayrılan SGA kaynaklarını serbest bırakır.
- Kilitlenmeleri (deadlock) otomatik olarak yakalar ve işlemi geri döndürerek (transaction rolling back) çözümler.

SMON
- Otomatic instance kurtarmayı gerçekleştirir.
- Geçici segment alanını geri elde eder.
- Kontrol dosyasının sürekliliğini sağlar.
- Sistemde kullanılabilir durumdaki serbest alanın kaydını tutar.

DBA bu görevlerin hızı ya da uyarılma aralığı üzerinde bir kontrole sahip değildir. DBWR ve LGWR gibi bu iki görev de instance çalıştırıldığında hazır olmalıdır.

Diğer Arka Plan Görevleri
- CKPT checkpoint görevi, LGWR üzerindeki yükü azaltmak için kullanılır.
- RECO kurtarıcı (recoverer) görev, çakılmış dağıtık transaction ‘ları çözümler.
- Snnn multi-threaded sunumcuda kullanılan paylaşılmış sunumcu görevleri.
- Dnnn multi-threaded sunumcuda kullanılan dispatcher görevleri.
- SNPn Şip-şak (snapshot) tazeleyici görevler.
- LCKn parallel server seçimliği kullanıldığında instance ‘lar arası kilitlemeyi kontrol eden görev.
- Oracle An ‘ı (Oracle Instance)

Oracle her başlatıldığında;,
- Sistem Genel Alanı (System Global Area – SGA) olarak adlandırılan paylaşılmış bir bellek alanı bellekte ayrılır.
- Oracle arka plan görevleri başlatılır.
- Bellek alanları ve arka plan görevlerinden oluşan bu bileşim Oracle instance olarak adlandırılır.
- Mutlaka olması gereken dört tane arka plan görevi vardır (DBWR, LGWR, PMON and SMON). Bunlardan başka görevler de vardır fakat kullanımları seçimliktir.
- Bir instance sadece bir veritabanını açabilir.
- Bir instance ‘ın başlatılabilmesi için mutlaka bir veritabanı olması gerekmez.
- Eğer Parallel Server seçeneği kullanılırsa, veritabanı birden fazla instance tarafından açılabilir.
- Kullanıcı ve sunumcu görevleri Oracle instance ‘ın bir parçası olarak tanımlanmazlar.

Parametre Dosyası (Parameter File) İnstance karakteristiklerini belirleyen dosyadır. Parametre dosyası;
- Gerektiğinde DBA tarafından serbestçe düzenlenebilen küçük bir metin dosyadır.
- İnstance başlatıldığında salt-okunurdur.
- Sık sık init.ora dosyasına karşılık gelir.
- Parametre dosyası kontrol dosyasının adını ve yerini belirler.
- Eğer parametre dosyasında herhangi bir değer belirtilmemişse öngörülen (default) değerler kullanılır.

Parametre Tanımı
- SHARED_POOL_SIZE Paylaşılmış SQL ve PL/SQL deyimleri için kullanılacak alanın bayt olarak boyu
- DB_BLOCK_SIZE Tek bir veri bloğu ve veritabanı buffer ‘ının bayt olarak boyu.
- DB_BLOCK_BUFFERS Herbiri DB_BLOCK_SIZE boyundaki veritabanı buffer ‘larının sayısı. (database buffer cache için ayrılan toplam alan :
- DB_BLOCK_SIZE * DB_BLOCK_BUFFERS)
- LOG_BUFFERS Redo log buffer ‘ı için ayrılan baytların sayısı
# Example INIT.ORA file
# $Header: init.ora 7020100.1.1120.4 95/07/07 09:54:09 rdhoopar Generic….
#—————————————————————————————–
# ——-Installation/Database Size——
# SMALL MEDIUM LARGE
# Block 2K 4500K 6800K 17000K
# Size 4K 5500K 8800K 21000K
#—————————————————————————————–

db_name = Oracle72
rollback_segments = (rbs01, rbs02, rbs03)
db_block_buffers = 200 # SMALL
# db_block_buffers = 550 # MEDIUM
# db_block_buffers = 3200 # LARGE
shared_pool_size = 3500000 # SMALL
# shared_pool_size = 6000000 # MEDIUM
# shared_pool_size = 9000000 # LARGE
log_checkpoint_interval = 10000

processes = 50 # SMALL
# processes = 100 # MEDIUM
# processes = 200 # LARGE

log_buffer = 8192 # SMALL

# log_buffer = 32768 # MEDIUM

# log_buffer = 163840 # LARGE
control_files = ( /disk6/oracle/dbs/ctrl1oracle72.ctl,
/disk6/oracle/dbs/ctrl2oracle72.ctl,
/disk6/oracle/dbs/ctrl3oracle72.ctl)

background_dump_dest = /disk6/oracle/rdbms/log
core_dump_dest = /disk6/oracle/dbs
user_dump_dest = /disk6/oracle/rdbms/log
#log_archive_dest = /disk6/oracle/dbs/arch/arch.log
#db_block_size =

Database Buffer Cache Diskten okunan veri bloklarının kopyalarını tutar.
Notlar:
İnstance ‘a bağlanan tüm Oracle kullanıcıları Database Buffer Cache içindeki bellek alanını kullanırlar. blok boyu parametre dosyasındaki DB_BLOCK-SIZE parametresi ile belirlenir. Bellekte tutulacak yastık alan (buffer) sayısı ise DB_BLOCK_BUFFERS ‘dır.

Kontrol Noktaları (Checkpoints) Checkpoint sırasında DBWR, database buffer cache içindeki tüm dirty buffer ‘ları diske yazar.
(dirty buffer : Değişikliğe uğramış fakat diske yazılmamış)

Checkpoint şu durumlarda görülür;
- Her günlük anahtarlanmasında (Log Switch)
- Belirlenmiş bir zaman aralığı sonunda
- Belirlenmiş sayıda işletim sistemi bloğu redo log dosyalarına yazılmasından sonra
- DBA tarafından zorlanması durumunda
- Normal yada immediate shutdown sırasında
- Ablespace, çevrim-dışı (off-line) konuma getirildiğinde

Bir veri bloğu database buffer cache içinde çok uzun süre kalabilir ve bu süre zarfında birçok değişikliklere mazur kalabilir. Yani commit edilen bir kayıt hala diske yazılmamış olabilir. Fakat tüm commit edilmiş işlemler güvendedir çünkü LGWR onların kaydını redo log dosyalarında tutar.

Checkpoint sırasında DBWR bir önceki checkpoint ‘ten sonra değişikliğe uğramış verileri diske yazar.

Eğer instance kurtarmaya ihtiyaç duyarsa Oracle sadece son checkpoint ‘ten sonra yazılan redo log kayıtlarını dikkate alacaktır. Çünkü checkpoint, daha önceki değişiklerin veri dosyalarına yazıldığını garanti eder.

Trace ve Alert Dosyaları Oracle instance çalışıyorken bir hata oluştuğu zaman, bu hata ile ilgili mesajlar alert dosyasına yazılır. Eğer hata sunumcu yada arkaplan görevlerince yakalanırsa, hata ile ilgili bilgiler trace dosyasına boşaltılır.

Alert dosyası mesaj ve hataların kronolojik olarak tutluduğu bir dosyadır. Şunları içerir;
- Tüm içsel (internal), block bozulma (corruption) ve kilitlenme (deadlock) hatalarını
- Yönetim türü işlemleri (DML) ve sunumcu yönetici deyimlerini (startup, shutdown…)
- Veritabanı ve instance başlatıldığı andaki parametre değerlerini
- Alert dosyası BACKGROUND_DUMP_DEST parametresi ile belirtilen konumda bulunur.

Bu dosyanın günlük olarak kontrol edilmesi problerin daha da ciddileşmeden çözülebilmesi açısından çok önemlidir.

Trace dosyaları eğer bilgi arka plan görevi tarafından yazılmışsa BACKGROUND_DUMP_DEST, sunumcu görevi tarafından yazılmışsa USER_DUMP_DEST ile belirtilen konumlarda bulunur.

Trace günlükleme SQL_TRACE parametresinin TRUE ya da FALSE olmasına göre yapılır ya da yapılmaz Aşağıdaki deyim trace dosyalarının yazılmasını sağlar.
SQL> alter session set sql_trace true;

SQL*Plus ‘a Giriş
SQL*Plus, SQL komutları ve PL/SQL bloklarını işletmeyi ve bunun yanında veritabanı üzerinde birçok
işlemin yapılmasını sağlayan bir programdır.

SQL*Plus ‘ı kullanarak yapılabilecek işlemler;
SQL komutlarını ve PL/SQL bloklarını girme, düzenleme, saklama, geri getirme ve çalıştırma
Sorgu sonuçlarını bir rapor düzeninde formatlayabilme
Herhangi bir tablo için sutun tanımlarını listeleyebilme
Veritabanındaki verilere ulaşıp bunları kopyalayabilme
Uç kullanıcılara mesajlar gönderip bunlardan gelen cevapları kabul edebilme
Temel Kavramlar Komut (command) SQL*Plus yada Oracle ‘dan yapması istenen
Blok (block) Yordamsal bir mantık içinde birbiriyle ilişkili SQL ya da PL/SQL komutlar grubu
Çizelge (table) Oracle ‘daki temel saklama birimi
Sorgu (query) Bir ya da daha fazla çizelgeden bilgi getiren SQL komut (Select)
Sorgu sonucu Sorgu sonucu getirilen veri (query result)
Rapor (report) SQL*Plus komutları yardımıyla biçimlenmiş sorgu sonuçları

SQL*Plus ‘ın Başlatılması
UNIX sisteme girdikten sonra komut iletisinden aşağıdaki komutu girerseniz, sizden kullanıcı kodunuz
ve parolanız istenecektir.
$ sqlplus
SQL*Plus: Release 3.2.3.0.0 – Production on Wed Aug 13 10:25:37 1997
Copyright © Oracle Corporation 1979, 1994. All rights reserved.
Enter user-name: scott
Enter password:
Connected to:
Oracle7 Server Release 7.2.3.0.0 – Production Release
SQL> _

Artık sisteme girdiniz (logging on). “SQL>” komut iletisi SQL*Plus ‘ın sizin komutlarınızı kabul edip
işletmeye hazır olduğunu gösterir. Şimdi bu komut satırından SQL komutlarını ya da PL/SQL bloklarını
işletebilirsiniz. SQL*Plus ‘ı daha çabuk başlatmak için şu komutu kullanabilirsiniz;
$ sqlplus scott/tiger
Connected to:
Oracle7 Server Release 7.2.3.0.0 – Production Release
SQL> _
SQL*Plus ile işinizi bitirdikten sonra işletim sistemine geri dönmek için exit komutunu kullanabilirsiniz.
SQL> exit
Disconnected from Oracle7 Server Release 7.2.3.0.0 – Production Release
$ _

Komutların Girilmesi ve Çalıştırılması

Komutların girilmesi
Bilgisayarınızın imleci (cursor) komut iletisinden sonra görünür. İmleç, sizin klavyeden gireceğiniz
karakterin ekranda görüneceği konumu gösterir. SQL*Plus ‘dan yapmasını istediğiniz şeye karşı gelen
komutu yazmanız gerekir. Genellikle komutlarla diğer kelimeler arasında boşluk ya da tab karakterleri
olur.Bunların sayısı önemsizdir. Komut iletisinden girebileceğiniz üç tip komut vardır;

SQL komutları
PL/SQL blokları özel amaçlı SQL*Plus komutları (sorgu sonuçlarını formatlama, seçenekleri kurma) yardım sağlama. Herhangi bir SQL*Plus komutu hakkında yardım bilgisi almak için komut iletisinden HELP komutu ve ardından hakkındayardım istenen komutun adını girmeniz gerekir.
SQL> help komut_adı

Not : Eğer 2 “HELP not accessible” mesajını aldıysanız bu konuyu sistem yöneticinize bildiriniz.

SQL komutlarının çalıştırılması
Örnek veri tabanımızda yer alan tabloları kullanarak bir sorgu yazmaya çalışalım. Kazancı 2500$ ‘dan
az olan çalışanları bulmaya çalışalım. Komut iletisinden komutun ilk satırını girdikten sonra return tuşuna
basılırsa, SQL*Plus ikinci satır anlamına gelen 2 uyarısını gösterecektir. ; noktalı virgül komutun bittiğini
gösterir. Bundan sonra SQL*Plus, komutu işletmeye başlayacaktır.
SQL> select empno, ename, job, sal /* seçilecek olan nitelikler */
2 from emp where sal <2500;
Komutlarınıza eklemek istediğiniz açıklamaları (comment) “/* … */” şeklinde yazabilirsiniz.
Sonuçların ve getirilen komutların sayısının gösterilmesinden sonra SQL*Plus tekrar komut iletisini gösterir.

SQL*Plus Komut Sözdizimini (Syntax) Anlama
SQL komutlarınızı istediğiniz sayıda satıra bölebilirsiniz. Fakat en anlamlısı satırlarınızı mantıksal bütünlük içeren gruplar halinde düzenlemenizdir. (Select, Where, Group By satırı gibi…). Aşağıdaki tüm sterimlerdeki sorgular özdeştir.

SQL> select empno, ename, job, sal from emp where sal
select empno, ename, job, sal
2 from emp where sal
select empno, ename, job, sal
2 from emp
3 where sal

SQL komut satırı üç şekilde sonlanabilir;
Noktalı virgül (semicolon “;”) ile. SQL*Plus ‘a sizin komutu çalıştırmak istediğinizi söyler.
Bölme işaret (slash “/”) ile. Son girilen komutu çalıştırmak istediğinizi söyler.
Boş satır (blank line) ile. Komuta bir sonraki satırdan devam etmek istediğinizi söyler.

PL/SQL bloklarının çalıştırılması
SQL*Plus içerisinden PL/SQL bloklarını da çalıştırabilirsiniz. SQL*Plus, PL/SQL yordamlarını sanki SQL deyimlerini işletiyormuş gibi düşünür. PL/SQL bloklarını bitirmek için en son satır olarak nokta “.”kullanılır. Aşağıda örnek bir PL/SQL bloğu biçimsel olarak verilmiştir.
SQL> declare
2 değişken_adı değişken_türü ;
3 begin
4 SQL _komutları ;
5 end;
6 .

İşletim sistemi komutlarının çalıştırılması
Üzerinde çalıştığınız işletim sisteminin komutlarını SQL*Plus komut iletisinden çalıştırabilir ya da geçici bir
süre için işletim sisteminin kabuğuna (shell) çıkabilirsiniz.
SQL> host [komut]
Aşağıda pwd (print working directory) komutunun iki şekilde nasıl çalıştırılabileceği gösterilmiştir.
SQL> host pwd ; komut doğrudan SQL*Plus ‘ın içinden çalıştırılıyor.
/disk6/oracle/ogrenci
SQL> host ; işletim sistemi kabuğuna çıkılıyor.
$ pwd ;komut uygulanıyor.
/disk6/oracle/ogrenci
$ exit ;SQL*Plus ‘a geri dönülüyor.
SQL> _ ;tekrar SQL*Plus ‘tayız.

İşletim sistemi kabuğuna çıkmak, çalıştırılacak komut sayısı birden fazlaysa daha anlamlı olmaktadır. Ayrıca kabuğa çıktıktan sonra geri dönmek için SQL*Plus tekrar çalıştırılmamalı, bunun yerine exit komutu kullanılmalıdır.

Çizelge Tanımlarının Listelenmesi
Verilen bir çizelgedeki niteliklerin tanımlarını SQL*Plus ‘ın describe komutunu kullanarak görebilirsiniz
(Kısaca desc olarak kullanılabilir.).
SQL> desc dept
Name Null? Type
——————————- ——– —-
DEPTNO NOT NULL NUMBER(2)
DNAME VARCHAR2(14)
LOC VARCHAR2(13)

Varolan Çizelgelerin ve Görüntülerin Listelenmesi
Bunun için sistemde hazır olarak bulunan tab adlı çizelge kullanılır.

SQL> select * from tab;
TNAME TABTYPE CLUSTERID
—————————— ——- ———-
CUSTOMER TABLE
DEPT TABLE
EMP TABLE
SALES VIEW
SALGRADE TABLE

5 rows selected.

Hata mesajlarının yorumlanması
SQL*Plus bir hata yakaladığı zaman sizi uygun bir hata mesajı ile uyaracaktır. Mesela olmayan bir çizelgeden sorgulama yapmak isterseniz;
SQL> select * from ta;
select * from ta
*
ERROR at line 1:
ORA-00942: table or view does not exist
mesajını alırsınız. ORA hatanın türü, 00942 ise numarasıdır.
Hata ile ilgili ayrıntılı açıklamaları Messages and Codes elkitabında bulabilebileceginiz gibi oerr
programını da kullanabilirsiniz.

$ oerr hata_türü numarası

Komutlar Üzerinde Yapılabilen İşlemler

SQL Buffer
Son girilen SQL komutunun saklandığı bellek alanıdır. Girilen komut, bir yenisi girilene dek burada saklanır. Yani eğer son komut üzerinde bir başka işlem yapmak istiyorsanız, komutun tamamını yeniden girmeniz gerekmeyebilir.

komut kısaltma amacı
APPEND metin A metin satırın sonuna metini ekler
CHANGE /eski/yeni C /eski/yeni eskiyi yeni ile değiştirir
CHANGE /metin C /metin satırdan metini siler
CLEAR BUFFER CL BUFF tüm satırları siler
DEL yok satırı siler
INPUT I bir ya da daha fazla satır ekler
INPUT metin I metin metini içeren bir satır ekler
LIST L SQL buffer ‘ındaki tüm satırları listeler
LIST n L n ya da n n numaralı satırı listeler
LIST * L * aktif satırı listeler
LIST LAST L LAST son satırı görüntüler
LIST m n L m n m ve n arasındaki satırları listeler

Çalışanlar tablosundan 10 numaralı bölümde çalışan kişilerin adlarını ve maaşlarını sorgulamak isteyelim.
SQL> select deptno,ename, sal
2 from emp
3 where deptno = 10;
DEPTNO ENAME SAL
———- ———- ——-
10 KING 5000
10 CLARK 2450
10 MILLER 1300
En son girdiğimiz SQL deyimi SQL buffer içinde tutulmaktadır. Bu deyimi list komutu ile görebiliriz.

SQL> list
1 select deptno,ename, sal
2 from emp
3* where deptno = 10
Karakteri aktif olan satırı göstermektedir. İstediğimiz bir satırı görmek için list komutundan sonra ilgili satırın numarasını vermemiz yeterli olacaktır. Bu sayede istediğimiz satırı aktif satır haline getirebiliriz.

Şimdi sırasıyla birinci satırdaki bir değişikliği nasıl yaptığımıza bakalım. Sorgumuzu yanlış girdiğimizi
varsayalım.
SQL> select deptno,enm, sal
2 from emp
3 where deptno = 10;

1 select deptno,enm, sal
2 from emp 3* where deptno = 10
select deptno,enm, sal
*
ERROR at line 1:
ORA-00904: invalid column name /* tablomuzda enm diye bir nitelik yok */

Sorgumuzda yer alan enm nitelik değerini ename olarak değiştirelim. Ve sorgumuzu tekrar çalıştıralım.
Bunun için önce ilgili satırı aktif hale getirmek gerekmektedir.

SQL> list1
1* select deptno,enm, sal

SQL> change/enm/ename
1* select deptno,ename, sal

SQL> run
1 select deptno,ename, sal
2 from emp
3* where deptno = 10
DEPTNO ENAME SAL
———- ———- ———-
10 KING 5000
10 CLARK 2450
10 MILLER 1300

Çalışanları, aldıkları maaşa göre sıralı listelemek istersek, yazdığımız sorgunun sonuna order by sal
komutunu eklememiz gerekecektir. Bunu yapmak için sorguyu yeniden yazmaya gerek yoktur.
SQL> input /* aktif satırdan sonra yeni bir satır ekler */
4 order by sal;

DEPTNO ENAME SAL
———- ———- ———-
10 MILLER 1300
10 CLARK 2450
10 KING 5000

SQL> list
1 select deptno,ename, sal
2 from emp
3 where deptno = 10
4* order by sal

Sonuçları azalan sırada (descending) görmek istersek order by kalıbının sonuna desc kelimesini
eklememiz gerekir.
SQL> append desc /* aktif satır numarası zaten 4 idi */
4* order by sal desc
SQL> list4
4* order by sal desc
SQL> run
1 select deptno,ename, sal
2 from emp 3 where deptno = 10
4* order by sal desc

DEPTNO ENAME SAL
———- ———- ———-
10 KING 5000
10 CLARK 2450
10 MILLER 1300

Şimdi sıralama ile ilgili bu dördüncü satırı silelim.
SQL> list 4 /* satırı aktifleştir */
SQL> del /* sil */
SQL> list
1 select deptno, ename, sal
2 from emp
3* where deptno = 10

SQL buffer ‘daki deyimleri belli bir satır aralığıda da listelemek mümkündür.
SQL> list 1 2 /* 1. ve 2. satırları listele */
1 select deptno, ename, sal
2* from emp

Komutların Saklanması
SQL buffer içindeki deyimleri save komutunu kullanarak bir dosyaya yazdırmak mümkündür. Save dosya_adı komutu çalıştırıldığında, SQL buffer ‘ın içeriği uzantısı .SQL olan dosya_adı isimli dosyaya
kaydedilir.
SQL> save deptinfo
Created file deptinfo

SQL> host ls -l dep*.*
rw-r—r– 1 oracle dba 55 Agu 14 10:00 deptinfo.sql

SQL buffer ‘ın içeriğinin temizlenmesi
SQL> clear buffer
buffer cleared
SQL> list
No lines in SQL buffer.

—

Komut dosyalarına açıklama satırlarının eklenmesi
Yazdığınız komut dosyalarına ekleyeceğiniz açıklama satırları, bu dosyaların daha sonra da kolayca
anlaşılmasını sağlayacaktır. Bu işlem üç şekilde gerçekleştirilebilir.
SQL*Plus ‘ın REMARK komutu ile
SQL komut ayıraçları ile, /* … */
ANSI/ISO karakterleri ile, –
REMARK SQL*Plus ‘ı öğrenmek için verilen örnekler tekrarlanmalıdır.
/* SQL*Plus ‘ı öğrenmek için verilen örnekler tekrarlanmalıdır. */
– SQL*Plus ‘ı öğrenmek için verilen örnekler tekrarlanmalıdır.

Dosyalardaki komutların yeniden kullanılması
Daha önce save komutu ile sakladığımız ya da herhangi bir editor yardımıyla oluşturduğumuz SQL
deyimlerin get dosya_adı komutunu kullanarak SQL buffer ‘a getirebiliriz.
SQL> get deptinfo
1 select deptno, ename, sal
2 from emp
3* where deptno = 10

SQL deyimlerini toplu işlem (batch) olarak çalıştırmak istersek start dosya_adı komutundan
yararlanabiliriz.
SQL> start deptinfo

DEPTNO ENAME SAL
———- ———- ——–
10 KING 5000
10 CLARK 2450
10 MILLER 1300

ya da @dosya_adı komutu kullanılabilir.
SQL> @deptinfo

DEPTNO ENAME SAL
———- ———- ———-
10 KING 5000
10 CLARK 2450
10 MILLER 1300
Dept tablosunun niteliklerinin neler olduğuna bakalım.
SQL> desc dept
Name Null? Type
——————————- ——– —–
DEPTNO NOT NULL NUMBER(2)
DNAME VARCHAR2(14)
LOC VARCHAR2(13)

Bölüm numaralarını ve adlarını sorgulayalım.
SQL> select deptno, dname
2* from dept

DEPTNO DNAME
———- ————–
10 ACCOUNTING
20 RESEARCH
30 SALES
40 OPERATIONS
SQL buffer içeriğini daha önce var olan bir dosyanın sonuna eklemek için append, üzerine yazmak içinse
replace anahtar kelimesi kullanılır.
SQL> save deptinfo append
Appended file to deptinfo

SQL> host cat deptinfo.sql
select deptno, ename, sal
from emp
where deptno = 10
/
select deptno, dname
from dept
/
Etkileşimli komutların yazılması
SQL*Plus, kullanıcılara değişken tanımlama imkanı verir.

SQL> DEFINE EMPLOYEE = SMITH
SQL> DEFINE EMPLOYEE
DEFINE EMPLOYEE = “SMITH” (CHAR)

SQL> cl buff
buffer cleared
SQL> input
1 select &col1, &col2
2 from &tab
3 ;
Enter value for col1: deptno
Enter value for col2: dname
old 1: select &col1, &col2
new 1: select deptno, dname
Enter value for tab: dept
old 2: from &tab
new 2: from dept

DEPTNO DNAME
———- ————–
10 ACCOUNTING
20 RESEARCH
30 SALES
40 OPERATIONS

SQL> save sel2col
Created file sel2col /* geçerli dizinde sel2col.sql dosyası oluşturuldu */

Bu dosya artık start komutu ya da “@” (at) işareti ile çalıştırılabilir.
SQL> @sel2col
Enter value for col1: deptno
Enter value for col2: dname
old 1: select &col1, &col2
new 1: select deptno, dname
Enter value for tab: dept
old 2: from &tab
new 2: from dept

DEPTNO DNAME
———- ————–
10 ACCOUNTING
20 RESEARCH
30 SALES
40 OPERATIONS
SQL> input
1 prompt Aradiginiz calisanin numarasini giriniz
2 accept enumber number prompt ‘Emp. No. : ‘
3 select ename, job, sal
4 from emp
5 where empno = &enumber
6

SQL buffer ‘daki deyimi zaten var olan bir dosya adıyla kaydetmek isteyelim.
SQL> save sel2col
File “sel2col.sql” already exists.
Use another name or “SAVE filename REPLACE”.

Eğer olan bir dosyanın adını kullanmak istiyorsak komutu şu şekilde kullanmalıyız:
SQL> save dosya_adı replace /* replace = yerini al */
SQL> save prompt1 /* SQL buffer içeriğini prompt1.sql dosyasına yazalım */
Created file prompt1
SQL> @prompt1 /* ya da start prompt1 */
Aradiginiz calisanin numarasini giriniz
Emp. No. : 7521
old 3: where empno = &enumber
new 3: where empno = 7521

ENAME JOB SAL
———- ——— ———-
WARD SALESMAN 1250

Komut dosyalarında parametre kullanımı
Bu işlem, komutların etkileşimli çalıştırılmasına benzer olarak şu şekilde gerçekleştirilebilir. SelJob.sql
dosyasının içeriği aşağıdaki şekilde olsun;
select empno, ename, sal
from emp
where job = ‘&1′

Komut çalıştırılırken dosya adından sonra girilen parametreler &1, &2 … şeklinde sıralandırılır.
SQL> start SelJob CLERK
old 3: where job = ‘&1′
new 3: where job = ‘CLERK’

EMPNO ENAME SAL
———- ———- ———-
7369 SMITH 800
7876 ADAMS 1100
7900 JAMES 950
7934 MILLER 1300

Yararlı Bazı Komutlar
Spool [dosyaAdı | off] komutunu kullanarak işlettiğiniz komutların ve sonuçlarının uzantısı .LST olan bir
metin dosyasına yazılmasını sağlayabilirsiniz.
SQL> spool oturum.lst
SQL> …
SQL> spool off

Set pause [on | off] “metin” komutunu kullanarak uzun çıktılar üreten sorgularınızın ekranda sayfa sayfa
görüntülenmesini sağlayabilirsiniz.
SQL> set pause on
SQL> set pause “Devam için NL tuşuna basınız…”

Pause [mesaj] komutu kullanıcının enter tuşuna basacağı ana kadar işlemi dondurur.
SQL> pause Devam etmek icin ENTER tusuna basiniz…

Devam etmek icin ENTER tusuna basiniz…
Clear screen komutunu kullanarak çalışma ekranınızı temizleyebilirsiniz.
SQL> clear screen

SQL*Plus ‘ın değişken tanımlayabilme özelliğinden yararlanarak kendiniz için bir metin düzenleyici
öngörebilirsiniz.
SQL> DEFINE_EDITOR = pico
SQL> edit deptinfo

Edit komutunu kullandığınızda pico programı çalıştırılacak ve size bir belge yaratma imkanı verilecektir.
Belgeniz üzerindeki işleminiz bitip pico programından çıktığınızda tekrar SQL*Plus ‘a dönersiniz.

Veritabanı ve İnstance ‘ın Çalıştırılıp Kapatılması (startup and shutdown)

Veritabanı sistem yöneticisi, veritabanının açılıp kapatılmasından sorumuludur. Oracle veritabanının
herzaman kullanıcıların erişimine açuk olmasI gerekmez. VeritabanI yöneticisi onu istediği zaman açabilir.
eritabanı açıkken, kullanıcılar veritabanının içerdiği bilgilere erişebilirler. Kapalıyken bu işlem yapılamaz.
Veritabanı ve instance ‘ın yönetimi için screen ve line kiplerinde çalıştırılabilen iki tane program vardır.

Bunlar;
SQL*DBA (Örneklerimizde kullanacağımız araç)
Server Manager (Sadece grafik kullanıcı arabirimi ortamında – Graphic User Interface GUI)

Startup Adımları
SQL*DBA ‘nın çalıştırılması
Internal olarak bağlanma
Start up
Instance ‘ın başlatılması
Veritabanının mount edilmesi
Veritabanının açılması (open)

ShutDown Adımları
SQL*DBA ‘nın çalıştırılması
internal olarak bağlanma
instance ‘ın kapatılması

SQL*DBA ‘nın çalıştırılması
$ sqldba mode = line
$ sqldba lmode = y — line mode, yes
$ sqldba mode = screen
$ sqldba lmode = n — line mode, no

Ya da ORA_SQLDBA_MODE çevre değişkeni line ya da screen olarak kurularak kullanılabilir.
Aşağıda SQL*DBA line modunda çalıştırılmıştır.

$ sqldba lmode = y

SQL*DBA: Release 7.2.3.0.0 – Production on Fri Aug 15 11:45:50 1997
Copyright (c) Oracle Corporation 1979, 1994. All rights reserved.
Oracle7 Server Release 7.2.3.0.0 – Production Release

Veritabanına Internal Olarak Bağlanmak
Veritabanının açılıp kapanma işlemleri önemli işlemlerdir ve Oracle ‘a internal olarak
bağlanmayı gerektirir. Eğer internal olarak bağlandıysanız, artık sistemde en yetkili
kullanıcı olan SYS olarak tanınırsınız.
SQLDBA> connect internal
Connected.

Instance ‘ın başlatılması
Veritabanı başlatılmadan önce veritabanının hangi durumda başlatılacağının seçilmesi gerekir.
Veritabanı üç şekilde başlatılabilir.

Başlangıç Durumu Kullanımı
NOMOUNT veritabanını yaratmak için kullanılır
MOUNT veritabanında bakım ya da kurtarma gerektiğinde kullanılır.
OPEN veritabanını tüm kullanıcılara açmak için kullanılır.

Start Up Işlemi;
instance ‘ın başlatılması
veritabanının mount edilmesi
veritabanının açılması (open)

NOMOUNT, MOUNT ve OPEN seçenekleri birarada kullanılamaz (mutually exclusive). Yani STARTUP MOUNT OPEN şeklinde bir komut olamaz. SHUTDOWN durumundan açık konuma
geçmek için sadece STARTUP komutu kullanılmalıdır.

SQLDBA> startup
ORACLE instance started.
Database mounted.
Database opened.
Total System Global Area 4451660 bytes

Fixed Size 55648 bytes
Variable Size 3978220 bytes
Database Buffers 409600 bytes
Redo Buffers 8192 bytes

SQLDBA> _
Eğer veritabanı adım adım açılmak istenirse;

SQLDBA> startup nomount
ORACLE instance started.
SQLDBA> alter database mount;
Statement processed.
SQLDBA> alter database open;
Statement processed.
SQLDBA> _
ya da;

SQLDBA> startup mount
ORACLE instance started.
Database mounted.
SQLDBA> alter database open;
Statement processed.
STARTUP [RESTRICT] [FORCE] [PFILE=fname]
[NOMOUNT
| MOUNT [EXCLUSIVE | {PARALLEL | SHARED} [RETRY]]
| OPEN [RECOVER] [dbname]
[EXCLUSIVE | {PARALLEL | SHARED} [RETRY]]]

dbname : veritabanının adıdır.
EXCLUSIVE : sadece geçerli instance ‘ın veritabanına erişmesine izin verir.
SHARED ya da PARALLEL : birden fazla instance ‘ın veritabanına erişmesine izin verir.
RETRY : paralel instance, 5 saniyelik aralıklarda tekrar başlatulmaya çalışılır.
PFILE=fname : instance ‘ın karakteristiklerini belirleyen bir parametre dosyası belirlenir.
FORCE : normal bir startup uygulanmadan once çalışan instance durdurulur.
RESTRICT : kullanıcılara sınırlı bir erişim sağlar.
RECOVER : veritabanı başlatıldığında medya kurtarma ‘yı uygular.

Veritabanının kapatılması
SHUTDOWN [NORMAL | IMMEDIATE | ABORT ]
NORMAL : diğer kullanıcıların oturumlarını terketmelerini bekler.
IMMEDIATE : o an işletilmekte olan SQL deyimlerini keserek commit edilmemiş değişiklikleri geri alır.
ABORT : en hızlı kapatma biçimidir. Ne diğer kullanıcıların sistemden çıkmalarını bekler ne de commit edilmemiş değişiklikleri geri alır.

SQL*DBA komut satırında shutdown komutunu girerseniz sırasıyla ; veritabanı kapatılacak, dismount edilecek ve son olarak da instance sonlandırılacaktır.
SQLDBA> shutdown
Database closed.
Database dismounted.
ORACLE instance shut down.

Veritabanı Yaratma

Veritabanı yaratmak için geçilmesi gereken adımlar:
Sistemde biricik olan bir instance adına karar verme
İlgili sistem değişkenlerini kurma
Parametre dosyasının kopyalanıp değiştirilmesi
SQL*DBA ‘nın başlatılıp internal olarak bağlanma
Instance ‘ın başlatılması
Veritabanının yaratılması.

Sistemde biricik olan bir instance adına karar verme
Instance ve Veritabanı Oracle ‘ın parallel server opsiyonu kullanılmadığı sürece normal olarak aynı adı
taşımalıdır. Birçok makinede bu isim en fazla 6 karakter olur. Aynı ismin başka bir instance tarafından
kullanılıp kullanılmadığından emin olmak için; Çalışan görevlerin listesine

$ORACLE_HOME/dbs dizinindeki tüm parametre dosyalarına bakılabilir.

İlgili sistem değişkenlerini kurma
UNIX makinelerde kullanılan değişken $ORACLE_SID ‘dir (ORACLE Sistem IDentifier). İlgili profile
dosyasına şu satırların yazılması yeterlidir. (sid, başlatılmak istenen instance ‘ın adıdır. )
ORACLE_SID=sid
export ORACLE_SID

Parametre dosyasının kopyalanıp değiştirilmesi
Parametre dosyası init.ora ‘dır. instance başlatıldığında initSID.ora dosyasını arar. Bulamazsa,
öngörülen dosya adı olarak init.ora ‘yı kullanır. Init.ora dosyasında mutlaka belirtilmesi gereken dört adet
arametre vardır:

Parametre Tanımı
DB_NAME Veritabanı belirteci, genellikle instance ile aynı ada sahiptir.
CONTROL_FILES Kontrol dosya(sı/ları)nın ad(lar)ı
USER_DUMP_DEST Kullanıcı trace dosyalarının konumu
BACKGROUND_DUMP_DEST Oracle trace dosyalarının konumu

CONTROL_FILES farklı disklerde bulunan iki ya da daha fazla dosyayı işaret etmelidir. Bu dosyalar,
veritabanı ile aynı zamanda yaratılırlar ve bu sırada bulundukları konum tam olarak verilmelidir.

Control_files = (/disk1/ctrl/control1.con,
/disk2/ctrl/control2.con)

SQL*DBA ‘nın başlatılıp internal olarak bağlanma ;

$ sqldba lmode = y

SQL*DBA: Release 7.2.3.0.0 – Production on Fri Aug 15 11:45:50 1997
Copyright (c) Oracle Corporation 1979, 1994. All rights reserved.
Oracle7 Server Release 7.2.3.0.0 – Production Release

Veritabanının açılıp kapanma işlemleri önemli işlemlerdir ve Oracle ‘a internal olarak bağlanmayı
gerektirir. Eğer internal olarak bağlandıysanız, artık sistemde en yetkili kullanıcı olan SYS olarak tanınırsınız.

SQLDBA> connect internal
Connected.

Instance ‘ın başlatılması
Veritabanı yaratılmadan önce instance NOMOUNT kipinde başlatılmalıdır.

SQLDBA> startup nomount
ORACLE instance started.

Veritabanının yaratılması.
Oracle veritabanı, tablo ve indeksleri barındıran veri dosyalarından, redo log dosyalarından ve
veritabanının başlatılıp sürekliliğinin sağlanabilmesi için gerekli olan kontrol dosyalarından oluşur.

CREATE DATABASE [ database ]
[ CONTROLFILE REUSE ]
[ LOGFILE ][GROUP integer ] filespec [ , filespec … ]]… ]
[ MAXLOGFILES integer]
[ MAXLOGMEMBERS integer ]
[ MAXLOGHISTORY integer ]
[ DATAFILE filespec [ , filespec … ?]
[ MAXDATAFILES integer ]
[ MAXINSTANCES integer ]
[ ARCHIVELOG | NOARCHIVELOG ]
[ EXCLUSIVE ]
[ CHARACTER SET charset]

DATABASE Yaratılacak veritabanının adı.
FILESPEC Dosyadı [SIZE n][K|M][REUSE]
CONTROLFILE REUSE Var olan kontrol dosyası tekrar kullanılacak mı?
LOGFILE GROUP Kullanılacak log dosyalarının adı ve hangi gruplara ait olduğu.
MAXLOGFILES Veritabanı için yaratılabilecek log dosyası sayısı için üst limit.
MAXLOGMEMBERS Bir log grubunda bulunabilecek üye sayısı için üst limit.
MAXLOGHISTORY (parallel server için)
DATAFILE Filespec kulanılacak veri dosyaları.
MAXDATAFILES Veritabanı için yaratılabilecek veri dosyası sayısı için üst limit.
MAXINSTANCES Simultane olarak veritabanına bağlanabilecek instance sayı için üst limit.
ARCHIVELOG Redo log girişlerinin kullanılmadan önce arşivlenmesini sağlar.
NOARCHIVELOG Redo log girişleri arşivleme yapılmadan kullanılır.
EXCLUSIVE Yaratıldıktan sonra birden fazla instance ‘ın veritabanına ulaşmasını önlemek için veritabanını exclusive kipinde mount eder..
CHARACTER SET Veritabanının verileri saklarken kullanacağı karakter tablosudur.

SQLDBA> create database “ogr”
2> maxinstances 8
3> maxlogfiles 32
4> character set “WE8ISO8859P9″
5> datafile
6> ‘/disk6/oracle/ogr/ogr1/systogr.dbf’ size 5M
7> logfile
8> ‘/disk6/oracle/ogr/ogr1/log1ogr.dbf’ size 500k,
9> ‘/disk6/oracle/ogr/ogr1/log2ogr.dbf’ size 500k;
Statement processed

Yukarıdaki örnekteki veritabanı etkileşimli olarak yaratılmıştır. Fakat bu işlemin, gereken deyimlerin bir
metin dosyasına yazılarak bu dosyanın start komutuyla çalıştırılmasıyla yapılması tercih edilir. Veritabanı
yaratma işleminin bir parçası olarak Oracle, temel veri sözlüğü tablolarını yaratan sql.bsq dosyasını
otomatik olarak çalıştırır. Bundan başka veri tabanını yaratan kişinin çalıştırması gereken iki dosya daha
vardır:

CATALOG.SQL temel tablolar üzerindeki görüntüleri yaratır.
CATPROC.SQL PL/SQL ‘nin kullanımına izin verir.
Bu dosyalar $ORACLE_HOME/rdbms/admin dizininde bulunur.

Yeni oluşturulan veritabanı ;

SYSTEM tablespace
Veri sözlüğü tablolarının sahibi olan SYS (/CHANGE_ON_INSTALL) kullanıcısı Oracle araçlarınca
kullanılacak tabloların sahibi olan SYSTEM (/MANAGER) kullanıcısı SYS tarafından sahiplenen ve
SYSTEM tablespace içinde saklanan temel veri sözlüğü tabloları catalog.sql tarafından yaratılan ve SYS
tarafından sahiplenen veri sözlüğü görüntüleri,

ALERT Dosyası
Oracle veritabanını yarattığında, ona karşılık gelen alert dosyasını da yaratır. Bu dosyanın konumunu
parametre dosyasında verilen BACKGROUND_DUMP_DEST değişkeninden alır. Alert dosyası mesaj ve
hataların kronolojik olarak tutluduğu bir dosyadır. Şunları içerir; tüm içsel (internal), block bozulma
corruption) ve kilitlenme (deadlock) hatalarını yönetim türü işlemleri (DDL) ve sunumcu yönetici deyimlerini (startup, shutdown…) veritabanı ve instance başlatıldığı andaki parametre değerlerini ,

Veri Sözlüğü(Data Dictionary)
Oracle ‘ın en önemli kısımlarından biridir. Veri sözlüğü, sys tarafından sahiplenen tablolar ve görüntülerden oluşur. Veritabanına salt-okunur bilgi sağlamak amacıyla kullanılır. Mesela;

Oracle kullanıcılarının kullanıcı kodları
Kullanıcılar atanan roller ve verilen haklar
Şema nesnelerinin adları ve tanımları
Bütünlük sınırlamaları
Veritabanı nesneleri için alan ayırma
Genel veritabanı yapısı
Aauditing bilgisi
Yordamların, trigger’ların işlevlerin ve paketlerin saklanması.
Veri Sözlüğü Kullanıcıları
Veritabanı yöneticileri
Veritabanı kullanıcıları
Uygulamalar
Oracle

Oracle her DDL (Veri Tanımlama Dili – Data Definition Language) deyimi çalıştırılmak istendiğinde veri
sözlüğüne erişir. Herhangi bir Oracle kullanıcısı veri sözlüğünü salt-okunur bir referans olarak kullanabilir.
Veri sözlüğü çok sık erişildiği için SGA içinde cache ‘lenmelidir. Bu işlem için bazen row cache olarak
adlandırılan paylaşılmış havuz kullanılır. Hiçbir kullanıcı veri sözlüğündeki veriyi değiştiremez ya da silemez. Veri sözlüğü görüntüleri şu kategorilere ayrılır;

Kategori Tanım

DBA_xxx Sistem yöneticine açık nesneler. Veritabanındaki herhangi bir nesnenin tanım bilgisini verir.
USER_xxx Herhangi bir kullanıcıya açık nesneler. Kullanıcıya, kendisine ait bir nesnenin tanım bilgisini verir.
ALL_xxx Tüm kullanıcılara açık nesneler. Kulanıcıya açık olan tüm nesnelerin tanım bilgisini verir.
Non-standard Özel işlevsellikle ilgili görüntülerdir.

Kullanıcı Oluşturma ve Yönetme
Her Oracle veritabanı kullanıcı kodları (username) ile tanımlanan kullanıcılara sahiptir. Kullanıcı kodu,veri
tabanına erişim için gereklidir. Her veri tabanı uygulaması (SQL*Plus, SQL*Forms) tarafından sağlanır. Veri tabanının içinde tanımlanır.

Not : Kullanıcı kodu ve parola (password) verme gerekliliğini ortadan kaldırmak için üzerinde çalışılan
işletim sisteminin authentication denetiminden yararlanılabilir. Yaratılan her kullanıcı için öngörülen
tablespace başkası belirtilmedikçe SYSTEM ‘dir. Geçici (temporary) bir tablespace SQL deyimleri için
gerekli olabilir. Eğer belirtilmemişse, geçici tablespace olarak da SYSTEM kullanılır.

Veri tabanına erişim denetimi;
Oracle her kullanıcı kodu için bir parola yaratır. Kullanıcı bunu daha sonra değiştirebilir. Oracle kullanıcı
kodlarını ve kodlanmış parolaları saklar. Kullanıcı veri tabanına bağlanmak istediğinde kullanıcı kodu ve
parolası doğrulanır. Kullanıcıya yetkiyi işletim sistemi verir.

Kulanıcının Yaratılması

CREATE USER user
IDENTIFIED { BY password | EXTERNALLY }
[ DEFAULT TABLESPACE tablespace ]
[ TEMPORARY TABLESPACE tablespace ]
[ QUOTA { integer [ K | M ] | UNLIMITED } ON tablespace ] …
[ PROFILE profile ]

USER kullanıcı kodu.
BY password logon olmak için gerekli parola.
EXTERNALLY kullanıcının erişimi işletim sistemi üzerinden onaylanacak.
DEFAULT kullanıcının nesneleri için öngörülen tablespace.
TABLESPACE
TEMPORARY geçici segmentler için öngörülen geçici tablespace.
TABLESPACE

Sadece SYS kullanıcısı öngörülen tablespace olarak SYSTEM ‘e sahip olmalıdır. SYSTEM tablespace ‘i herhangi bir kullanıcıya geçici tablespace olarak atanmamalıdır. Sistemde tanımlı olan kullanıcılar all_users adlı bir tabloda tutulurlar. Veri tabanı ilk kez yaratıldığında sistem sadece iki kullanıcı bulunur.

SQLDBA> select * from all_users;
USERNAME USER_ID CREATED
——————– ———- ————–
SYS 0 05-SEP-97
SYSTEM 5 05-SEP-97
2 rows selected.

Kullanıcı yaratmak için create user komutunu kullanabiliriz. kurs1 kullanıcı kodlu bir kullanıcı
tanımlayalım.

SQLDBA> create user kurs1
2> identified by kurs1
3> default tablespace users
4> temporary tablespace temp;
Statement processed.

SQLDBA> select * from all_users;
USERNAME USER_ID CREATED
—————————— ———- ————–
SYS 0 05-SEP-97
SYSTEM 5 05-SEP-97
KURS1 8 05-SEP-97
3 rows selected.

Kullanıcı şu an sadece yaratıldı. Bu kullanıcının veri tabanına erişebilmesini sağlamak için birtakım hakların verilmesi gerekmektedir. Bu işlem grant komutuyla yapılabilir.

SQLDBA> grant connect, resource to kurs1;
Statement processed.

GRANT { system_priv | role } [, { system_priv | role } ] …
TO { user | role | PUBLIC } [, { user | role | PUBLIC } ] …
[ WITH ADMIN OPTION ]

system_priv verilecek olan sistem önceliği.
role verilecek olan rol.
WITH ADMIN OPTION hak verilen kullanıcı bu hakkı başka kullanıcılara da iletebilir.

Oracle ‘ın tanımladığı bazı roller;
Rol Sistem Öncelikleri ve Verilen Roller
CONNECT ALTER SESSION
CREATE CLUSTER
CREATE DATABASE LINK
CREATE SEQUENCE
CREATE SESION
CREATE SYNONYM
CREATE TABLE
CREATE VIEW
RESOURCE CREATE CLUSTER
CREATE PROCEDURE
CREATE SEQUENCE
CREATE TABLE
CREATE TRIGGER

DBA Tüm sistem öncelikleri
WITH ADMIN OPTION
EXP_FULL_DATABASE role
IMP_FULL_DATABASE role

Yetkilendirilmenin işletim sistemi tarafından yapılması
Eğer gerek duyulursa, kullanıcıların Oracle ‘a log in olmaları işletim sisteminin denetiminde yapılabilir.
Bunun için externally anahtar kelimesi kullanılır.

OS_AUTHENT_PREFIX OS Kullanıcısı Oracle Kullanıcısı
OPS$(ÖNGÖRÜLEN) SCOTT OPS$SCOTT
Herhangi bir dizgi “ABC” SCOTT ABCSCOTT
Yok “” SCOTT SCOTT

Şimdi UNIX sistemde bir account ‘a sahip olan mab01 kullanıcısını için bir Oracle kullanıcısı olarak tanımlayalım.
SQLDBA> create user ops$mab01
2> identified externally
3> default tablespace users
4> temporary tablespace temp;
Statement processed.

SQLDBA> select * from all_users;
USERNAME USER_ID CREATED
—————————— ———- ————–
SYS 0 05-SEP-97
SYSTEM 5 05-SEP-97
KURS1 8 05-SEP-97
OPS$MAB01 9 05-SEP-97
4 rows selected.

SQLDBA> grant connect, resource to ops$mab01;
Statement processed.

Kullanıcının bilgilerinin değiştirilmesi
ALTER USER user
[ IDENTIFIED { BY password | EXTERNALLY } ]
[ DEFAULT TABLESPACE tablespace ]
[ TEMPORARY TABLESPACE tablespace ]
[ QUOTA {integer [ K | M ? | UNLIMITED } ON tablespace ]…
[ PROFILE profile ]
[ DEFAULT ROLE { role [, role ] …
| ALL [ EXCEPT role [, role ] … ]
| NONE } ]

Varolan bir kullanıcının gizlilikle ilgili konfigurasyonu ALTER USER komutuyla değiştirilebilir. Bu komutla değiştirilebilecek opsiyonlar şunlardır:

Parola işletim sistemi yetkilendirmesi öngörülen nesne tablespace ‘i geçici tablespace tablespace kotaları
profile rol
urs1 kodlu kullanıcımızın parolasını yenikurs1 olarak şu şekilde değiştirebiliriz;

SQLDBA > alter user kurs1
2> identified by yenikurs1;
Statement processed.

Notlar: Sadece ALTER USER komutuyla verilen opsiyonlar değişecek diğerleri olduğu gibi kalacaktır. Kullanıcı üzerindeki kota şu şekilde kaldırılabilir;

ALTER USER username
QUOTA 0 ON tablespace;
Öngörülen rollerin atanmasi sadece ALTER USER komutuyla yapılabilir.

Kullanıcıların yokedilmesi

DROP USER user [CASCADE]
user yok edilecek kullanıcı kodu.
CASCADE kullanıcı yok edilmeden önce onun şemasında bulunan tüm nesneleri yok eder.

SQLDBA > drop user kurs1 cascade;
Statement processed.

Not : Veritabanına bağlı durumdaki kullanıcı yok edilemez.

Kullanıcıların izlenmesi
Veri sözlüğünde saklanan kullanıcı bilgileri SELECT cümleleri ile görülebilir. Veri sözlüğü ;

Veritabanındaki Tüm Kullanıcılar
Kullanıcı nesnelerinin öngörülen tablespace ‘leri
Geçici segmentlerce kullanılan tablespace ‘ler ve
Kotalar hakkındaki bilgileri içerir.

Yararlı verisözlüğü görüntüleri
USER_USERS geçerli kullanıcı hakkındaki bilgileri içerir.
ALL_USERS
DBA_USERS tüm kullanıcılar hakkındaki bilgileri içerir.
USER_TS_QUOTAS
DBA_TS_QUOTAS tüm kullanıcıların tablespace kotaları hakkındaki bilgileri içerir.

Kullanıcı oturumunun kapatılması
ALTER SYSTEM KILL SESSION ‘ integer1, integer2 ‘
KILL SESSION oturumu sonladır.
Integer1 kullanıcı SID numarası.
Integer2 kullanıcı seri numarası.

Integer1 ve integer2 sayıları V$SESSION görüntüsü sorgulanarak elde edilebilir. Şimdi bundan
yararlanarak SCOTT kodlu kullanıcının oturumunu kapatalım.

SQLDBA> select sid, serial#, username
2> from v$session;

SID SERIAL# USERNAME
—– ———— —————–
…
13 9 SCOTT
…
SQLDBA> alter system kill session ‘13, 9′;
Statement processed.

Bu komutun çalıştırılmasından sonra; Kullanıcının işlemleri geri döndürülecektir. Kullanıcıya ait tüm kilitler kaldırılacaktır. Kullanıcı tarafından ayrılan tüm kaynaklar Serbest bırakılacaktır
Uygulama 6 (Export Utility)

Enter array fetch buffer size: 4096 > /* tablolar diskten okunurken kullanılacak olan bellek alanının boyu */

Export file: expdat.dmp > /* export dosyasının adı */

(1)E(ntire database), (2)U(sers), or (3)T(ables): (2)U >
/* export işleminin modu */
/* genellikle sıradan kullanıcılar için tablo ya da user, DBA için database ‘dir */

Export grants (Y/N) : N >
/* yes (full database mode) : tablo üzerindeki tüm haklar export edilir */
/* yes (user mode) : sadece tablonun sahibinin hakları export edilir */

Export table data (yes/no): yes >
/* yes : tablo içindeki veriler export edilsin. */
/* no : sadece tablo tanımları export edilsin */

Compress extents (yes/no): yes >
/* yes : export edilen tablo içindeki veriler tablo import edilirken bir initial extent içine sıkıstırılır */
/* no : tablolar export edildikleri anki parametreleriyle import edilirler */

User to be exported : (RETURN to quit) >
/* nesneleri export edilecek bir sonraki kullanıcı */

Table to be exported : (RETURN to quit) >
/* export edilecek tablonun adı */

Uygulama 6 (Sonuçlar)

$ exp

Export: Release 7.2.3.0.0 – Production on Fri Sep 12 14:07:19 1997

Copyright (c) Oracle Corporation 1979, 1994. All rights reserved.

Username: ogrenci
Password:

Connected to: Oracle7 Server Release 7.2.3.0.0 – Production Release
With the distributed and replication options
PL/SQL Release 2.2.3.0.0 – Production
Enter array fetch buffer size: 4096 >

Export file: expdat.dmp > ogrenci.dmp

(1)E(ntire database), (2)U(sers), or (3)T(ables): (2)U > t

Export table data (yes/no): yes >

Compress extents (yes/no): yes >

About to export specified tables …
Table to be exported: (RETURN to quit) > BOLUM

. . exporting table BOLUM 184 rows exported
Table to be exported: (RETURN to quit) > DERS

. . exporting table DERS 2439 rows exported
Table to be exported: (RETURN to quit) > FAKULTE

. . exporting table FAKULTE 33 rows exported
Table to be exported: (RETURN to quit) > OGRENCI

. . exporting table OGRENCI 3165 rows exported
Table to be exported: (RETURN to quit) > OGRETIM_UYESI

. . exporting table OGRETIM_UYESI 3184 rows exported
Table to be exported: (RETURN to quit) > OGR_DERS

. . exporting table OGR_DERS 17442 rows exported
Table to be exported: (RETURN to quit) > SUBE

. . exporting table SUBE 4733 rows exported
Table to be exported: (RETURN to quit) >

Export terminated successfully without warnings.

ALINTIDIR.