Bu yazının amacı, site üzerinde daha önceden anlatılmış olan birinci normal form (1NF),
ikinci normal form (2NF) ve üçüncü normal form (3NF) konularını kapsayan bir örnek çözmektir.

Genel olarak çok sayıda sınav sorusunda normalleştirme için hayali bazı tablolar sunulur ve bu tabloların normalleştirilmesi (normalizasyonu) istenir.

Örnek olarak aşağıdaki tabloyu ele alalım.

Yukarıdaki tabloda görüldüğü üzere 4 adet kolon ve her kolonda çeşitli sayılar ile gösterilmiş değerler bulunmaktadır. Bu tablonun üzerinde normalleştirme yapmaya başlamadan önce bazı konuları açıklayalım.

Örneğin yukarıdaki tabloda bir aday anahtar (candidate key) bulmamız istense ne yaparız?

Bir aday anahtar bulma işlemi için en kolay yol, tablonun birincil anahtarını (primary key) bulmaktan geçer. O halde sorumuzu öncelikle tablonun birincil anahtarını (primary key) bulmak üzere değiştirelim:

Yukarıdaki tabloda, satır bazlı olarak tekrar etmeyen bir kolon var mıdır?

Cevap : D kolonudur. Dikkat edilirse D kolonu, her satırda farklı bir değer almıştır. Demek ki tek bir kolonun birincil anahtar (primary key) olmasını istersek, D kolonunu seçmemiz yerinde olur.

Peki birden fazla kolon alınması durumunda hangi kolonları seçebiliriz?

Cevap: D kolonunun zaten her satırda tekrarsız olduğunu (unique) biliyoruz. Dolayısıyla D kolonu ile birlikte hangi kolon alınırsa alınsın bu kolonlar da tekrarsız (unique) olacaktır.

Ancak acaba D kolonunu almadan bir asil anahtar ( primary key) bulunabilir mi?

Cevap: Evet vardır. Örneğin (A,B) ikilisi de tablodaki her satırda tek başına tekrarsız (unique) olma özelliğindedir. Bir önceki cevabımızdan çıkardığımız üzere, (A,B) ikilisi ile birlikte alınacak diğer bir kolon da (örneğin C ) bu durumda birincil anahtar (primary key) olma özelliğini taşıyacaktır.

Yukarıdaki cevapların doğru olmasına karşılık, birincil anahtar (primary key) seçimi yapılırken en az sayıda kolonu içeren alternatifin seçilmesi yerinde olur. Bu anlamda, yukarıdaki anahtar ihtimallerinin hepsi birer aday anahtar (candidate key) olarak değerlendirilebilir ancak birincil anahtar olarak D kolonun tek başına seçilmesi yerinde olur.

Gelelim bir diğer soruya:

Yukarıdaki tabloya, aşağıdaki şekilde ilave bir kolon eklediğimizi düşünelim:

Yeni tablomuzda bulunan fonksiyonel bağlılıkları (functional dependency) çıkarmaya çalışalım:

Öncelikle, biliyoruz ki D kolonu birincil anahtardır (primary key) dolayısıyla zaten D kolonu bütün kolonların fonksiyonel olarak bağımlı olduğu bir kolondur ve aşağıdaki satırların tamamı doğrudur:

D à A , D àB , Dà C , Dà E

Ayrıca bir dipnot olarak, her kolonun kendisine fonksiyonel bağlı olduğunu söyleyebiliriz (self functional dependency), dolayısıyla DàD ifadesi de doğrudur ancak bu ifade, genelde veritabanı normalleştirmesinde bir anlam ifade etmediğinden göz ardı edilir.

Gelelim diğer fonksiyonel bağımlılıklara. Tabloda ikili üçlü ve dörtlü fonksiyonel bağlılıklar bulunabilir. Örneğin yukarıdaki sorularda (A,B) çiftinin de bir aday anahtar olduğundan bahsetmiştik. Bu durumda (A,B) à C, (A,B) à D , (A,B) à E ifadeleri de doğru olacaktır. Hatta D ile birlikte herhangi bir kolonun alınması da doğrudur. Örneğin (C,D) à A, (C,D) à B , (C,D) à E ifadeleri de doğrudur. Benzer şekilde D bir aday anahtar, birden fazla kolon birleşimini de fonksiyonel olarak ifade eder. Örneğin D à (A,B,C) veya Dà (B,C,E) veya (A,B) à (C,D,E) ifadelerinin tamamı da doğru kabul edilebilir.

Ancak acaba tek kolon seviyesinde başka fonksiyonel bağımlılık bulunabilir mi? Bu sorunun cevabı aslında bir kolon değişirken diğer bir kolonun değerlerinin bu değişimi yansıtıp yansıtmadığıdır.

Örneğin yukarıdaki tabloda, B ve E kolonları birlikte değişmektedir. Diğer bir deyişle B(1) à E(X) ve B(2)à E(Y) bağlantısı bulunmaktadır. Yani B tablosundaki 1 ile E tablosundaki X ve B tablosundaki 2 ile E tablosundaki Y arasında bir birliktelik söz konusudur.

Bu anlamda, BàE ve EàB ifadeleri doğrudur. Ancak konunun daha iyi anlaşılması için tabloda ufak bir oynama yapalım:

Yukarıdaki yeni tabloda, B kolonunun son satırı 3 olarak değiştirilmiştir. Bu durumda acaba BàE ve EàB ifadelerinden bahsedilebilir mi?

Tablonun yeni halinde E’deki her değişim, B’de bir değişimle karşılandığı için BàE ibaresi doğrudur ancak ne yazık ki EàB ibaresi kullanılamaz çünkü E, B’deki değişimleri göstermek için yetersizdir.

Ayrıca yukarıdaki tabloda, C kolonu, bütün diğer kolonlara fonksiyonel olarak bağımlıdır. Bunun sebebi C kolonunun sabit olması ve dolayısıyla bütün kolonlar tarafından doğası gereği fonksiyonel bağımlılığının ifade edilmesinin mümkün olmasıdır.

Gelelim tablomuzu normalleştirmeye. Tablomuzda bulunan fonksiyonel bağımlılıkları normalleştirme aşamasında kullanacağız. Normalleştirme işleminin amacını kısaca tabloda tekrar eden veri bırakmamak (veya en aza indirmek) olduğunu söyleyebiliriz.

Yukarıdaki son halini almış tablomuzda, BàE bağımlılığının bulunması bize aşağıdaki durumu oluşturma imkanı sağlar:

