1. 1 חישוב ואופטימיזציה של שאילתות חלק 2 Query Evaluation and Optimization Part 2

2. 2 שיטות לחישוב צירוף R(A,B) ⋈ S(B,C) אם יש מספיק זיכרון, קרא את R בשלמותו לזיכרון לכל בלוק של S, קרא את הבלוק לזיכרון וחשב את הצירוף של הרשומות מבלוק זה עם כל הרשומות של R כתוב תוצאה לדיסק וקרא הבלוק הבא של S

3. 3 כמות הזיכרון הנדרשת מספר הבלוקים של הקטן מבין שני היחסים + 2 בלוק אחד לקריאת היחס השני בלוק שני לכתיבת התוצאה  כשהוא מתמלא, כותבים אותו לדיסק ומתחילים למלאו מחדש

4. 4 זמן חישוב כולל B R בלוקים ב - R ו - B S בלוקים ב - S כל בלוק של R ו - S נקרא פעם אחת כל בלוק של התוצאה נכתב פעם אחת זמן כולל : B R + B S + output size נתעלם מהזמן הדרוש לכתיבת התוצאה, כי הוא זהה בכל השיטות לכן הזמן הוא B R + B S

5. 5 מה עושים אם כל אחד משני היחסים גדול מהזיכרון הפנימי ? בזיכרון הפנימי יש B בלוקים קרא את R בחלקים – כל פעם B-2 בלוקים עבור כל חלק של R, קוראים את כל S, בלוק אחד בכל פעם חשב את הצירוף של הרשומות מהבלוק של S עם הרשומות מהחלק של R שנמצא בזיכרון יש איטרציות שבהן קוראים את כל S, בעוד ש - R נקרא פעם אחת הזמן הנדרש הוא

6. 6 הערה הזמן הוא לכן עדיף שהיחס הקטן יותר הוא זה שיקרא בחלקים, כלומר בלולאה החיצונית השיטה הזאת נקראת Block Nested-Loops Join

7. 7 חישוב R(A,B) ⋈ S(B,C) כאשר יש אינדקס על עמודה B של S קרא בלוק של R ולכל רשומה מהבלוק מצא בעזרת האינדקס את כל הרשומות המתאימות של S קוראים את R פעם אחת בלבד בהינתן רשומה של R, נסמן ע " י X את הזמן הנדרש כדי למצוא את כל הרשומות המתאימות של S הזמן הכולל (t R מס ' הרשומות ב - R) השיטה נקראת Index Nested-Loops Join

8. 8 מהו X? נניח שהאינדקס מכיל נתוני כניסה מהצורה (k, rid) גם אם יש הרבה נתוני כניסה עם אותו k עדיין סביר להניח שכולם על בלוק אחד, שיקרא b באינדקס ערבול צריך, בממוצע, לקרוא 1.2 בלוקים כדי להגיע לבלוק b באינדקס B+ צריך לקרוא 4-2 בלוקים כדי להגיע לבלוק b

