1 חישוב של אופרטורים רלציוניים evaluation of relational operators
Post on 19-Dec-2015
234 views
TRANSCRIPT
1
חישוב של אופרטורים רלציוניים
Evaluation of Relational Operators
2
שאילתות של יעיל חישוב
שאילתות מתורגמות לביטוי אלגברי •שאותו יש לחשב
נדרש:•חישוב יעיל של כל אופרטור בביטוי•תוכנית ביצוע יעילה לחישוב הביטוי •
3
לדוגמאות יחסיםנתונים שני יחסים•
Sailors(sid:integer, sname:string, rating:integer, age:real)Reserves(sid:integer, bid:integer, day:dates, rname:string)
Reservesרשומת • בתים, 40באורך • רשומות בדף 100• דפים1000ב-•
Sailorsרשומת • בתים, 50באורך • רשומות בדף 80• דפים500ב-•
sid פירושוsailor idbid פירושוboat idsid הוא מפתח שלSailors
sid,bid,day הוא מפתח שלReserves
rname הוא שם המזמין )לאו(sidדווקא השם של
4
הבחירה פעולת לביצוע שיטות
5
אחד תנאי עם בחירה פעולת
A op c(R) רוצים לחשב ביטויים מהצורה:•R אטריביוט של Aכאשר ••op= ,> הוא אופרטור כגון •cהוא קבוע
לדוגמא, רוצים לחשב את השאילתה •* SELECTהבאה
FROM Reserves R
WHERE R.rname = ‘Joe’
6
, סדר אין אינדקס אין
ניתן לבצע את החישוב על ידי סריקה של •היחס
דפים, נדרש מחיר של Mאם ביחס יש • דפיםMקריאת
בדוגמא מהשקף הקודם, המחיר הוא • דפים1000קריאת
7
, סדר יש אינדקס אין
, אז ניתןA ממוין לפי אטריביוט Rאם היחס • למצוא את הרשומה הראשונה שמקיימת את •
התנאי על ידי חיפוש בינארילהמשיך כל עוד הרשומות מקיימות את התנאי•
המחיר:• log(M) + #pages with tuples from the
result
8
+Bשימוש באינדקס מסוג עץ לצורך ביצוע פעולת בחירה
9
+Bשימוש באינדקס מבוסס עץ
R של Aנניח שקיים אינדקס על עמודה •+Bהממומש כעץ
מוצאים כניסה ראשונה בעץ שתואמת את •תנאי החיפוש
ממשיכים לעבור באופן סדרתי על העלים •של האינדקס כל עוד הערכים מקיימים את
תנאי החיפושמביאים את הרשומות המתאימות מהקובץ•
10
דוגמה
על ’rname>‘Cמבצעים בחירה עם התנאי •Reserves
בהנחת התפלגות אחידה, מספר הרשומות ביחס •Reserves:שעונות על התנאי הוא
2/26 10% 10,000 tuples הרשומות הללו 10,000נתוני הכניסה של •
מאוחסנים ברצף במספר קטן של עלי האינדקסלכל נתון כניסה, קוראים את הדף המתאים של •
היחס
11
, אז מקובץ האינדקס אם
נתוני כניסה סמוכים זה לזה מצביעים על רשומות •Reservesשנמצאות באותו דף של היחס
הרשומות של היחס שעונות על 10,000לכן, • רשומות בדף(100 דפים )יש 100התנאי תופסות
הדפים נקרא לתוך 100בנוסף, כל אחד מ- •הזיכרון הפנימי )לחוצץ( פעם אחת בלבד
דפים 100לפיכך אם האינדקס מקובץ, קוראים •Reservesמהיחס
12
דף כל קוראים מדוע? בלבד אחת פעם
היחס • של דף מהדיסק לראשונה שקוראים נניחהתנאי על שעונה רשומה בו שיש
• , שמופיע מסוים כניסה נתון עבור נקרא זה דףהאינדקס של העלים באחד
• , כניסה נתון לאחר מיד מקובץ שהאינדקס מכיווןשאר כל עבור הכניסה נתוני ברצף מופיעים זה
הדף מאותו לקרוא שיש הרשומותלקרוא • צורך ואין הפנימי בזיכרון כבר הדף אבל
שוב אותו
13
, אז מקובץ אינו האינדקס אם
נתוני כניסה סמוכים זה לזה מצביעים על רשומות •Reservesשנמצאות בדפים שונים של היחס
הרשומות של 10,000לכן במקרה הגרוע ביותר, • 10,000היחס שעונות על התנאי נמצאות ב-
דפים שונים דפים1,000 יש Reservesאבל ביחס •לכן הרשומות שעונות על התנאי נמצאות ב- •
דפים שונים לכל היותר1,000
14
כמה דפים של היחס?מהדיסקצריך לקרוא
Reservesכאמור, הרשומות של היחס • דפים 1,000שעונות על התנאי נמצאות ב-
שונים לכל היותראבל במקרה הגרוע ביותר, קוראים דף •
מהדיסק עבור כל רשומה שעונה על התנאי לפיכך אם האינדקס אינו מקובץ, קוראים •
דפים של היחס 10,000במקרה הגרוע ביותר Reserves
15
של רשומות שמכיל דף כל מדוע? פעמים הרבה נקרא התוצאה
נניח שעבור נתון כניסה מסוים, דף של היחס •נקרא לראשונה מהדיסק
מכיוון שהאינדקס אינו מקובץ, מיד לאחר נתון •כניסה זה מופיעים נתוני כניסה עבור רשומות
שנמצאות על דפים אחריםלכן הדף שכבר נמצא בזיכרון מפנה את מקומו •
לדפים אחריםכשמגיעים שוב לנתון כניסה המתייחס לאותו •
הדף, צריך לקרוא את הדף שנית מהדיסק
16
לשפר אפשר
על • שעונים הכניסה נתוני כל את קוראים תחילההדף מספר לפי אותם וממיינים התנאי
הממוין • הסדר לפי הדפים את קוראים השני בשלב• ) ביותר ) הגרוע במקרה לקרוא שיש הדפים מספר
, לא אבל התנאי על שעונות הרשומות כמספר הואביחס הדפים ממספר יותר
• , לקרוא, שיש הדפים מספר הזה השיפור עם לפיכךהוא ביותר הגרוע 1,000במקרה
• , סדרתי באופן היחס על לעבור שעדיף יתכן השיפור למרות) באינדקס) שימוש בלי
17
? מהאינדקס לקרוא צריך דפים כמהמכל רמה, חוץ מרמת העלים, קוראים לכל היותר דף •
אחדיש סיכוי טוב שהדפים של הרמות העליונות כבר נמצאים בחוצץ •
)קרי, בזיכרון הפנימי(
יש +Bבכל מקרה, לרוב האינדקסים המבוססים על עץ •מספר קטן של רמות
הרשומות בעלים של אינדקס הן קצרות ויכולות להיות •אלפי רשומות בדף אחד
לפיכך, מספר הרשומות שקוראים מהאינדקס הוא בדר"כ •בסדר גודל פחות ממספר הרשומות שיש לקרוא מהיחס
עצמו )אין זה משנה אם האינדקס מקובץ או לא(
18
ערבול באינדקס שימושבחירה פעולת ביצוע לצורך
19
(Hashשימוש באינדקס ערבול )אינדקס ערבול מתאים לצורך חישוב שאילתות •
בחירה כאשר התנאי הוא שוויון גישות לדיסק2-1מציאת הדלי המתאים: כ- •
( של מבנה הערבול directoryקריאה של השורש )•)קריאה זו נחסכת אם השורש כבר בזיכרון הפנימי(
קריאה נוספת של הדלי המתאים•סביר להניח שאין יותר מדלי אחד שמתאים לשוויון )אחרת, •
עדיף שלא להשתמש בקובץ ערבול, כדי להימנע מ- overflow)
קריאת הדפים של היחס לפי נתוני הכניסה •שנמצאים בדלי ומקיימים את השוויון
20
דוגמה
לפי Reservesנניח שיש בחירה מהיחס • ’rname=‘Joeהתנאי
נניח שיש אינדקס ערבול לא מקובץ על •rname
Joe הזמנות שנעשו על ידי 100נניח שיש • Reservesלפיכך, צריך לשלוף מהיחס •
רשומות100
21
הדוגמה המשך
הרשומות שצריך לשלוף מהיחס 100•Reservesנמצאות
דפים שונים100במקרה הגרוע ביותר ב- •ובמקרה הטוב ביותר בדף אחד )כזכור, דף של •
רשומות(100היחס מכיל
גישות 102 ל-2כלומר, בסכ"ה יהיו בין • גישות לקובץ העירבול(2-1לדיסק )כולל
22
הטלה לביצוע שיטות
23
הטלה לביצוע שיטות
חישוב הטלה דורש מעבר על הקובץ•הורדת אטריביוטים לא רצויים•הורדת כפילויות•
הורדת כפילויות על ידי •שימוש במיון•(hashingשימוש בערבול )•
אפשר לבצע רק באמצעות אינדקס, •במקרה של הטלה על עמודות שכולן נכללות במפתח החיפוש של האינדקס
24
צירוף לחישוב שיטות
25
דוגמה
הבאה • השאילתה את לחשב מעונינים
SELECT *
FROM Reserves R, Sailors S
WHERE R.sid = S.sid
26
נאיבית חישוב שיטת
• Simple Nested-Loops Join
foreach tuple r of of R do
foreach tuple s of S do
if ri == sj then
add <r,s> to result
27
עלות הערכת
pR ונניח S בלוקים ב-N ו-R בלוקים ב-Mנניח •S רשומות לבלוק ב-pS ו-Rרשומות לבלוק ב-
M + pR*M*Nעלות החישוב: •לא כולל המחיר של כתיבת התוצאה לדיסק•
בדוגמה של השייטים:• 1,000 + 100*1,000*500 = 1,000 + 5*107
I/Os זמן קריאת בלוק מהדיסק, 10msבהנחה של •
שעות לביצוע החישוב!140יידרשו כ-
28
לחישוב עיקריות שיטותיחסים שני של הצירוף
צירוף היא הפעולה האלגברית היקרה •ביותר וקיימות עבורה מספר שיטות חישוב
שונות:•Block Nested-Loops Join•Index Nested-Loops Join•Sort-Merge Join•Hash Join
להלן, נתאר את כל אחת מארבעת •השיטות האלו
29
כשיש הצירוף מקום חישוב מספיקהיחסים משני לאחד הפנימי בזיכרון
S ו- Rרוצים לחשב את הצירוף הטבעי של • בשלמותו Rאם יש מספיק זיכרון, קרא את •
לזיכרון, קרא את הבלוק לזיכרון Sלכל בלוק של •
וחשב את הצירוף של הרשומות מבלוק זה Rעם כל הרשומות של
כתוב את התוצאה לדיסק וקרא את הבלוק •Sהבא של
30
הנדרשת הפנימי הזיכרון כמות
שני • מבין הקטן של הבלוקים מספר2היחסים +
השני • היחס לקריאת אחד בלוקהתוצאה • לכתיבת שני בלוק
• , לדיסק אותו כותבים מתמלא כשהואמחדש למלאו ומתחילים
31
כולל חישוב זמן
•BR -בלוקים ב R -ו BS -בלוקים ב S נקרא פעם אחתS ו- Rכל בלוק של •כל בלוק של התוצאה נכתב פעם אחת•BR + BS + output size :זמן כולל•נתעלם מהזמן הדרוש לכתיבת התוצאה, •
כי הוא זהה בכל השיטות BR + BSלכן הזמן הוא •
32
משני אחד כל אם עושים מה? הפנימי מהזיכרון גדול היחסים
בלוקים Bבזיכרון הפנימי יש • בלוקיםB-2 בחלקים – כל פעם Rקרא את •, בלוק S, קוראים את כל Rעבור כל חלק של •
אחד בכל פעם Sחשב את הצירוף של הרשומות מהבלוק של •
שנמצא בזיכרוןRעם הרשומות מהחלק של איטרציות שבהן קוראים את ceil(BR /(B-2))יש •
נקרא פעם אחתR, בעוד ש- Sכל BR + BS * ceil(BR /(B-2))הזמן הנדרש הוא •
33
הערה
BR + BS * ceil(BR /(B-2))הזמן הוא •
האם עדיף שבלולאה החיצונית יהיה •היחס הקטן או היחס הגדול?
תשובה: היחס הקטן )מדוע?(•
34
למעשה תיארנו זה עתה את Block Nested-Loops Joinהשיטה
• Suppose that there are B buffer pagesforeach block of B-2 pages of R do
foreach page of S do {
for all matching in-memory
pairs r, s:
add <r,s> to result
}
35
שלדוגמה להערכת העלות Block Nested-Loops Join
block nested-loops joinמשתמשים ב-•לחישוב הצירוף מהדוגמה הקודמת תוך
מקומות לדפים בזיכרון 102שימוש ב- ביחס החיצוני Reservesבהנחה ש-•
Reserves גישות לקריאת 1,000נדרשות • מעבר על כל Reserves בלוקים של 100לכל •
מעברים על 10, לכן בסה"כ Sailorsהיחס בלוקים500 ובכל מעבר קוראים Sailorsהיחס
I/Os 6,000 = 500*10 + 1,000סך הכל •
36
העלות הערכת המשך
בלולאה החיצונית נדרשוReservesכאשר •1,000 + )1,000/100(*500 = 6,000 I/Os
בלולאה החיצונית יידרשוSailorsכאשר •500 + )500/100(*1,000 = 5,500 I/Os
, 10msבהנחה שקריאת בלוק אורכת •תידרש קצת יותר מדקה לחישוב הצירוף!
37
Index Nested-Loops Join
על אחד האטריביוטים Sנניח שיש אינדקס של •R עם Sשלפיהם מבצעים את הצירוף של
למציאת הרשומות משתמשים באינדקס•המתאימות!
foreach tuple r of R
foreach tuple s of S where ri=sj
add <r,s> to result
38
אינדקס בעזרת צירוף חישוב
עם )R)A,Bחישוב צירוף של •S)B,C( כאשר יש אינדקס על עמודה
B של S: ולכל רשומה מהבלוקRקרא בלוק של •
מצא בעזרת האינדקס את כל • Sהרשומות המתאימות של
פעם אחת בלבדRהערה: קוראים את •
39
עלות הערכת
את X, נסמן ע"י Rבהינתן רשומה של •הזמן הנדרש כדי למצוא את כל
Sהרשומות המתאימות של
מס' BR + tRX( tRהזמן הכולל •(Rהרשומות ב-
40
?Xמהו
נניח שהאינדקס מכיל נתוני כניסה מהצורה•(k, rid)
kגם אם יש הרבה נתוני כניסה עם אותו •עדיין סביר להניח שכולם על בלוק אחד,
bשיקרא 1.2באינדקס ערבול צריך, בממוצע, לקרוא •
bבלוקים כדי להגיע לבלוק 4-2, צריך לקרוא +Bבאינדקס, שהוא עץ •
bבלוקים כדי להגיע לבלוק
41
Xהמשך החישוב של
Sצריך לקרוא גם את הרשומות עצמן מהיחס •אם האינדקס מקובץ, אפשר להניח )שבדר"כ( •
ולכןSכולן על בלוק אחד של Sצריך לקרוא בלוק אחד של •
אם האינדקס אינו מקובץ, אז כל רשומה • נמצאת על בלוק נפרד, ומספר Sמתאימה של למספר שצריך לקרוא שווה Sהבלוקים של שמתאימות לרשומה אחת של Sהרשומות של
R )נתאר בהמשך איך להעריך מספר זה(
42
לדוגמה
אם מדובר באינדקס ערבול מקובץ, אז •X=2.2והזמן הכולל הוא
BR + 2.2tR
BR + BS * ceil(BR / (B-2))לעומת •
Block Nested-Loops Joinבשיטה של
43
דוגמה להערכת העלות של Index Nested-Loops Join
sid יש אינדקס ערבול על Sailorsנניח שליחס ••sid מפתח של Sailors ולכן לכל רשומת
Reserves יש לפחות רשומה מתאימה אחת )למעשה, בדיוק אחת – למה?(Sailorsמהיחס
בלוקים1,000 דורשת קריאת Reservesסריקת • רשומות ביחס 100,000 = 1,000*100יש •
Reserves, החיפוש באינדקס דורש Sailorsלכל רשומה של •
בלוקים 1.2לקרוא בממוצע
44
הדוגמה המשך
סך כל העלות הנדרשת:•1,000 + 100,000 * 2.2 = 221,000 I/Os
סך כל הזמן הנדרש, בהנחה שקריאת • דקות35, הוא כ- 10msבלוק אורכת
45
נוספת דוגמה
sid יש אינדקס ערבול על Reservesנניח שליחס • בלוקים500 דורשת קריאת Sailorsסריקת •Sailors רשומות ב-40,000 = 500*80יש • שייטים – בהנחה 40,000 הזמנות ל-100,000יש •
הזמנות לשייט2.5שההתפלגות אחידה: בהנחה שהאינדקס אינו מקובץ:•
500 + 40,000*)1.2 + 2.5( = 148,500 I/Os דקות25החישוב ידרוש כ- •
46
Sort-Merge Join
ע"י )B,C(S עם )R)A,Bחישוב צירוף של •Sort-Merge Join:
ואז ממזגים:Bממיינים כ"א מהיחסים על •R.B >= S.B עד ש- Rעוברים על •S.B >= R.B עד ש- Sעוברים על •חוזרים על שני הצעדים הקודמים עד ש- •
R.B = S.B ואז קוראים לזיכרון את כל , B ששווים על S וכל החלק של Rהחלק של
ומחשבים את הצירוף בין שני חלקים אלה
47
sidsnameratingage
22dustin745
28yuppy935
31lubber855
36lubber636
44guppy535
58rusty1035sidbiddayagent
2810312/4/96Joe
2810311/3/96Frank
3110110/2/96Joe
3110212/7/96Sam
3110113/7/96Sam
5810322/6/96Frank
Reserves
Sailors
48
זמן החישוב של צירוף ע"י Sort-Merge Join
זמן למיון:• BRlogBR + BSlogBS
זמן למיזוג )תחת איזה הנחה?(• BR + BS
סה"כ:• BR + BS + BRlogBR + BSlogBS
49
דוגמה
דורשReservesמיון •1000 log 1000 10,000 I/Os
דורשSailorsמיון •500 log 500 4,500 I/Os
I/Os 1,500 = 500 + 1,000צירוף: • 16,000 = 1,500 + 4,500 + 10,000סה"כ: •
I/Osהזמן שנדרש יהיה פחות משלוש דקות•על ידי שימוש בשיטות מיון טובות, ניתן להקטין את •
עלות החישוב לפחות מחצי העלות המחושבת כאן
50
Hash Join
חלקים B-1מבצעים חלוקה של שני יחסי הקלט ל- •ע"י הפעלת פונקצית ערבול על ערכי האטריביוטים
שלפיהם נעשה הצירוף יכולות i שמופו לקבוצה Rעל פי החלוקה, רשומות של •
i שאף הן מופו ל-Sלהתחבר רק לרשומות של
בזו אחר זו וכל Rקוראים את קבוצות החלוקה של •קבוצה מחלקים לתת קבוצות )שנשמרות בזיכרון
שונה הראשי( בעזרת פונקצית ערבול חדשה )!(מהראשונה
קוראים את הקבוצות Sלכל קבוצת חלוקה של • ומנסים למצוא התאמות Rהמתאימות של
51
Hash-Join Algorithm
//Partition R into k partitions
foreach tuple r in R do
read r and add it to buffer page h(ri)
//flush buffer page when it fills
//Partition S into k partitions
foreach tuple s in S do
read s and add it to buffer page h(sj)
//flush buffer page when it fills
52
Hash-Join Algorithm )cont’d(
//Probing phase
for l = 1..k
//Build in-memory hash table for Rl
//using h2(ri)
foreach tuple r in partition Rl do read r and insert into hash table
using h2(ri)
//Scan Sl and probe for matching Rl tuples foreach tuple s in partition Sl do
read s and probe table using h2(sj) output matching pairs <r,s>
53
Hash Join• Partition both
relations using hash fn h: R tuples in partition i will only match S tuples in partition i
• Read in a partition of R, hash it using h2 (<> h!). Scan matching partition of S, search for matches
Partitionsof R & S
Input bufferfor Si
Hash table for partitionRi (k < B-1 pages)
B main memory buffersDisk
Output buffer
Disk
Join Result
hashfnh2
h2
B main memory buffers DiskDisk
Original Relation OUTPUT
2INPUT
1
hashfunction
h B-1
Partitions
1
2
B-1
. . .
54
B main memory blocks DiskDisk
Original Relation OUTPUT
2INPUT
1
hashfunction
h B-1
Partitions
1
2
B-1
. . .
Partition R & S using h
55
Partitionsof R & S
Input bufferfor Si
Hash table for partitionRi (k < B-1 pages)
B main memory blocksDisk
Output buffer
Disk
Join Result
hashfnh2
h2
Read partition Ri & partition it using h2
Partition Si is joined with Ri
56
Hash Joinהמחיר של
אם יש מספיק מקום בזיכרון וה- •Partitions הן פחות או יותר בגודל
שווה, אז בשלב הראשון קוראים וכותבים כל יחס •
פעם אחת בלבדובשלב השני קוראים כל יחס פעם אחת•
(BR + BS)3לכן המחיר הכולל הוא •
57
השייטים בדוגמת
Reserves בלוקים של 1,000עבור • יידרשוSailors בלוקים של 500ו-
3(1,000 + 500 = )4,500 I/Os 45במקרה זה, לביצוע הצירוף יידרשו כ-•
שניות
58
כמות הזיכרון הנדרשת לביצוע Hash Join
בלוקים בזיכרון אז מספר ה- Bאם יש •Partitions הוא לכל היותר k=B-1
הואPartitionלכן הגודל של כל •בלוקים לכל לכן צריך בשלב השני•
Partition כאשר ,f הוא מקדם גדול , כי בשלב השני צריך לייצר מבנה 1מ-
hash לפי h2 -וזה דורש קצת יותר מ B-1בלוקים
1B
BR
1B
fBR
59
המשך חישוב כמות הזיכרון Hash Joinהנדרשת לביצוע
בלוקיםכאמור, בשלב השני צריך• בלוקים וצריך גם אחד Bיש בסך הכל •
לכתיבת התוצאה ואחד לקריאת היחס השני, ולכן
R בלוקים, כאשר לפיכך, צריך •היחס הקטן יותר
21
B
fBB R
1B
fBR
RfBB
לא בגודל Partitionsלמעשה צריך קצת יותר, כי ה- שווה
60
-שיטה משופרת לSort-Merge Join )SMJ(
שלוקחת SMJ -יש שיטה משופרת ל•)hash join: 3)BR + BSאותו זמן כמו
בלוקים שיטה זאת דורשת • הוא הגדול משני Sבזיכרון, כאשר
(12היחסים )פרטים בפרק •SMJ מייצרת תוצאה ממוינת וזמן
worst caseהחישוב הוא
sBB
61
סיכום
צירוף • לחישוב שונות שיטות ראינויחסים שני של
החישוב • זמן עבור נוסחה שיטה לכלטובה • הכי תמיד שהיא שיטה אין