Görüldüğü üzere, B kolonu ve E kolonu ayrı bir tabloda tutularak, E kolonunun B kolonuna fonksiyonel bağımlılığından yararlanılmıştır. Bu durumda E kolonunun orjinal tabloda yer almasına gerek yoktur. A,B,C veya D kolonları ile birlikte karşılığı olan E kolonunu bir kişinin sorgulamak istemesi halinde, iki tablo arasında bir birleştirme (join) işlemi uygulanacak ve istenen veriye kolaylıkla ulaşılabilecektir. Bu durumda K tablosundaki B kolonu bir yabancı anahtar (foreign key) olmuş ve M tablosundaki B kolonu ise birincil anahtar (primary key) olmuştur denilebilir.

Gelelim C kolonuna. Bu kolon da herhangi bir kolona fonksiyonel bağımlı kabul edilebilir demiştik. O halde aşağıdaki şekilde bölünebilir:

Yukarıdaki gösterim doğru olmasına karşılık, aşağıdaki gösterim de doğrudur:

Veya diğer bir çözüm olarak aşağıdaki çözüm de doğrudur:

Yukarıdaki bütün çözümler doğrudur. Görüldüğü üzere, normalleştirme işleminde, tekrar eden satırlar elenmiş ve mümkün olduğunca tekrarsız satırların bırakılması amaçlanmıştır.

Burada bir soru, DàA özelliğini neden kullanmadık şeklinde sorulabilir. Yani D kolonu zaten A kolonunu veya B kolonunu belirlemektedir, o halde bu özelliği de kullanarak bir bölme işlemine daha gidilebilir mi?

Cevabı hem evet hem de hayırdır. Teorik olarak bahsedildiği gibi bir bölme olabilir. Ancak bu bölmenin hiçbir faydası olmaz. Aşağıda göstermeye çalışalım:

Bir önceki şekilde bulunan tablo K’yı tablo K ve tablo Q olarak bölmeye çalıştım. Görüldüğü üzere herhangi bir satır sayısında azalma olmamıştır. Bu tip birincil anahtar kullanarak bölme işlemleri mümkün olmakla birlikte genelde normalleştirme anlamında bir fayda sağlamaz. Bu şekilde böldükten sonra, iki tablo arasında (örneğimizdeki tablo K ve Q ) sayısallık açısından (cardinality) birebir (one-to-one) ilişki kurulmaktadır ki teorik olarak iki tablo arasında birebir ilişki varsa aslında bu iki tablo, bir tablonun ikiye bölünmüş halidir denilebilir. Genelde birebir ilişki, veritabanında hız amacıyla kullanlan (bazı kolonlara istatistiksel olarak çok nadir erişim yapıldığı biliniyorsa) veya veritabanı kısıtlarından dolayı kullanılan (örneğin veri tabanımızın tablo başına sadece 10 kolon tutmaya izin verdiği durumda 15 kolonlu bir tablo oluşturmak için) bir özelliktir.

99 views

Google tarafından geliştirilen ve arama motoru tasarımında kullanılan yaklaşımdır. Kısaca amaç, web sayfalarının daha başarılı bir şekilde depolanması (storing), bulunması (finding) ve güncellenmesidir (updating) .

Google’ın konuya yaklaşımı, ucuz bilgisayarlar tarafından yüksek miktarda verinin tutulması ve işlenmesi yönündedir. Bu yaklaşımın genel bir görüntüsü aşağıdaki şekilde çizilebilir:

Yukarıdaki şekilde görüldüğü üzere, bir büyük mantıksal tablo, çok sayıda küçük tabletlere bölünmüştür. Diğer bir deyişle, aslında tek bir bilgisayarda işlenecek olan mantıksal tablo, çok sayıda ufak ve nispeten daha ucuz bilgisayar tarafından işlenebilmekte / tutulabilmektedir.

Büyük tablo yaklaşımında, veriler aşağıdaki şekilde tutulmaktadır:

Yukarıdaki tabloda gösterildiği üzere, herhangi bir büyük tablo kayıdında, sitenin adresi, sitenin metin kısmı, sitede bulunan bağlantılar (link, anchor, çıpa) vey sitenin başlığı tutulmaktadır.

Büyük tablo (big table) yaklaşımında, herhangi bir veriye erişmek için, erişilecek olan hücrenin, zaman bilgisi, satır bilgisi ve kolon bilgisine ihtiyaç duyulur. Örneğin yukarıdaki örnek sitenin fihristlendiği (indexing) zaman, sitenin adresi ve hangi bilgisine erişileceği (örneğin sitenin içeriği olan metin) bilgileri birleştirilerek bir erişim sağlanabilir.

Büyük tablo kullanımının avantajları aşağıdaki şekilde sıralanabilir.

• Özel bir sorgulama diline (query language) ihtiyaç duyulmaz ve dolayısıyla sorgulama dilinin iyileştirilmesi (query optimisation) gibi özel adımlara gerek yoktur.
• Sadece satır seviyesinde işlemler gerçekleştirilir. Yani ilişkisel veritabanı (relational database) tasarımında olduğu üzere, tablolar arasında birleştirme (join)gibi işlemlere gerek yoktur.
• Tabletler, bütün büyük tablo (big table) sisteminde bulunan sunucular tarafından erişilebilir durumda tutulurlar.
• Ayrıca yapılan her işlem ilave bir işlem kütüğünde (transaction log) tutulur ve bu kütüğe bütün sunucular erişebilir.
• Sunuculardan birisinin bozulması durumunda, diğer sunuculardan birisi bu işlem kütüğüne erişerek bozulan sunucunun görevini üstlenebilir.

Büyük tablonun en önemli avantajlarından birisi, satır bazında bir limitinin olmamasıdır. Yani her kayıt için sınırsız sayıda bağlantı tutulması gerekebilir. Önceden bir sayı belirlenmesi, iki yönlü olarak probleme sebep olabilirdi. Örneğin her sayfa başına 100 bağlantı tutma limiti gelmiş olsaydı, daha az olan sayfalar için gereksiz yere hafızada yer işgal edilecek, daha fazla olan sayfalar için de bağlantıların sadece ilk 100 tanesinin tutulup, geri kalanının tutulamaması gibi bir durum ortaya çıkacaktı.

Bu yaklaşımla, ayrıca disk erişimi de azaltılmış olur çünkü bir erişimde, site ile ilgili bütün bilgilerin okunması mümkündür. Alternatif olarak ilişkisel bir veritabanı kullanılması durumunda, site ile ilgili bilgilerin okunması ancak bütün tablolara erişildikten sonra mümkün olacaktı.