9. 9 המשך החישוב של X צריך לקרוא גם את הרשומות עצמן מהיחס S אם האינדקס מקבץ, אפשר להניח ( שבדר " כ ) כולן על בלוק אחד של S ולכן צריך לקרוא בלוק אחד של S אם האינדקס אינו מקבץ, אז כל רשומה מתאימה של S נמצאת על בלוק נפרד, ומספר הבלוקים של S שצריך לקרוא שווה למספר הרשומות של S שמתאימות לרשומה אחת של R ( נתאר בהמשך איך להעריך מספר זה )

10. 10 לדוגמה אם מדובר באינדקס ערבול מקבץ, אז X=2.2 והזמן הכולל הוא לעומת בשיטה של Block Nested-Loops Join

11. 11 חישוב של R(A,B) ⋈ S(B,C) ע " י Sort-Merge Join ממיינים כ " א מהיחסים על B ואז ממזגים : עוברים על R עד ש- R.B >= S.B עוברים על S עד ש- S.B >= R.B חוזרים על שני הצעדים הקודמים עד ש- R.B = S.B, ואז קוראים לזיכרון את כל החלק של R וכל החלק של S ששווים על B ומחשבים את הצירוף בין שני חלקים אלה

12. 12 זמן החישוב של R(A,B) ⋈ S(B,C) ע " י Sort-Merge Join זמן למיון זמן למיזוג ( תחת איזה הנחה ?) סה " כ

13. 13 Hash-Join Partition both relations using hash fn h: R tuples in partition i will only match S tuples in partition i. v Read in a partition of R, hash it using h2 (<> h!). Scan matching partition of S, search for matches. Partitions of R & S Input buffer for Si Hash table for partition Ri (k < B-1 pages) B main memory buffers Disk Output buffer Disk Join Result hash fn h2 B main memory buffers Disk Original Relation OUTPUT 2 INPUT 1 hash function h B-1 Partitions 1 2 B-1...

14. 14 Hash Join Partition both relations using hash function 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

15. 15 B main memory blocks Disk Original Relation OUTPUT 2 INPUT 1 hash function h B-1 Partitions 1 2 B-1... Partition R & S using h

16. 16 Partitions of R & S Input buffer for Si Hash table for partition Ri (k < B-1 pages) B main memory blocks Disk Output buffer Disk Join Result hash fn h2 Read partition Ri & partition it using h2 Partition Si is joined with Ri

17. 17 המחיר של Hash Join אם יש מספיק מקום בזיכרון וה - Partitions הן פחות או יותר בגודל שווה, אז בשלב הראשון קוראים וכותבים כל יחס פעם אחת בלבד ובשלב השני קוראים כל יחס פעם אחת לכן המחיר הכולל הוא 3(B R + B S )

18. 18 כמות הזיכרון הנדרשת לביצוע Hash Join אם יש B בלוקים בזיכרון אז מספר ה - Partitions הוא לכל היותר k=B-1 לכן הגודל של כל Partition הוא לכן צריך בשלב השניבלוקים לכל Partition, כאשר f הוא מקדם גדול מ - 1, כי הדליים אינם 100% מלאים

19. 19 המשך חישוב כמות הזיכרון הנדרשת לביצוע Hash Join כאמור, בשלב השני צריך בלוקים יש בסך הכל B בלוקים וצריך גם אחד לכתיבת התוצאה ואחד לקריאת היחס השני, ולכן לפיכך, צריך בלוקים, כאשר R היחס הקטן יותר למעשה צריך קצת יותר, כי ה- Partitions לא בגודל שווה

20. 20 שיטה משופרת ל - Sort-Merge Join (SMJ) יש שיטה משופרת ל - SMJ שלוקחת אותו זמן כמו hash join: 3(B R + B S ) שיטה זאת דורשת בלוקים בזיכרון, כאשר S הוא הגדול משני היחסים ( פרטים בפרק 12) SMJ מייצרת תוצאה ממוינת וזמן החישוב הוא worst case

21. 21 סיכום עד כה ראינו שיטות שונות לחישוב צירוף של שני יחסים לכל שיטה נוסחה עבור זמן החישוב אין שיטה שהיא תמיד הכי טובה בספר בפרק 12 ( בשקפים פרק 12, חלק B), מתוארות שיטות לחישוב הפעולות האלגבריות האחרות

22. 22 עקרונות לחישוב ביטוי כללי : 1. הקטנת יחסים בשאילתה כללית יש מספר פעולות וצריך למצוא את שיטת החישוב הזולה ביותר של כלל הפעולות יחסים קטנים יותר ⇐ זמן חישוב מהיר יותר משתמשים בשקילויות אלגבריות, כדי להקטין יחסים בשלב מוקדם ככל האפשר ע " י דחיפת בחירה והטלה

23. 23 דוגמה  AC (  B=5 (R(A,B) ⋈ S(B,C) ⋈ T(C,D))) נדחוף בחירה והטלה פנימה, ככל האפשר תחילה נחשב R’(A,B) = (  B=5 (R(A,B)) S’(B,C) = (  B=5 (S(B,C)) T’(C) =  C (T(C,D)) ואז נחשב  AC (R’(A,B) ⋈ S’(B,C) ⋈ T’(C))

24. 24 2. מבצעים פעולות בחירה והטלה on the fly תוצאת ביניים צריך לכתוב על דיסק ואח " כ לקרוא שוב להמשך החישוב, ולכן זה מייקר מאוד את זמן החישוב פעולות בחירה ( שנוגעות ליחס אחד בלבד ) מבצעים כאשר קוראים יחס זה לראשונה בחירה שכוללת מספר יחסים (R.A = S.D) מבצעים כחלק מפעולת הצירוף הטלות מבצעים כאשר מייצרים תוצאות של צירוף ( וכשהדבר אפשרי, מבצעים הטלה כשקוראים יחס בפעם הראשונה )

25. 25 דוגמה  AC (  B=5 (R(A,B) ⋈ S(B,C) ⋈ T(C,D))) נדחוף בחירה והטלה פנימה, ככל האפשר תחילה נחשב R’(A,B) = (  B=5 (R(A,B)) S’(B,C) = (  B=5 (S(B,C)) T’(C) =  C (T(C,D)) ואז נחשב  AC (R’(A,B) ⋈ S’(B,C) ⋈ T’(C)) 1.תוך כדי קריאת R ו- S מבצעים בחירה 2.תוך כדי קריאת T מבצעים הטלה תוך כדי כתיבת התוצאה הסופית שוב מבצעים הטלה

26. 26 3. לא מבצעים מכפלה קרטזית צריך למצוא את הסדר היעיל ביותר לחישוב פעולות הצירוף בודקים את המחיר של כל סדר אפשרי, במטרה למצוא את הסדר הזול ביותר אבל מתעלמים מסדר שכולל מכפלה קרטזית, אלא אם כן השאילתה דורשת לחשב מכפלה קרטזית

27. 27 דוגמה  AC (  B=5 (R(A,B) ⋈ S(B,C) ⋈ T(C,D))) האפשרויות לחישוב הביטוי הנ " ל הן R(A,B) ⋈ (S(B,C) ⋈ T(C,D)) (R(A,B) ⋈ S(B,C)) ⋈ T(C,D) (R(A,B) ⋈ T(C,D)) ⋈ S(B,C) אבל האפשרות השלישית כוללת מכפלה קרטזית ולכן מתעלמים ממנה

28. 28 4. פעולות צירוף מבצעים בשיטת ה - Pipe Line כדי להימנע מכתיבת תוצאות ביניים, מזרימים, חלק חלק, את התוצאה של פעולת צירוף לתהליך החישוב של פעולת הצירוף הבאה כזכור, פעולות בחירה והטלה מתבצעות on the fly עם פעולות הצירוף

29. 29 דוגמה נניח שמחשבים את הביטוי (R(A,B) ⋈ S(B,C)) ⋈ T(C,D) מחשבים חלק מהתוצאה של הצירוף הראשון, ומשתמשים בחלק זה כדי להתחיל לחשב את הצירוף השני כאשר החישוב של הצירוף השני מסתיים עבור החלק הראשון, מחשבים חלק נוסף של הצירוף הראשון

30. 30 5. בודקים רק אפשרויות שהן Left-Deep עקרונית צריך לעבור על כל האפשרויות לחישוב סדרה של פעולות צירוף למעשה עוברים רק על אפשרויות שבהן מצרפים, בכל שלב, תוצאת ביניים ( של שלב קודם ) עם יחס ממסד הנתונים

31. 31 דוגמה מביאים בחשבון את הסדר (R(A,B) ⋈ S(B,C)) ⋈ T(C,D)) ⋈ P(D,E)) אבל כדי לצמצם את מרחב החיפוש, מתעלמים מהסדר הבא (R(A,B) ⋈ S(B,C)) ⋈ (T(C,D) ⋈ P(D,E))

32. 32 הסיבות למעבר רק על אפשרויות שהן Left Deep מצמצם את מרחב החיפוש מאפשר לבצע חישוב שהוא fully pipelined, כלומר כותבים לדיסק רק את התוצאה הסופית ( ואין צורך לרשום לדיסק שום דבר בשלבי ביניים ), זאת בתנאי ש - משתמשים בשיטות של Nested-Loops Joins מאפשר ניצול מקסימלי של אינדקסים הקיימים עבור היחסים של מסד הנתונים

33. 33 אלגוריתם תכנות דינמי למעבר על כל מרחב האפשרויות נמצא דרך אופטימלית לצירוף של n יחסים R 1 ⋈ R 2 ⋈ … ⋈ R n בשלב ה - i מחשבים, לכל תת - קבוצה של i יחסים, את המחיר האופטימלי של צירוף היחסים בתת - קבוצה זו בשלב ה - i+1 מגדילים כל תת - קבוצה ע " י הוספת יחס נוסף, ומחשבים את המחיר האופטימלי של תת - הקבוצה החדשה, שמתבסס על המחיר שחושב בשלב הקודם

34. 34 המחיר האופטימלי לתת - קבוצה המחיר האופטימלי לתת - קבוצה {R 1, R 2, R 4 } נקבע לפי הסדר האופטימלי לביצוע פעולות הצירוף של היחסים בתת-הקבוצה שיטה ספציפית לביצוע כ"א מפעולות הצירוף, כך שהמחיר הכולל הוא הנמוך ביותר לכן, צריך לעבור על כל הסדרים האפשריים ולכל סדר אפשרי לעבור על כל האפשריות לביצוע של פעולות הצירוף

35. 35 כיצד פועלת השיטה של התכנות הדינמי כדי לקבוע את התוכנית האופטימלית לתת - קבוצה {R 1, R 2, R 3, R 4 } בוחרים את התוכנית האופטימלית מבין האפשרויות הבאות התוכנית האופטימלית עבור {R 2, R 3, R 4 } כאשר מוסיפים לה בשלב האחרון צירוף עם R 1 התוכנית האופטימלית עבור {R 1, R 3, R 4 } כאשר מוסיפים לה בשלב האחרון צירוף עם R 2 התוכנית האופטימלית עבור {R 2, R 1, R 4 } כאשר מוסיפים לה בשלב האחרון צירוף עם R 3 התוכנית האופטימלית עבור {R 2, R 3, R 1 } כאשר מוסיפים לה בשלב האחרון צירוף עם R 4

36. 36 אבל לא מספיק לחשב רק את המחיר האופטימלי לכל תת - קבוצה (R(A,B) ⋈ S(B,C)) ⋈ T(B,D) יתכן ש - sort-merge join של R ו - S אינו היעיל ביותר, אבל הוא מייצר תוצאה שממוינת על B אם גם T ממוין על B, אז הצירוף עם T זול עד כדי כך, שהמחיר הכולל הוא הזול ביותר

37. 37 לכל תת - קבוצה מחשבים מחיר עבור כל סדר מעניין עבור תת - קבוצה של i יחסים, מחשבים את מחיר הצירוף לכל אפשרות שמייצרת את התוצאה ממוינת על אטריביוט ( ים ) כלשהו כמו כן, אם המחיר של האפשרות, שמייצרת תוצאה ללא סדר כלשהו, הוא הזול ביותר, אז שומרים לשלב הבא גם את המחיר הזה

38. 38 דוגמה (R(A,B) ⋈ S(B,C)) ⋈ T(C,D) ⋈ P(B,D) מחשבים את המחיר של sort-merge join של R ו - S, כי הוא מייצר תוצאה ממוינת על B אם S ממוין על C, אז מוצאים גם את המחיר הזול ביותר לחישוב הצירוף של R ו - S, מבין כל האפשרויות ( אם יש כאלה ) שמשאירות את התוצאה ממוינת על C אם hash join הוא הזול ביותר, אז משאירים גם את המחיר שלו לשלב הבא

39. 39 שלב 1 של האלגוריתם בשלב 1 של האלגוריתם מחשבים לכל יחס את המחיר של כל האפשרויות לקרוא את היחס מהדיסק, תוך שימוש באינדקסים או במעבר סדרתי על כל היחס

40. 40 סיום האלגוריתם בסיום מקבלים את המחירים האופטימליים לחישוב הצירוף של כל היחסים, עבור כל הסדרים המעניינים מחשבים את השאילתה לפי האפשרות שנותנת את המחיר הזול ביותר