Bu kısa yazı üç tane bölüm içeriyor. Birinci bölümde veritabani servis sağlayıcısı olan postgreSQL programının diğer SQL uygulamaları ile olan benzer yanlarını anlatacağız.. İkinci bölümde ise SQL komutlarını öğreneceğiz. Son bölümde SQL komutları ile ilgili bazı gelişmiş seçenekleri,projemiz için gerekli olabilecek PostgreSQL fonksiyonlarını öğreneceğiz. Son olarakta bunları kullanarak küçük bir C programyazacağız.
Introduction
Giriş bölümünde sadece veritabanı ile ilgileneceğiz. (DB). Başka bilgiye ulaşma yollarıda var ama , bunlardan bahsetmek konumuzun dışında kalıyor.
Bilgiye ulaşma yolları aralarıda mantıksal ilişki bulunan veritabanı linklerine ulaşmayı başarıyor.. Bu tür bir ulaşımın hızlı olmak gibi bir faydası var , fakat sadece daha önceden belirtilen bir bilgiye ulaşılabilme gibi büyük bir zararı var. Örneğin;
Country - states - counties
Fakat aşağıdaki yazım yanlıştır:
country - counties
Eğer ikinci bir ilişki kurabilseydik şemayı tekrar belirtmek ve , onu tekrar derlemek zorunda kalırdık.
Hierarşik bir veri tabanında, mühtelif olgular arsındaki ilişki is sabit olmalı ve sadece veri tabanı şemalarının değişiminden ve of sonuncu kez tekrar derlenmesinden sonra değiştirilebilmeli.
Temel fikir veri tabanı ilişkilerinin kesin olarak linklerde olmasıdır. Örnek sırasındaki bilgi, değişmez bir linke ihtiyaç duyar, fakat onun yerine linke izin veren bir kayıt bir belirleyici kullanmak.
Veri tabanı programları statik linklerin hierarşik olguların batmasını tavsiye etmez onun yerine olguları belirleyen daha iyi kodlar kullanır.
Belirlemek hiçbirşeydir fakat koddur. Örneğin Benim telefon numaram 1234567 değildir. Fakat 34 6 1234567dır.
Bu telefon numarası ülke kodunu (34), bölge kodunu (6) ve aletin numarasını (1234567) belli eder.
- Ülkeler arsı konuşmada , kod 34 (İspanya) kullanılır.
- Bölgeler arasında,kod34-6 (İspanya/Valensiya) kullanılır.
- Telefon konuşmasında ise kod 34-6-1234567 (İspanya/Valensiya/telefon numaram) kullanılır.
Bütün bölgelerin ,ülkelerin ve telefonların numarası vardır.
Şehirler arası konuşmak için şehir koduna, milletlerarası için ülke koduna ihtiyacımız vardır. Bu ilişkiler geçicidir ve sadece zaman içinde belirlenirler.
Bu is bir bit kuru ve zor anlaşılır fakat birinci örnekle bu kodu anlatmaya çalıştım.
Birinci soruyu veri tabanı programına gönderdiğimde o bana aralarında mantıksal ilişki kurulan bütün bilgileri döndürdü. Fakat hangi bilgiyi kabul edebilirim? Ülke topluluğu ve ülke parçaları, her ülke için aralarında mantıksal ilişki bulunan ülke parçalarını kabul edeceğim.
Birinci sorum sırasında yeni isimsiz olgularis yaratıldı, Bu ülkelerin kopyalarını ve ülkeleri içeriyor. Bu yeni olgu, sorumun sonunu görünmez yapıyor.
Biz bir bilgiyi kullanmadan önce bilgi dosya olarak kurulur. Bu bir kayıt yapar ve her bilgi bir tarlaya sahiptir. Geleneksel bir veri tabanında a "bir dosya tablo olarak bilinir. Bir tablosatır ve sütunlar içerir,.
Hierarşik veri tabanı programları ulaşım dili olan SQL ı içerir, fakat bu sadece hikayedir. SQL dili geleneksel programların özelliğidir.
SQL i kullanmak için geleneksel bir dosya olan PostgreSQL i kullanacağız. SQL in bütün kurallarını kullanmasa da bile, Bu program projemiz için yeterlidir.
Bu kaynaklar www.postgresql.org adresinden yöreden indirildi (download), bazı yamalarıda yöreden indirilebilir (download). Kaynakları tar ile açın (tar zxvf) dizinine cd postgresql-6.3.
cd src
./configure --prefix=/the/desired/path
make all & make.log &
tail -f make.log
export PATH=$PATH:/the/desired/path/pgsql/bin
export MANPATH=$MANPATH:/the/desired/path/pgsql/man
export PGLIB=/the/desired/path/pgsql/lib
export PGDATA=/the/desired/path/pgsql/data
initdb
createdb test
psql test
Welcome to the POSTGRESQL interactive sql monitor:
COPYRIGHT dosyasını POSTGRESQL için okuyunuz.
type \? for help on slash commands
type \q to quit
type \g or terminate with semicolon to execute query
You are currently connected to the database: postgres
test=
This is the prompt for postgres, now we can start executing commands.
mytest=>create table mytest (field1 varchar(10));
CREATE
mytest=>insert into mytest values ('hello');
INSERT number 1
mytest=>commit work;
NOTICE:EndTransactionBlock and not inprogress/abort state
END
mytest=>select * from mytest;
field1
------
hello
(1 row)
mytest=>drop table mytest;
DROP
mytest=>Ctrl-d
We have already exited the SQL console.
In case of having trouble compiling and installing Postgres95 correctly
please refer to the INSTALL file in the root directory for the distribution.
Let me make another side comment; a relational database server is generally
made of the following parts:
- Data access layer
- SQL processing layer
- SQL parser layer
- Communications layer
As clients we connect to the 4th layer, we send SQL commands which are then
passed to the parser layer. This translates the commands and, in the absence
of errors, sends the requests to the second layer. All the processing
and querying operations take place at this level in collaboration with the
data access layer obviously: data is collected, errors are transmitted to
the client via the communications layer. The SQL processing layer establishes a
dialogue with the client while managing the correct transfer of data and
controlling the transactions and interrupts.
First Steps
Next I will illustrate with an example what has been described so far, let us
build three tables (or files):
File: countries.sql
create table countries (cod_country integer, name varchar(30));
insert into countries values (1, 'country 1');
insert into countries values (2, 'country 2');
insert into countries values (3, 'country 3');
commit work;
File: states.sql
create table states (cod_State int,
cod_country int,
nam_State varchar(30));
insert into states values (1, 1, 'State 1, Country 1');
insert into states values (2, 1, 'State 2, Country 1');
insert into states values (1, 2, 'State 1, Country 2');
insert into states values (2, 2, 'State 2, Country 2');
insert into states values (1, 3, 'State 1, Country 3');
insert into states values (2, 3, 'State 2, Country 3');
commit work;
File: counties.sql
create table counties (cod_country int,
cod_state int,
cod_county int,
nam_county varchar(60));
insert into counties values (1, 1, 1, 'County 1, State 1, Country 1');
insert into counties values (2, 1, 1, 'County 2, State 1, Country 1');
insert into counties values (3, 1, 1, 'County 3, State 1, Country 1');
insert into counties values (1, 2, 1, 'County 1, State 2, Country 1');
insert into counties values (2, 2, 1, 'County 2, State 2, Country 1');
insert into counties values (3, 2, 1, 'County 3, State 2, Country 1');
insert into counties values (1, 3, 1, 'County 1, State 3, Country 1');
insert into counties values (2, 3, 1, 'County 2, State 3, Country 1');
insert into counties values (3, 3, 1, 'County 3, State 3, Country 1');
insert into counties values (1, 1, 2, 'County 1, State 1, Country 2');
insert into counties values (2, 1, 2, 'County 2, State 1, Country 2');
insert into counties values (3, 1, 2, 'County 3, State 1, Country 2');
insert into counties values (1, 2, 2, 'County 1, State 2, Country 2');
insert into counties values (2, 2, 2, 'County 2, State 2, Country 2');
insert into counties values (3, 2, 2, 'County 3, State 2, Country 2');
insert into counties values (1, 3, 2, 'County 1, State 3, Country 2');
insert into counties values (2, 3, 2, 'County 2, State 3, Country 2');
insert into counties values (3, 3, 2, 'County 3, State 3, Country 2');
insert into counties values (1, 1, 3, 'County 1, State 1, Country 3');
insert into counties values (2, 1, 3, 'County 2, State 1, Country 3');
insert into counties values (3, 1, 3, 'County 3, State 1, Country 3');
insert into counties values (1, 2, 3, 'County 1, State 2, Country 3');
insert into counties values (2, 2, 3, 'County 2, State 2, Country 3');
insert into counties values (3, 2, 3, 'County 3, State 2, Country 3');
insert into counties values (1, 3, 3, 'County 1, State 3, Country 3');
insert into counties values (2, 3, 3, 'County 2, State 3, Country 3');
insert into counties values (3, 3, 3, 'County 3, State 3, Country 3');
commit work;
A file with SQL commands can be executed from pgsql like this:
\i file_name
We could also insert the commands using a simple cut & paste.
Let us see next what counties are available:
manu=> select * from counties;
cod_country|cod_state|cod_county|nam_county
-----------+---------+----------+----------------------------
1| 1| 1|County 1, State 1, Country 1
2| 1| 1|County 2, State 1, Country 1
3| 1| 1|County 3, State 1, Country 1
1| 2| 1|County 1, State 2, Country 1
2| 2| 1|County 2, State 2, Country 1
3| 2| 1|County 3, State 2, Country 1
1| 3| 1|County 1, State 3, Country 1
2| 3| 1|County 2, State 3, Country 1
3| 3| 1|County 3, State 3, Country 1
1| 1| 2|County 1, State 1, Country 2
2| 1| 2|County 2, State 1, Country 2
3| 1| 2|County 3, State 1, Country 2
1| 2| 2|County 1, State 2, Country 2
2| 2| 2|County 2, State 2, Country 2
3| 2| 2|County 3, State 2, Country 2
1| 3| 2|County 1, State 3, Country 2
2| 3| 2|County 2, State 3, Country 2
3| 3| 2|County 3, State 3, Country 2
1| 1| 3|County 1, State 1, Country 3
2| 1| 3|County 2, State 1, Country 3
3| 1| 3|County 3, State 1, Country 3
1| 2| 3|County 1, State 2, Country 3
2| 2| 3|County 2, State 2, Country 3
3| 2| 3|County 3, State 2, Country 3
1| 3| 3|County 1, State 3, Country 3
2| 3| 3|County 2, State 3, Country 3
3| 3| 3|County 3, State 3, Country 3
(27 rows)
manu=>
There are 27 rows and pgsql is now waiting the next command,
try this one:
manu=> select * from countries, states;
cod_country|name |cod_state|cod_country|nam_state
-----------+---------+---------+-----------+------------------
1|country 1| 1| 1|State 1, Country 1
2|country 2| 1| 1|State 1, Country 1
3|country 3| 1| 1|State 1, Country 1
1|country 1| 2| 1|State 2, Country 1
2|country 2| 2| 1|State 2, Country 1
3|country 3| 2| 1|State 2, Country 1
1|country 1| 1| 2|State 1, Country 2
2|country 2| 1| 2|State 1, Country 2
3|country 3| 1| 2|State 1, Country 2
1|country 1| 2| 2|State 2, Country 2
2|country 2| 2| 2|State 2, Country 2
3|country 3| 2| 2|State 2, Country 2
1|country 1| 1| 3|State 1, Country 3
2|country 2| 1| 3|State 1, Country 3
3|country 3| 1| 3|State 1, Country 3
1|country 1| 2| 3|State 2, Country 3
2|country 2| 2| 3|State 2, Country 3
3|country 3| 2| 3|State 2, Country 3
(18 rows)
18 rows ??? We inserted 3 countries and 6 states, all identify a single country.
How is it possible we get 18 rows?
The last command has performed a union of two tables, we have related the
table of countries with the table of counties, since we have not specify any
union exclusion rule, pgsql returned ALL possible rows of countries
related with ALL rows of states, i.e. 3 for countries times 6 for states
for a total of 18. This result is obviously illogic and useless, better if we could have done
the following:
manu=> select * from countries, states
manu-> where countries.cod_country = states.cod_country;
cod_country|name |cod_state|cod_country|nam_state
-----------+---------+---------+-----------+------------------
1|country 1| 1| 1|State 1, Country 1
1|country 1| 2| 1|State 2, Country 1
2|country 2| 1| 2|State 1, Country 2
2|country 2| 2| 2|State 2, Country 2
3|country 3| 1| 3|State 1, Country 3
3|country 3| 2| 3|State 2, Country 3
(6 rows)
Well, this begins to appear a bit more reasonable, Six rows, Correct?
Yes, there are six counties and each county is in a country. It is
reasonable to get a number of rows identical to the number of
counties because country is a qualifier of counties. We just related
the table of countries with the table of counties via the country code.
Remember that countries have a code and counties have the code of
the country they belong to.
Why countries.cod_country = states.cod_country ?
The country code in the table of countries is cod_country
and in the table of counties too, therefore:
cod_country = cod_country
is illogical, the interpreter will never now which of the two to use and it would return
us an error:
select * from countries, states
where cod_country = cod_country;
ERROR: Column cod_country is ambiguous
Next, we can use aliases for columns:
manu=> select * from countries a, states b
manu-> where a.cod_country = b.cod_country;
cod_country|name |cod_state|cod_country|nam_state
-----------+---------+---------+-----------+------------------
1|country 1| 1| 1|State 1, Country 1
1|country 1| 2| 1|State 2, Country 1
2|country 2| 1| 2|State 1, Country 2
2|country 2| 2| 2|State 2, Country 2
3|country 3| 1| 3|State 1, Country 3
3|country 3| 2| 3|State 2, Country 3
(6 rows)
What does the manager return?: cod_country, name,
cod_state, cod_country y nam_state.
Since we query "select * from countries, states", where the
* is a wild card that stands for EVERYTHING, we obtained
the two columns for countries and the three for counties. Now we would like
to be more specific:
manu=> select a.cod_country, cod_state, name, nam_state
manu-> from countries a, states b
manu-> where a.cod_country = b.cod_country;
cod_country|cod_state|name |nam_state
-----------+---------+---------+------------------
1| 1|country 1|State 1, Country 1
1| 2|country 1|State 2, Country 1
2| 1|country 2|State 1, Country 2
2| 2|country 2|State 2, Country 2
3| 1|country 3|State 1, Country 3
3| 2|country 3|State 2, Country 3
(6 rows)
In the last command we explicitly asked for the country
code, the state code and the name of the country and state.
Notice that some column names are qualified (a.cod_country)
while others are not (nam_state), this is because cod_country
is repeated in both tables while nam_state exists only in states.
Unique column names do not need extra qualifiers.
Let us make things more complicated:
manu=> select a.cod_country, cod_state, name, nam_state
manu-> from countries a, states b
manu-> where a.cod_country = b.cod_country
manu-> and a.cod_country = 3;
cod_country|cod_state|name |nam_state
-----------+---------+---------+------------------
3| 1|country 3|State 1, Country 3
3| 2|country 3|State 2, Country 3
(2 rows)
This time we limited the search to country number 3 only.
Fonksiyonlar
Burada satir sayma fonksiyonunun ( row counting function ) kullaniminin
bir örnegi yeralmaktadir. count():
select count(*) from states;
count
-----
27
(1 row)
counties in tablosunda yer alan satirlarin sayisini olusturur, sonraki:
manu=> select cod_country, count(*) from states
manu-> group by cod_country;
cod_country|count
-----------+-----
1| 2
2| 2
3| 2
(3 rows)
Benzer ülke kodlu satirlarin numarasini verir, Bu cod_country
kullanmanin bir nedenidir..
Hatta daha iyi bir örnekle:
manu=> select name, count(*) from countries a, states b
manu-> where a.cod_country = b.cod_country
manu-> group by name;
name |count
---------+-----
country 1| 2
country 2| 2
country 3| 2
(3 rows)
Biz ayni üç satiri verdik ama bu kez daha açik bir bilgi
geldi.
Simdiye kadar küçük bir giris yaptik, yalnizca
hazirlaniyoruz :-)
Genelin Tekrari (Concepts
Review)
Simdiye kadar yalnizca SQL birkac kücük genel özellikten
bahsettik.SQL in en baglantili seyi burdaki kendine has genel özelikleridir.
Degismeyen (sabit) bilgilerle calismiyoruz ayrik bilgilerle calisiyoruz.
Ayrik bilgiler veritabaninin daha etkin bilgileridir."BÜTÜNDEN
YALNIZCA UYGUN OLAN PARÇANIN GERI DONÜSÜ" seklinde
bir örnekleme onu daha anlasir kilar.
Birçok farkli komut gördük:
CREATE TABLE |
Bu komut bölümlere sahip bir tablo olusturur. |
DROP TABLE |
Tabloyu temizler. |
SELECT |
Bu komut SQL 'in destegidir, Gerekli bilgilerinde yeraldigi kullanisli
bir tablo olusturmamizi saglar.. SELECT parametre fonksiyonlari yada komplike
yapilari verebilir, sub_selects te oldugu gibi:
select count(*) from states
where cod_country in (select cod_country from countries);
count
-----
27
(1 row)
|
BEGIN WORK |
Bu diger önemli komutlardan biridir. BEGINWORK veri tabani yöneticimize
yapilacak olan tüm degisikliklerin basladigini söyler.Bizim özel
veritabani yöneticimiz BEGIN WORK ile bölümlerin baslangicini
ayirir, Diger yöneticilerde bölümlerin baslangici veri tabanindaki
seylerden farkli olan bir ilk komutla baslar. postgreSQL de bütün
komutlar farklidir önünde BEGINWORK olmadikça bütün
veriler dogrudan icra görür .
NOT: komutlar veri tabaninin semasini degistirir COMMIT WORK,
Bu yüzden bir bölüm açildiginda ve bir komut çalistirildiginda
bizim bölümümüz hemen kapatilmali ve bir ROLLBACK WORK
yollamasi imkansiz hale getirilmelidir .
Bir kullanici bir bölüm açarken kendi bilgisi için
erisim tipini diger kullanicilara tanimlayabilir :
Degisen bilgi
Bölümdeki ilk bilgi
Blok bilgi erisimi
|
COMMIT WORK |
Degisen bilgilerin kabulu ile bölümü kapatir. Komut
bilgiye bir önceki ana bölümleri için ROLLBACK WORK
yollar . |
Bölümlerin genel fikri bir hata olustugu zaman bir önceki
bölümelere dönebilmemiz bakimindan önemlidir. Bu islemi
deneyelim, Önce "rollback work" ile önceki bölümleri
kapayalim:
manu=> select * from countries;
cod_country|name
-----------+---------
1|country 1
2|country 2
3|country 3
(3 rows)
Üç satir var,
begin work;
Bölümü baslatir
insert into countries values (5, 'Country Not True');
Bir satir ekledik Sonraki satirlarda olanlari dogruladik
manu=> select * from countries;
cod_country|name
-----------+----------------
1|country 1
2|country 2
3|country 3
5|Country Not True
(4 rows)
Bütün satirlar burada. Sonra
rollback work;
Bu bizi bolumden ayirir.
manu=> select * from countries;
cod_country|name
-----------+---------
1|country 1
2|country 2
3|country 3
(3 rows)
Satirlarin numaralarini kontrolden sonra yeniden orijinal 3 satirimiza
döndük.
INSERT |
Bu komutu zaten görmüstük yeni bir tablo ekler. |
CREATE TABLE |
Diger bir önemli komut, Bir tablo ve onun bölümlerini
yapar, Simdi tasinabilir bilgileri görelim
char(range): |
30 byte uzunlugunda Alfa-numeric bilgi. |
varchar(rango): |
30 byte a kadar degisebilen Alfa- numeric bilgi. |
int2: |
' byte uzunlugunda binary sayisal bilgi: 2**-15 hasta 2**15 |
int4: |
+ byte uzunlunda binary sayisal bilgi: 2**-31 - 2**31 |
money: |
Sabit noktali sayi , örn: money(6,3) i0-9 arasi 6 sayi, bunlarin
üçü ondalik (3 ondalik ,3 integer). |
time: |
Saati, dakikayi,saniyeyi,saliseyi ekler SS:DD:SS:Salise |
date: |
Tarihi, yil,ay, gün ekler , , |
timestamp: |
Hem tarihi hemde saati ekler |
float(n): |
tekil dogru sonuçlarin gerçek bilgisi. |
float3: |
çift dogru sonuclarin gerçek bilgisi. |
Veri tipinin taniminda karakteristik özellileri ile her çesit
SQL yöneticisi için belirgin olmak gerekir . Bu kurs bize yalnizca
PostgreSQL in birkaç beligin tipinigösterecektir . |
DELETE |
tablodaki satirlari siler |
UPDATE |
tablodaki satirlarin kolonlarini tanimlar. |
ÖZET
Bu sabit olmayan stilimize ragmen, SQL 'e giris yaptik ve iliskisel veritabanini
olusturduk.
SQL bilgimiz için genel bir yapi olusturmamizi saglar ve
ihtiyacimizi gerceklestirecek bir yol bulmamiza izin verir.
Simdiye kadar gördüklerimizden söyle bir soru çikartabiliriz,:
Uygulamada SQL 'i nasil kullanabiliriz?
Cevap ardindan kendiliginden gelecektir, üç bölümümüzde
SQL kullanarak kisa C uygulamalari gözden geçirecegiz.
|