Elbette büyük tablo yaklaşımının karşılaştığı problemler de bulunur. Örneğin, aynı kaydın birden fazla kere geçmesi bir risktir. Örneğin aynı içeriğin internet üzerinde içerik hırsızları tarafından kopyalanması, aynı içeriğin bir kısmının aynı kaldığı yeni sürümlerinin çıkması, intihal olarak çalıntı içeriğin bulunması, çoklu gönderiler (spam, mass message) ile aynı içeriğin birden fazla divan (forum ) ve tartışma sitelerinde bulunması veya kopya siteler bu tip içerik tekrarlarının başlıca sebepleridir. Yapılan çalışmalarda, geniş kapsamlı bir web emeklemesi (web crawling) sonucu, dolaşılan sayfaların %30′luk bir bölümü, geri kalan %70′lik bölüm içerisinde tam veya benzer içerikte kopyalar bulundurmaktadır (diğer bir deyişle sadece %40′lık bir kesimin benzeri veya tam kopyası bulunmamakta %60′lık kesim ise benzer veya tam kopya olarak internette bulunmaktadır. Bu problemin çözümü için tekrarların bulunması gerekir (duplicate detection).

Tekrar bulma işlemi iki seviyede yapılabilir. Birincisi tam tekrarın bulunmasıdır ki buradaki amaç, birebir kopyalanan içerikleri eşleştirmektir. Diğer bir yaklaşım ise benzerliklerin bulunması ve belirli bir benzerlik seviyesinin üzerinde olan içeriklerin eşleştirilmesidir. Örneğin şu anda yazmakta olduğum yazıyı, kopyalayarak, yazar kısmına kendi ismini yazan birisi ile bu sayfadaki içeriğin eşleşmesi gerekir. Sonuçta birebir aynı değildir ama çok yakın içeriktedirler ve iki sayfa için ayrı ayrı sunucuda kaynak kullanılması problem oluşturabilir.

Tam benzerliğin bulunması için toplam kontrolü (checksum) yöntemleri kullanılır. Örneğin CRC (cyclic redundancy check) ve benzer algoritmalar ile sayfaların toplam kontrolü yapılır ve eşleştirilir.

Benzer sitelerin bulunması için de geliştirilmiş algoritmalar vardır. Örneğin SimHash algoritması (benzerlik özeti) bu algoritmalara bir örnektir ve google tarafından da kullanılmaktadır.

269 views

Bilgisayar bilimlerinde özellikle veri tabanı (databases) konusunda geçen bu kavramlar, iki tablonun birleşmesi sırasında bir tabloda bulunmayan kayıtlar için nasıl bir yol izleneceğini anlatırlar.

Bilindiği üzere iki tablonun birleşmesi (join) aslında iki tabloda bulunan kayıtlar için bir kartezyen çarpım (cartesian product) alınması işlemidir. Bir işlemin sadece Kartezyen çarpımının alınması ile birleşmesine çapraz birleştirme (cross join) ismi verilir. Bu işlem sırasında herhangi bir koşul bulunursa bu tip birleştirmelere de şartlı birleştirme (koşullu birleştirme, conditional join) ismi verilir. Şayet iki tabloda da bulunan ve tercihen bir tabloda birincil anahtar (primary key) olup diğer tabloda yabancı anahtar (foreign key) olan bir kolonun eşitliği birleşme sırasında koşul olarak veriliyorsa bu tip birleşmelere de eşit birleşme (equijoin veya doğal birleşme, natural join) ismi verilir.

İç birleştirme (inner join) veya dış birleştirme (outer join) işlemi ise bu birleştirme koşulunun üzerinde, iki taraf için taşıyıp taşımamasına göre belirlenir.

Şayet iki tabloda da aynı koşulun sağlanması isteniyorsa bu tip birleştirmelere (join) iç birleştirme (inner join) ismi verilir.

Şayet iki tablodan birisinin koşulu sağlanması isteniyorsa bu tip birleştirmelere de dış birleştirme (outer join) ismi verilir.

Birleştirme işlemi sırasında, işlemin (operator) sol veya sağ tarafının koşulu sağlamasına göre, birleştirme işlemine sol dış birleştirme (left outer join) veya sağ dış birleştirme (right outer join) ismi verilebilir.

Yukarıdaki bu tanımları örnekler üzerinden anlamaya çalışalım.

Örneğin birleştirme (join) yapmak istediğimiz iki tablo aşağıdaki şekilde verilmiş olsun:

Çalışanlar Tablosu:

İki kolonlu bu tabloda her çalışanın hangi kısımda çalıştığını kısım tablosunun birincil anahtarı olarak tutuyor olsun. Dolayısıyla yukarıdaki çalışan tablosunda bulunan kısım kolonu bir yabancı anahtar (foreign key) olmuş olur.

Yukarıdaki iki tablonun iç birleştirmesinin sonucu (iner join) aşağıda verilmiştir:

Yukarıdaki birleşim sonucunda örneğin finans kısmı ile ilgili veya Ömer için bir satır bulunmamaktadır, çünkü ancak iki tabloda ortak olan satırlar alınmıştır.

İç birleştirme genelde SQL dillerinde herhangi bir şey belirtilmediğinde yapılan birleştirme şeklidir. Örneğin yukarıdaki tablolar için aşağıdaki SQL satırı yazıldığında iç birleştirme kastedilmiş olur:

Select * from çalışanlar , kısımlar

		where çalışanlar.KısımNo = kısımlar.KısımNo;

Yukarıdaki satırı bazı SQL dillerinde özel olarak inner join ibaresi ile belirlemek gerekebilir. Bu durumda yukarıdaki SQL cümlesini aşağıdaki şekilde değiştirebiliriz:

Select * from çalışanlar , kısımlar

		inner join ksımlar

		on  çalışanlar.KısımNo= kısımlar.KısımNo;

Yukarıdaki birleştirme işlemi ayrıca yabancı /birincil (foreign / primary key) anahtar eşitliği olduğu için bir eşit birleştirme (equi join) olarak da kabul edilebilir. Eşit birleştirmelere özel olarak SQL dilinde “using” komutu kullanılabilir. Yukarıdaki SQL cümlesini “using” komutu ile yazacak olursak:

Select * from çalışanlar , kısımlar

		INNER JOIN ksımlar

		using (KısımNo);

Eşit birleştirmenin özel bir hali olan doğal birleştirmede (natural join) ise, eşitliği aranan kolonların isimlerinin birebir aynı olması gerekir. Yukarıdaki örnekte iki tabloda da KısımNo isimli kolonlar eşit olacağı ve iki tabloda da aynı isme sahip olduğu için doğal birleştirme yapılabilir. Şayet tablolardaki kolonlar aynı amaçla aynı bilgileri tutan fakat farklı isimlere sahip olsaydı doğal birleştirme işlemi yapılamazdı.

Select * from çalışanlar

		natural join ksımlar

Doğal birleştirme sırasında, yukarıda görüldüğü üzere “natural join” kelimesi kullanılabilir.

Bu yazı şadi evren şeker tarafından yazılmış ve bilgisayarkavramlari.com sitesinde yayınlanmıştır. Bu içeriğin kopyalanması veya farklı bir sitede yayınlanması hırsızlıktır ve telif hakları yasası gereği suçtur.

Buraya kadar olan birleştirme şekilleri sonuçta birer iç birleştirmedir ve sonuçların hepsinde yukarıdaki örnek tablo gösterilecektir. Dış birleştirme durumunda ise aşağıdaki sonuç çıkacaktır:

Yukarıdaki tabloda dikkat edilirse, karşılığı olmayan değerler de alınmıştır. Yani Ömer isimli çalışanın, hangi kısımda çalıştığı bilinmemektedir veya Finans kısmında çalışan kimse yoktur ama yine de bu bilgiler karşılığı null (boş) da olsa alınmıştır. Bu birleştirme tipine tam dış birleştirme anlamına gelen full outer join ismi de verilir ve bazı SQL dillerinde bu komut olarak kullanılır.

Sol dış birleştirme (left outer join) için birleştirme sırasındaki tablolardan solda olanı esas kabul edilerek, bu tablodaki bütün değerler karşılığı olsun olmasın yazılır. Buna karşılık soldaki tabloda karşılığı bulunmayan satırlar yazılmaz. Örneğin aşağıdaki SQL cümlesini ele alalım:

Select * from çalışanlar , kısımlar

		Left OUTER join ksımlar

		on  çalışanlar.KısımNo= kısımlar.KısımNo;

Yukarıdaki cümlenin çıktısı aşağıdaki şekildedir:

Görüldüğü üzere normal bir dış birleştirmede olması beklenen finans departmanı, sol dış birleştirme sonucunda çıkmamıştır. Şayet cümlemizi aşağıdaki şekilde değiştirecek olursak:

Select * from çalışanlar , kısımlar

		LEFT outer join ksımlar

		on kısımlar.KısımNo = çalışanlar.KısımNo;

Bu durumda da finans kısmı solda olan tabloda olduğu için yazılacak ancak Ömer isimli çalışan sağdaki tabloda olduğu için sonuçta görülmeyecektir.

Yukarıdaki şekilde sol dış birleştirmede, tabloların yerini değiştirmek yerine, sağ dış bağlantı (right outer join) yapılması da mümkündür. Yani şayet tabloların yerini değiştirmek yerine aradaki birleştirme tipini aşağıdaki şekilde değiştirirsek:

Select * from çalışanlar , kısımlar

		Right outer join ksımlar

		on  çalışanlar.KısımNo= kısımlar.KısımNo;

Sonuç yine yukarıda görülen son tablo şeklinde olacaktır.

Anti Join (Zıt Birleştirme)

SQL dilinde kullanılan bir birleştirme tipi de zıt birleştirme’dir (antijoin). Bu tip birleştirmelerde amaç iki küme arasında zıtlık (anti) ilişkisi kurmaktır. SQL dilinde bulunan NOT IN ve NOT EXISTS kelimeleri ile, sorgulanan bilginin, verilen bir kümede olmaması şartı aranır.

SELECT   k.kısım
    FROM kısımlar k
   WHERE NOT EXISTS (SELECT NULL
                       FROM çalışanlar ç
                      WHERE ç.kısımNo = k.kısımNo)

Yukarıdaki sorgu cümlesindeki amaç, çalışanı olmayan departmanları bulmaktır.  Görüldüğü üzere iç içe iki sorgu bulunmaktadır.  Mavi renkle gösterilen iç sorguda, dıştaki sorgu ile bağlantı kurulmaya çalışılmıştır. Burada önemli olan iki küme arasında içermeme ilişkisi kurulmasıdır. Yukarıdaki sorgunun çıktısı aşağıdaki şekildedir.

Görüldüğü üzere çalışanı bulunmayan tek kısım olan Finans, sonuç kümesinde görülmektedir.

Zıt birleştirme (anti join) işlemleri aslında iki küme arasında fark almaya (set difference) benzetilebilir. Örneğin yukarıdaki sorgu cümlesi, aşağıdaki şekilde de yazılabilir:

SELECT  k.kısım
    FROM kısımlar k
MINUS
SELECT   k.kısım
    FROM kısımlar k, çalışanlar ç
   WHERE k.kısımNo = ç.kısımNo

Yukarıdaki yeni sorgunun, bir önceki sorgudan anlam olarak bir farkı yoktur. Mavi renkle gösterilen sorgunun sonucu, ilk sorgudan çıkarılmıştır (minus). İlk sorguda (siyah renkli olan) bütün kısımlar sorgulanmakta ve sonuç kümesinden, çalışanı olan kısımlar çıkarılmaktadır ( mavi sorgu). Bu işlemi, ilişkisel cebirdeki (Relational Algebra) , fark işlemi (difference) olarak düşünebiliriz.

Semi Joins (Yarı Birleştirmeler)

SQL cümleleri hazırlanırken kullanılan bir birleştirm türü de yarı birleştirmelerdir (semijoins). Bu birleştirme tipleri, bir önceki bölümde anlattığımız zıt birleştirmelerin tersi olarak düşünülebilir. Yani zıt birleştirmelerde kullanılan NOT IN veya NOT EXISTS kelimelerinin tam tersi anlamdaki IN veya EXISTS kelimeleri, yarı birleştirmelerin (semi joins) yazılmasını sağlar.

Örneğin, yukarıdaki zıt birleştirme (ters birleştirme) işleminin tersi anlama gelen ve çalışanı bulunan kısımları görmeyi amaçlayan aşağıdaki sorguyu ele alalım:

SELECT   k.kısım
    FROM kısım k
   WHERE EXISTS (SELECT NULL
                   FROM çalışanlar ç
                  WHERE ç.kısımNo = k.kısımNo)

Yukarıdaki sorguda, mavi renkle gösterilen ikinci sorgu, çalışanlar ile kısımlar arasında bağlantı kurmakta, dışarıdaki sorgu ise bütün kısımları sorgulamaktadır. Bütün kısımlardan çalışanları olan kısımları sorgulamak için “exists” kelimesi kullanılmıştır.

295 views

İngilizce olarak object linking and embedding database kelimelerinin baş harflerinden oluşan bir veritabanı terimidir. Aslında OLE terimi (object linking and embedding) Microsoft firması tarafından kazandırılan ve uygulama geliştirme sırasında bir varlığı programa bağlamaya yarayan mantıktır.

Örneğin bir prograda bulunan bir resim, programın içerisine dahil edilip çalıştırılabilir kodun (executable code) bir parçası olabileceği gibi, bir resim dosyası olarak hariçte tutulup programın çalışması sırasında bu harici dosyadan okunabilir. Bir varlığın bu şekilde programa dahil edilmesine microsoft terminolojisinde COM (component object model) ismi verilirken hariçte tutulmasına ole ismi verilir.

OLEDB terimi ise bu açıklamadan anlaşılacağı üzere program ile veri tabanı arasındaki bağlantının hariçte tutulması anlamındadır. Aslında MDAC ismi verilen ve microsoft tarafından geliştirilen microsoft data access components (microsoft veri erişim bileşenleri) ailesinin bir üyesi olan OLEDB, kısaca microsoft ortamlarında veritabanına (DB database) erişmek için kullanılan çeşitli yöntemlerden birisidir. Yapı olarak ODBC bağlantısına benzetilebilir.

OLEDB kullanımını daha net anlayabilmek için C# dilinde yazılmış aşağıdaki kodu anlamaya çalışalım:

using System;
using System.Data.OleDb;

public class ReadFromOleDb
{
  [STAThread]
  static void Main(string[] args)
  {
    String sConn = "provider=sqloledb;server=(local)\\SQLEXPRESS;database=veritabani;Integrated Security=SSPI";

    String sSQL = "select id, firstname, lastname from Employee";

    OleDbConnection oConn = new OleDbConnection(sConn);
    oConn.Open();

    OleDbCommand oCmd = new OleDbCommand(sSQL, oConn);
    OleDbDataReader oReader = oCmd.ExecuteReader();

    int idxID = oReader.GetOrdinal("id");
    int idxFirstName = oReader.GetOrdinal("firstname");
    int idxLastName = oReader.GetOrdinal("lastname");

    while(oReader.Read()) {
      Console.WriteLine("{0} {1} {2}",
        oReader.GetValue(idxID),
        oReader.GetValue(idxFirstName),
        oReader.GetValue(idxLastName));
    }
  }
}

Yukarıdaki kodda dikkat edileceği üzere System.Data.OleDb kütüphanesi kullanılmıştır. OleDb ile veritabanı işlemini 3 adımda inceleyebiliriz:

1. Veritabanı bağlantısının kurulması

2. Bağlantı üzerinde bir sorgunun (query) çalıştırılması

3. Sorgu sonucunda (şayet sorgu bir sonuç kümesi döndürüyorsa (result set) ) sonuç kümesi üzerinde işlem yapılması

Bu sıralanan adımları yukarıdaki kodda belirleyecek olursak ilk adım olan veritabanı bağlantısı

String sConn = "provider=sqloledb;server=(local)\\SQLEXPRESS;database=veritabani;Integrated Security=SSPI";

OleDbConnection oConn = new OleDbConnection(sConn);
oConn.Open();

Şeklinde 3 ayrı satırda kurulmuştur.  Buradaki provider terimi sqlodedb olarak belirlenmiştir. Bunun anlamı bilgisayarımızda bu bağlantıyı sağlamaya yarayan bir sürücü (driver) bulunması gerektiği ve bağlantının isminin tam olarak sqloledb olmasıdır.

Ardından server= ile başlayan kısımda (local) yazılmıştır. Burada da aynı bilgisayar üzerinde bulunan veri tabanına bağlanılacağı anlaşılıyor. Şayet farklı bir sunucudaki bir veritabanına bağlanılması istenirse bu durumda sunucunun internet addresi ( IP address ) veya ağ kurulumuna göre  ismi yazılmalıdır.

Bu yazı şadi evren şeker tarafından yazılmış ve bilgisayarkavramlari.com sitesinde yayınlanmıştır. Bu içeriğin kopyalanması veya farklı bir sitede yayınlanması hırsızlıktır ve telif hakları yasası gereği suçtur.

database= ile başlayan kısma ise veri tabanı sunucumuzda bulunan ve bağlanılmak istenen veritabanının ismi yazılır.

Integrated Security ile SSPI ayarlanmıştır. SSPI aslında detaylıca anlatılabilecek bir güvenlik modülü olmasına karşılık bu yazıda sadece Security Support Provider Interface kelimelerinin baş harfinden oluştuğunu ve bağlantı sırasında gidip gelen verinin güvenli bir şekilde saklanmasının hedeflendiğini söylemek ile yetinelim.

Yukarıdaki bağlantıyı gösteren ikinci satırda OleDbConnection sınıfından (class) bir nesne (object) oluşturuyoruz ve ismi de oConn olarak veriliyor. Burada OleDbConnection yapıcısına (constructor) parametre olarak bir önceki saıtrda tanımladığımız dizgiyi (string) veriyoruz.

Son olarak oConn.open() metodunu çağırarak bağlantıyı açıyoruz.

Bağlantı açıldıktan sonra, bu bağlantı üzerinden artık sorgu (query) çalıştırılabilir. Sorgu çalıştıran satırlarımız aşağıda verilmiştir:

String sSQL = "select id, firstname, lastname from Employee";

OleDbCommand oCmd = new OleDbCommand(sSQL, oConn);
OleDbDataReader oReader = oCmd.ExecuteReader();

Yukarıdaki 3 satırda sırasıyla bir sorgu cümlesi (query string) girilmiş, bu cümle daha önceden açılmış olan bağlantı üzerinde çalıştırılmış ve son olarak sorgunun sonucunu okumak üzere OleDbDataReader sınıfından (class) bir nesne üretilmiştir.

Üçüncü kısımda bu sorgunun sonucu işlenmektedir.

oReader nesnesinden getOrdinal fonksiyonu ile veritabanımızda bulunan Employee tablosundaki ilgili kolonları (column) bağlayabiliyoruz:

oReader.GetOrdinal("id");

Örneğin yukarıdaki kodda “id” isimli kolon alınmıştır. Daha sonra bu bağlantılar üzerinden satır satır okuma yaparak verileri çekmemiz mümkün. while döngüsünün (loop) içindeki satırlarda da bu şekilde veri çekilerek Console.write komutu ile ekrana basılmaktadır.

91 views

Özellikle veri güvenliği ve veri bütünlüğü (data integrity) konularında kullanılan mesaj özetleri aslında birer özetleme fonksiyonudurlar (hashing functions). Buna göre büyük bir veriden nispeten daha küçük bir özet üretilir ve bu özetten orijinal veriye geri dönülemeyeceği varsayılır.

Mesaj özetlerinden en meşhurları MD5 ve SHA-1 algoritmalarıdır.

MD5 : Message digest (mesaj özeti) kelimelerinin kısaltmasıdır ve 5. Versiyonunu ifade etmektedir.

SHA-1 : Secure Hashing Algorithm (güvenli özetleme algoritması) ise 1. Versiyonudur ve daha önceki 0. Versiyonuna göre daha güvenlidir. Çoğu kaynakta sadece SHA olarak da geçmektedir.

76 views

Bilgisayar bilimlerinin birinci derece uğraştığı varlık veridir. Yani bilgisayar bilimlerinde yapılan her işi bir bakışa göre veriyi işlemek olarak görmek mümkündür. İşlenen bu verinin bütünlüğü ise ayrı bir problemdir. Veri bütünlüğü ile genelde verinin birden fazla parçaya bölünmesi durumunda bu parçaların bütün olarak tutulması kastedilir.

Veri’nin bölünmesi ne zaman gerekir

Günümüzde kullanılan ilişkisel veri tabanlarında veya nesne yönelimli programlama yaklaşımlarında bir bilgi birden fazla parçaya bölünmektedir. Örneğin gerçek hayattaki bir müşteri sipariş formunu (kağıt ile tutulan) ele alalım. Mu formun üzerinde muhtemelen müşterinin iletişim bilgilerini (adres, telefon gibi) istediği ürün bilgilerini (örneğin kitap alacaksa, kitabın ismi fiyatı gibi) ve sipariş bilgilerini (örneğin sipariş tarihi toplam ücreti gibi) görebiliriz.

Ancak ilişkisel veri tabanında (relational database) bu bilgilerin tek bir yerde tutulması teorik olarak doğru kabul edilmez. Normalleştirme (normalisation) teorilerine gore verinin parçalanması (docomposition) gerekmektedir.

Görüldüğü üzere bir veri tabanı modellemesi sırasında veri parçalara bölünmektedir.

Benzer durum nesne yönelimli yaklaşımda da yaşanabilir. Yani veriyi nesneler ile modellemek isteyelim. Her nesne kendisi ile ilgili bilgiyi tutacaktır. Örneğin yukarıdaki örnek için, müşteri ve kitap gibi iki farklı nesne bulunacak ve veri bu nesneler arasında dağıtılacaktır.

Veri bütünlüğünü tehdit eden durumlar

Veri bütünlüğünü tehdit eden birinci durum silme işlemleridir. Yani veriyi modelimiz içinde parçalara böldüğümüzü ve her parçayı başarılı bir şekilde tuttuğumuz düşünelim. Bu bütünün bir parçasını müstakil olarak silersek veri bütünlüğünu tehdit ederiz.

Örneğin yukarıdaki misale devam edelim ve sipariş formundaki bilgileri veri tabanımızdaki üç ayrı tabloya:

• müşteri
• sipariş
• kitap

tablolarına dağıtalım.

Şimdi gidip bir müşteriyi sildiğimizde artık elimizdeki bazı siparişlerin kime ait olduğunu bilmiyoruz. Ya da bir kitabı sildiğimizde bazı müşterilerin hangi kitabı aldığını bilmiyoruz.  İşte bu durum veri bütünlüğünün bozulmasıdır.

Veri bütünlüğü silme işlemi dışında yanlış tasarımdan da bozulabilir. Tasarım hataları verinin tutulması ve işlenmesi sırasında ortaya çıkabilir ancak sonuçta anlatılmak istenen verinin bir kısmına ulaşılamaz olmasıdır.

526 views

Bu yazının amacı JAVA programlama dilinden bir veri tabanına nasıl bağlanılacağını adım adım örnek kod üzerinden açıklamaktır. Uygulamada veri tabanı olarak JavaDB kullanacağız. Bu veritabanı netbeans ile birlikte gelmenin yanında Sun microsystems’in web sitesinden de indirilebilir.

Temel olarak bir programlama dilinden (JAVA veya farklı bir dil) bir veritabanına (database) bağlanmak ve veri almak için aşağıdaki üç adım izlenmelidir:

• Veri tabanına bir bağlantı oluşturmak (connection)
• Bağlantı üzerinden bir sorgunun çalıştırılması
• Sorgunun sonucunun bir veri yapısı (Datastructure) içerisine alınması

Yukarıdaki bu adımları sırasıyla JAVA dilinde ve JavaDB veritabanında gerçekleştirmeye çalışalım.

Veritabanına bağlantı oluşturulması

Bu aşamada ve bundan sonraki veritabanı işlemlerinde JAVA dilinde bulunna java.sql.* paketini kullanıyoruz. Bu paket için

import java.sql.*;

satırını kodumuzun başına ekliyoruz.

Bağlantıyı oluşturmak için java.sql.Connection sınıfından (class) bir nesne (object) oluşturuyoruz. Bu işlem için aşağıdaki satırı kullanabiliriz:

 Connection con = DriverManager.getConnection(
"jdbc:derby://localhost:1527/xyz;user=sadi;password=evren;");

Yukarıdaki satırda con ismi verilen nesne (object) oluşturulmuş ve yerel bilgisayarda (localhost) bulunan “xyz” isimli veritabanına “sadi” kullanıcısı ve “evren” şifresi ile bağlanmaya çalışmıştır.  1527 bilgisayarımızda kurulu olan JavaDB’nin port numarasıdır.

Veritabanında sorgunun çalıştırılması

Veri tabanına yukarıdaki şekilde bağlandıktan sonra istenilen bir sorgu çalıştırılabilir. Bu işlem için de yine java.sql paketinde bulunan Statement sınıfını kullanacağız.

Statement sta = con.createStatement();
ResultSet res = sta.executeQuery(
“SELECT * FROM USERTABLE“);

Yukarıda verilen kod parçasındaki sorgu bir sonuç kümesine (ResultSet) toplanmıştır. Yani yukarıdaki ilk satır ile bağlantımız üzerinde (con nesnesinin bağlantı olduğunu hatırlayalım) bir sorgu çalıştıracak imkan açılmıştır. İkinci satır ile de bu bağlantı üzerinde verilen sorgu çalıştırılarak res ismindeki nesnenin içersine sonuç bilgileri alınmıştır.

Sorgudan alınan sonuç kümesinin (Result Set) işlenmesi

Sorgudan dönen bilgi bir önceki adımda bir ResultSet nesnesinin içerisine atıldı. Bu sınıfın çok farklı fonksiyonları olmakla beraber aşağıdaki örnekte gösterilen kodu çalıştırabiliriz:

 while (res.next()) {
           System.out.println(
           "  "+res.getString("USERNAME")
           + ", "+res.getString("PASSWORD"

           );
}

Yukarıdaki kod örneğinde veri tabanından dönen kümeden “USERNAME” ve “PASSWORD” isimli kolonlar (Veritabanındanki USERTABLE tablosunun kolonları) alınarak ekrana basılmaktadır. Dikkat edilirse bu basma işlemi bir while döngüsü (loop) içerisinde gerçekleşmektedir ve her adımda res.next() fonksiyonu ile kümedeki bir sonraki satır (Tuple) alınmaktadır.

Bağlantının kapatılması

Son olarak JAVA ile veritabanı arasındaki bağlantının kapatılması gerekir. Bu işlem için

con.close();

satırı kullanılabilir.

Tam çalışır kod

Yukarıdaki verilen parçalı ve açıklamalı kodun tamamı aşağıda tek adımda verilmiştir. Yukarıdaki koda ilave olarak çeşitli satırlarda try / catch blokları ile SQLException yakalandığına dikkat ediniz. Bunun sebebi beklenmedik bir durumda JAVA‘nın SQLException catch edilmesini zorunlu tutmasıdır.

import java.sql.*;
/**
 *
 * @author shedai
 */
public class dbAbstract {
    Connection con;
    public void close() {
         try{
              con.close();
         }
         catch(Exception e){}
 }
 public dbAbstract(){
     try{
     con = DriverManager.getConnection(
        "jdbc:derby://localhost:1527/xyz;user=sadi;password=evren;");
     }
     catch(SQLException exp){
        exp.printStackTrace();
     }
 }
 public boolean Authenticate(String User,String Pass){
     try{
          Statement sta = con.createStatement();
          ResultSet res = sta.executeQuery(
          "SELECT * FROM USERTABLE where USERNAME='"+User+"';");
          while (res.next()) {
             if(Pass.equals(res.getString("PASSWORD")))
              return true;
      }
      res.close();
      sta.close();
      return false;
     }catch(SQLException exp){
         exp.printStackTrace();
         return false;
     }
 }
}

Veri Tabanı bağlantısından bilgileri JTAble'a çekerek görsel olarak gösteren kod
Betül Hanımın sorusu üzerine aşağıdaki kodu yazdım ve basitçe veri tabanından veri çekip JFrame içerisindeki bir JTable bileşenine (component) ekliyoruz.

import java.sql.*;
import java.util.Vector;
import javax.swing.JFrame;
import javax.swing.JTable;
/**
 *
 * @author shedai
 */
public class NewClass {
    Connection con;
    public void close() {
         try{
              con.close();
         }
         catch(Exception e){}
 }

 public NewClass(){
     try{
    con = DriverManager.getConnection( "jdbc:mysql://localhost/deneme", "root", "" );  
     }
     catch(SQLException exp){
        exp.printStackTrace();
     }
 }
 JTable jt;
 public void tablo(){
     try{
          Statement sta = con.createStatement();
          ResultSet res = sta.executeQuery(
          "SELECT * FROM persons");
          Vector satirlar = new Vector();
          Vector satir[] = new Vector[2];
          satir[0] = new Vector();
          satir[1] = new Vector();
          int s = 0;
          while (res.next()) {

              for(int i = 1;i<6;i++){
               satir[s].add(res.getString(i));
                System.out.println(res.getString(i));
              }
              s++;

          }
          satirlar.add(satir[0]);
          satirlar.add(satir[1]);
          Vector basliklar = new Vector();
          basliklar.add("id");
          basliklar.add("soyisim");
          basliklar.add("isim");
          basliklar.add("adres");
          basliklar.add("şehir");
          jt = new JTable(satirlar,basliklar);

      res.close();
      sta.close();

     }catch(SQLException exp){
         exp.printStackTrace();

     }
 }
 public static void main(String args[]){
     NewClass nc = new NewClass();
     nc.tablo();
     JFrame jf = new JFrame();
    jf.add(nc.jt);
    jf.setVisible(true);

 }
 }

Öncelikle, hazır yeni bir kod yazıyorken, MySQL bağlantısını da örneklendirmiş olmak için kodu, MySQL sunucusna bağlanan şekilde yazdım. MySQL sunucunda öncelikle deneme isminde bir tablo oluşturduk:

CREATE TABLE IF NOT EXISTS `persons` (
`P_Id` int(11) NOT NULL,
`LastName` varchar(255) NOT NULL,
`FirstName` varchar(255) DEFAULT NULL,
`Address` varchar(255) DEFAULT NULL,
`City` varchar(255) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

Ayrıca tabloya iki adet basit veri ekledim:

INSERT INTO `persons` (`P_Id`, `LastName`, `FirstName`, `Address`, `City`) VALUES
(1, 'seker', 'sadi', 'fasfa af af a', 'ist'),
(2, 'demir', 'ali', 'fasdf af af afa', 'adana');

Yukarıda verdiğim kodda, inşa sınıfında bulunan (constructor) veri tabanı bağlantısı, MySQL bağlantısı olduğu için, ilgili kütüphanenin öncelikle classpath içerisinde tanımlı olması gerekir. Bu kütüphane JDBC üzerinden MySQL bağlantısı kurmaya yarayan sürücü (driver) bilgisini içerir.

Ardından bağlantı kurulduktan sonra yukarıdaki kodda bulunan tablo() fonksiyonumuz veri tabanından ilgili tablonun içeriğini çekerek hem ekrana hem de JTable içerisine basmaktadır. Bu işlem yazının başında verilen ilk örnek koda benzer şekilde bir while döngüsü üzerinden yapılmaktadır.

JTable sınıfının çok sayıdaki inşa fonksiyonlarından (constructor) birisi de, iki adet vektör (vector) almaktadır.

Bu vectorlerden ilki, verileri tutan ve “vector of vector”, yani vektörler vektörü olan veri yapısıyken, ikinci vektör sadece tablo başlıklarını tutmaktadır.

İşlemi kolaylaştırmak ve ileride çok sayıdak satır ile ilgilenmek ihtimalinden dolayı, bir dizi tanımlayıp (satir) her satırı bu dizininin bir elemanına çekiyoruz. Ardından çekilen bu satırları daha üstte tek bir vektörde (satirlar) topluyoruz ve bunu JTable’ın ilk elemanı yapıyoruz.

Son olarak, koddaki, ilk çalışan main fonksiyonuna bakalım. Main fonksiyonunda bir JFrame oluşturulmakta, bu JFrame içerisine de jt isimli, daha önceden tanımlanmış ve tablo() fonksiyonu ile içerisine veri tabanından veri çekilmiş olan JTable yerleştirilmektedir.

Kodun çalışmasının ardından ekran çıktısı aşağıdaki şekildedir:

1,967 views

Gelen bir soru üzerine C# ile MS SQL server’dan veri çekmeyi adım adım kod üzerinden inceleyelim. Öncelikle veri çekmek için gereken adımları sıralayalım:

• Veri tabanına C# dilinde kullanıcı ve şifre ile bir bağlantı oluşturulur.
• Açılan bağlantı üzerinde bir sorgu (Query) çalıştırılır.
• Sorgu (query) sonucu bir veri yapısında (data structures) saklanır. (C# için tercihen datatable)

Şimdi yukarıdaki adımları sırasıyla inceleyelim ve kod üzerinde yazmaya çalışalım.

Veri tabanına CSharp ile bağlantı

Temel olarak bir veri tabanından bir dil vasıtasıyla bilgi çekmek için öncelikle bu veri tabanına dilden bir bağlantı oluşturmak gerekir. Bu bağlantı ODBC (Open Database Connectivity) ismi verilen ve bütün veri tabanlarının desteklediği genel bir bağlantı olabilir veya dile özgü bağlantı (native connection) kullanılabilir. Kısaca dile özgü bağlantı, ODBC’ye göre daha başarılıdır. Bunun sebebi o dil ve o veritabanı arasında özel olarak yazılmış ve iyileştirilmiş olmasıdır.

Bilindiği üzere C# ve MS SQL Server birbirleriyle iyi anlaşan teknolojiler olduğu için aralarında bir dile özgü bağlantı şansı bulunmaktadır. Bu bağlantı bizden sadece veritabanının ismini, IP adresini, kullanıcı ve şifre bilgilerini ister.

Bu bilgileri ilerde değiştirilebilir diye değişkenlerde tanımlıyoruz:

string Server = "localhost";
string Username = "kullanici";
string Password = "sifre";
string Database = "veritabani";

string ConnectionString = "Data Source=" + Server + ";";
ConnectionString += "User ID=" + Username + ";";
ConnectionString += "Password=" + Password + ";";
ConnectionString += "Initial Catalog=" + Database;

string ConnectionString = "Data Source=localhost;User ID=kullanici;Password=sifre;Initial Catalog=Veritabaniismi";

SqlConnection SQLConnection = new SqlConnection();

try
{
    SQLConnection.ConnectionString = ConnectionString;
    SQLConnection.Open();
}
catch (Exception Ex)
{
    // hata oldu kapatiyoruz
    if (SQLConnection != null)
        SQLConnection.Dispose();
    return;
}

string SQLStatement = "SELECT * FROM Tablo";

SqlDataAdapter SQLDataAdapter = new SqlDataAdapter(SQLStatement, SQLConnection);

DataTable dtResult = new DataTable();

SQLDataAdapter.Fill(dtResult);

foreach (DataRow drRow in dtResult.Rows)
{
    MessageBox.Show(drRow["KolonAdi"].ToString());
}

SQLDataAdapter.Dispose();
SQLConnection.Close();
SQLConnection.Dispose();

Yukarıda adım adım anlatılan kodun çalışması için System.Data.* paketinin projeye dahil edilmesi (using) gerekmektedir.

487 views

Latince bölünemez anlamına gelen atom kökünden üretilen bu kelime, bilgisayar bilimlerinde çeşitli alanlarda bir bilginin veya bir varlığın bölünemediğini ifade eder.

Örneğin programlama dillerinde bir dilin atomic (bölünemez) en küçük üyesi bu anlama gelmektedir. Mesela C dilinde her satır (statement) atomic (bölünemez) bir varlıktır.

Benzer şekilde bir verinin bölünemezliğini ifade etmek için de veri tabanı, veri güvenliği veya veri iletimi konularında kullanılabilir.

Örneğin veri tabanında bir işlemin (transaction) tamamlanmasının bölünemez olması gerekir. Yani basit bir örnekle bir para transferi bir hesabın değerinin artması ve diğer hesabın değerinin azalmasıdır (havale yapılan kaynak hesaptan havale yapılan hedef hesaba doğru paranın yer değiştirmesi) bu sıradaki işlemlerin bölünmeden tamamlanması (atomic olması) gerekir ve bir hesaptan para eksildikten sonra, diğer hesapa para eklenmeden araya başka işlem giremez.

Benzer şekilde işletim sistemi tasarımı, paralel programlama gibi konularda da bir işlemin atomic olması araya başka işlemlerin girmemesi anlamına gelir.

Örneğin sistem tasarımında kullanılan check and set fonksiyonu önce bir değişkeni kontrol edip sonra değerini değiştirmektedir. Bir değişkenin değeri kontrol edildikten sonra içerisine değer atanmadan farklı işlemler araya girerse bu sırada problem yaşanması mümkündür. Pekçok işlemci tasarımında buna benzer fonksiyonlar sunulmaktadır.

Genel olarak bölünemezlik (atomicity) geliştirilen ortamda daha düşük seviyeli kontroller ile sağlanır. Örneğin işletim sistemlerinde kullanılan semafor’lar (semaphores), kilitler (locks), koşullu değişkenler (conditional variables) ve monitörler (monitors) bunlar örnektir ve işletim sisteminde bir işlemin yapılması öncesinde bölünmezlik sağlayabilirler.

Kullanılan ortama göre farklı yöntemlerle benzer bölünmezlikler geliştirilebilir. Örneğin veritabanı programlama sırasında koşul (condition) veya kilit (lock) kullanımı bölünmezliği sağlayabilir.

174 views

Veritabanı tasarım şekillerinden birisi olan BCNF, üçüncü normal şekil ile (third normal form, 3NF) karşılaştıırlabilir. Yapı olarak normal şekillerde üst sayıdaki normal şekiller, alt normal şekilleri kapsar. Yani 2. normal şekilde olan bütün veri tabanı tasarımları 1. normal şekilde ve benzer şekilde 3. normal şekilde olan bütün veri tabanı tasarımları 2. normal şekilde kabul edilebilir.

Bu durumda BCNF şeklinde olan veritabanı tasarımları da 1. , 2. ve 3. normal şekillerin şartlarını sağlamak zorundadır.

BCNF ile3NF arasındaki farkı şu şekilde açıklayabiliriz:

Veri tabanı tasarımında A → B şeklinde bir functional bağlılık bulunuyorsa (functional dependency), bu bağımlılıktaki B birincil anahtar olmak zorundadır. 3NF tasarımında A anahtarı bir aday anahtar (candidate key) olmak zorunda değildir ancak BCNF şeklinde bunun tersine A →  B şeklindeki bir fonksiyonel bağımlılık durumunda A bir aday anahtar olmalıdır.

Bu durumu aşağıdaki örnek üzerinden anlamaya çalışalım. Örneğin 3. normal şekilde olan aşağıdaki tabloyu ele alalım:

Yukarıdaki tablodaki fonksiyonel bağımlılıklar aşağıdaki şekilde sıralanabilir:

1. FD1   “Müşteri No”, “Görüşme Tarihi” → “Görüşme Saati”, “Personel No”, “Oda No”      (Birincil Anahtar, Primary Key)
2. FD2   “Personel No”, “Görüşme Tarihi”, “Görüşme Saati” →  “Müşteri No”         (Adah Anahtar, Candidate key)
3. FD3   “Oda No”, “Görüşme Tarihi”, “Görüşme Saati” → “Müşteri No”, “Personel No”     (Aday Anahtar, Candidate key)
4. FD4   “Personel No”, “Görüşme Tarihi” → “Oda No”     (Aday anahtar DEĞILDIR)

Yukarıdaki fonksiyonel bağımlılıklardan 4.’sü bir aday anahtar değildir. Dolayısıyla veri bütünlüğü (data integrity) açısından sorun olabilir. Örneğin herhangi bir personel için oda değişikliği veri tabanından birden fazla değişikliğin kontrolünü gerektirir.

Örneğin SG5 personeli, B301 odasındadır, bu personelin odasının değişmesi durumunda veri tabanında ya veri bütünlüğü sorunu olur ya da birden fazla erişim gerekir.

Bu sorunun çözümü olarak BCNF şeklinde olan aşağıdaki iki tabloya bölünmesi gerekir:

ikinci bir tablo ile de toplantılar tutulabilir:

1,129 views