1. phantom kaydı nedir? Açıklayınız.
Phantom kaydı, bir hareketin yapmış olduğu --diğer çelişen hareketlerden saklı olan- bir eklemedir.
Örneğin T hareketi, eşzamanlı çalışan T’ hareketinin belirli bir şarta göre okuduğu kayıtlara, o şartı
sağlayan bir kayıt ekliyor olsun. T ve T’ harketleri mantıksal olarak çelişiyorlar fakat bu çelişkiyi
yakalamak (ve senkronize etmek) gerekiyor. Eğer, plan <T, T’> sırasına denk bir plan olursa T’ yeni
gelen kaydı değerlendirebilir. T hareketi yeni kaydı W ile kilitledi; T’ buna R kilit ile bakmak için
bekliyor. Burda bir sorun yok. Diğer taraftan, <T’,T> sırasına denk bir plan da ise T’ yeni gelen
kaydı göremeyecektir. Bu ikinci planda; T’, şartı sağlayan kayıtları okurken bir kayıt aniden ortaya
çıktı. Oysa burda çelişen bir durum yok, fakat T’ hareketi devam ederken gördüğü görüntü değişti!
T’ bir kez daha şartı sağlayan kayıtlara baksa, (T commit olup çıkarsa; yani W kilidini bırakırsa)
farklı sayıda tuple ile neticelenecek. Ortaya çıkan bu kayda “phantom kayıt” deniyor. Bu phantom
kaydı, eklenen yeni kayıt W kilit ile eklenmiş olmasına rağmen mevcut R kilitleri ile çelişemiyor. Bu
yüzden çelişkiyi yakalayamadık.
Hareket süresince aynı sorgunun tekrar çalışmasında farklı sayıda tuple ile neticelenmesi bir
PhantomRead problemidir. Bununla beraber, bir hareket süresince okunan bir tuple’ın tekrar
okunmasında farklı değerler alınması non-repeatable read problemidir. Aşağıdaki problem tipik
bir Phantom Read problemidir.
/* Query 1 */
SELECT * FROM users
WHERE age BETWEEN 10 AND 30;
/* Query 2 */
INSERT INTO users VALUES ( 3, 'Bob', 27 );
COMMIT;
/* Query 1 */
SELECT * FROM users
WHERE age BETWEEN 10 AND 30;
Sciori’nin kitabında Phantom problemi daha basit tanımlanmış. Ona göre de basit bir çözüm
önerilmiş. Orada append() ve size() operasyonlarının çelişkisinden bahsediliyor. Örneğin, append()
operasyonu içeren bir T1 ile eşzamanlı olan T2 operasyonu sürekli size() operasyonunu çalıştırsın.
Burdada yukarıdaki örneğe benzer şekilde <T1,T2> sırasında bir sorun olmuyor. Ancak T1, T2’nin
iki size() operasyonu arasında append ederse bu ACID-izolasyonuna aykırı bir durumdur. Sciori
bunun için basit bir çözüm göstermiş size() ve append() opresyonları EOF işaretçisinin kilitleme ile
çalışabilmeleri problemi çömektedir. (size() için slock(EOF); append() için xlock(EOF) gerekiyor)
Oysa Elmasri’nin tanımladığı ANSI’ye daha uygun olan Phantom Read probleminde (ilk paragrafta
anlatılan genel durum) append ve size operasyonları olmasına gerek yok. Eğer tanesellik kayıt
seviyesinde ise; Tablodaki bir bloktaki boş alanlara kayıtlar eklenebilir. Bu (daha doğru olan) tanıma
göre; eğer tanesellik block veya daha yukarısı ise Phantom okuma mümkün olmayacaktır. Fakat
block taneselliği çok iri olduğundan eşzamanlılık az, false conflict çoktur. (Bu arada sadece INSERT
operasyonu Phantom problemine sabebp olur. DELETE olamaz; çünkü okunan kayıt üzerinde R
kilit olduğu için, W gerektiren silme yapilamayacaktır. )
Phantom probleminin genel çözümü için 3 farklı yöntemden bahsediliyor: (Sciori probemin daha
basit bir halini tarif edif daha basit bir çözüm önermiş) bunlar Index Lock, Predicate Lock ve “kayıt
ekleme/çıkarmada dosya taneselliğinde XL kullanmak”. Burdaki üçüncü yöntem oldukça basittir;
gerçeklenmesi için MGL (multi-granularity lock protokolü olmalıdır)
*****************************************************
2. phantom problemi indeks kilitleri ile nasıl çözülür?
Index Lock’da, çelişki indeks bloğu üzerinde yakalanabilir. Kayıt ekleme ve okumaların indeks
üzerinden olduğunu varsayarsak aynı şartları sağlayan bu kayıtlara erişim ve aynı şartı sağlayan bir
kayıt ekleme indekste aynı yaprak düğüm üzerinden olacaktır. O zaman bu düğümdeki R ve W
kilitlerinin çelişkisi yakalanabilir.
*****************************************************
3. predicate lock (yüklem kilitleme) ne demektir?
Predicate Lock(Range Lock):
Select cümlesinin yüklemi, tablodaki bir tuple setini ifade eder. SQL sorgu veya ekleme
cümlesindeki yüklem üzerine R veya W kilidi alabiliriz. Bu kilitlerin çelişkili olması için: Bir kilit W
olmalı ve her iki yüklemi de sağlayan bir tuple mecut olmalı. Örneğin;
Audit:
NewAccount:
SELECT SUM (balance)
FROM Accounts
WHERE name = ‘Mary’
INSERT INTO Accounts
VALUES (‘123’,‘Mary’,100)
Audit hareketi (name=’Mary’) için R kilidi; NewAccount hareketi ise (acctnum=‘123’ 
name=‘Mary’  bal=100) W kilidi ister. Yüklemler de ortak tuple olduğu için Phantom
olmayacaktır.
SELECT SUM (balance)
FROM Accounts
WHERE name = ‘Mary’
DELETE
FROM Accounts
WHERE bal < 100
Yukarıda ise (name=’Mary’) için R kilidi; bal < 100 için W kilidi gerekli. Bal<100 olup Mary isimli
bir tuple olabilir; o yüzden çelişki yakalanır.
SELECT SUM (balance)
FROM Accounts
WHERE name = ‘Mary’
DELETE
FROM Accounts
WHERE name = ‘John’
Yukarıda ise (name=’Mary’) için R kilidi; (name=’John’) için W kilidi gerekli. Bunların çelişkisi
mümkün değil.
Predicate Lock pratikte gerçeklenmesi çok mümkün olmayan bir yöntemdir.
Download

indir