מנוע מסד נתונים בפייתון: יישום אינדקס B-tree - צלילה עמוקה

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

הבנת עצי B

לפני שנצלול לפרטי היישום, הבה נבסס הבנה מוצקה של עצי B. עץ B הוא מבנה נתונים עץ המתאזן את עצמו, השומר על נתונים ממוינים ומאפשר חיפושים, גישה סדרתית, הכנסות ומחיקות בזמן לוגריתמי. בניגוד לעצי חיפוש בינאריים, עצי B מתוכננים במיוחד לאחסון מבוסס דיסק, שבו גישה לבלוקי נתונים מהדיסק איטית משמעותית מגישה לנתונים בזיכרון. להלן פירוט של מאפייני B-tree מרכזיים:

• נתונים ממוינים: עצי B מאחסנים נתונים בסדר ממוין, מה שמאפשר שאילתות טווח יעילות ואחזורים ממוינים.
• איזון עצמי: עצי B מתאימים את מבנם באופן אוטומטי כדי לשמור על איזון, ולהבטיח שפעולות חיפוש ועדכון יישארו יעילות גם עם מספר גדול של הכנסות ומחיקות. זה מנוגד לעצים לא מאוזנים שבהם הביצועים עלולים לרדת לזמן לינארי בתרחישים הגרועים ביותר.
• מונחה דיסק: עצי B מותאמים לאחסון מבוסס דיסק על ידי מזעור מספר פעולות ה-I/O של הדיסק הנדרשות עבור כל שאילתה.
• צמתים: כל צומת בעץ B יכול להכיל מפתחות ומצביעים לילדים מרובים, הנקבעים על ידי סדר העץ (או מקדם הפיצוח).
• סדר (מקדם פיצוח): סדר עץ B קובע את המספר המרבי של ילדים שיכולים להיות לצומת. סדר גבוה יותר בדרך כלל מביא לעץ רדוד יותר, מה שמפחית את מספר הגישות לדיסק.
• צומת שורש: הצומת העליון ביותר של העץ.
• צמתי עלה: הצמתים ברמה התחתונה של העץ, המכילים מצביעים לרשומות נתונים אמיתיות (או מזהי שורות).
• צמתים פנימיים: צמתים שאינם צומת שורש או עלה. הם מכילים מפתחות המשמשים כמפרידים להדרכת תהליך החיפוש.

פעולות B-tree

מספר פעולות יסוד מתבצעות על עצי B:

• חיפוש: פעולת החיפוש עוברת דרך העץ מהשורש לעלה, מודרכת על ידי המפתחות בכל צומת. בכל צומת, מצביע הילד המתאים נבחר על סמך ערך מפתח החיפוש.
• הכנסה: הכנסה כרוכה במציאת צומת העלה המתאים להכנסת המפתח החדש. אם צומת העלה מלא, הוא מתפצל לשני צמתים, והמפתח האמצעי מקודם לצומת ההורה. תהליך זה עשוי להתפשט כלפי מעלה, ועלול לפצל צמתים עד השורש.
• מחיקה: מחיקה כרוכה במציאת המפתח למחיקה והסרתו. אם הצומת הופך להיות תת-מלא (כלומר, מכיל פחות מהמספר המינימלי של מפתחות), מפתחות נשאבים מצומת אח או ממוזגים עם צומת אח.

יישום פייתון של אינדקס B-tree

כעת, בואו נצלול ליישום פייתון של אינדקס B-tree. נתמקד ברכיבי הליבה ובאלגוריתמים המעורבים.

מבני נתונים

ראשית, אנו מגדירים את מבני הנתונים המייצגים צמתי B-tree ואת העץ הכולל:

class BTreeNode:
    def __init__(self, leaf=False):
        self.leaf = leaf
        self.keys = []
        self.children = []

class BTree:
    def __init__(self, t):
        self.root = BTreeNode(leaf=True)
        self.t = t  # דרגה מינימלית (קובעת את המספר המרבי של מפתחות בצומת)

בקוד הזה:

• BTreeNode מייצג צומת בעץ B. הוא מאחסן אם הצומת הוא עלה, את המפתחות שהוא מכיל, ומצביעים לילדיו.
• BTree מייצג את מבנה עץ B הכולל. הוא מאחסן את צומת השורש ואת הדרגה המינימלית (t), המכתיבה את מקדם הפיצוח של העץ. t גבוה יותר בדרך כלל מוביל לעץ רחב יותר ורדוד יותר, שיכול לשפר ביצועים על ידי הפחתת מספר הגישות לדיסק.

פעולת חיפוש

פעולת החיפוש עוברת באופן רקורסיבי בעץ B כדי למצוא מפתח ספציפי:

def search(node, key):
    i = 0
    while i < len(node.keys) and key > node.keys[i]:
        i += 1
    if i < len(node.keys) and key == node.keys[i]:
        return node.keys[i]  # מפתח נמצא
    elif node.leaf:
        return None  # מפתח לא נמצא
    else:
        return search(node.children[i], key)  # חפש באופן רקורסיבי בילד המתאים

פונקציה זו:

• עוברת על המפתחות בצומת הנוכחי עד שהיא מוצאת מפתח גדול או שווה למפתח החיפוש.
• אם מפתח החיפוש נמצא בצומת הנוכחי, הוא מחזיר את המפתח.
• אם הצומת הנוכחי הוא צומת עלה, זה אומר שהמפתח לא נמצא בעץ, ולכן הוא מחזיר None.
• אחרת, הוא קורא באופן רקורסיבי לפונקציה search בצומת הילד המתאים.

פעולת הכנסה

פעולת ההכנסה מורכבת יותר, כרוכה בפיצול צמתים מלאים לשמירה על איזון. להלן גרסה פשוטה:

def insert(tree, key):
    root = tree.root
    if len(root.keys) == (2 * tree.t) - 1:  # השורש מלא
        new_root = BTreeNode()
        tree.root = new_root
        new_root.children.insert(0, root)
        split_child(tree, new_root, 0)  # פצל את השורש הישן
        insert_non_full(tree, new_root, key)
    else:
        insert_non_full(tree, root, key)

def insert_non_full(tree, node, key):
    i = len(node.keys) - 1
    if node.leaf:
        node.keys.append(None) # פנה מקום למפתח החדש
        while i >= 0 and key < node.keys[i]:
            node.keys[i + 1] = node.keys[i]
            i -= 1
        node.keys[i + 1] = key
    else:
        while i >= 0 and key < node.keys[i]:
            i -= 1
        i += 1
        if len(node.children[i].keys) == (2 * tree.t) - 1:
            split_child(tree, node, i)
            if key > node.keys[i]:
                i += 1
        insert_non_full(tree, node.children[i], key)

def split_child(tree, parent_node, i):
    t = tree.t
    child_node = parent_node.children[i]
    new_node = BTreeNode(leaf=child_node.leaf)
    parent_node.children.insert(i + 1, new_node)
    parent_node.keys.insert(i, child_node.keys[t - 1])
    new_node.keys = child_node.keys[t:(2 * t - 1)]
    child_node.keys = child_node.keys[0:(t - 1)]
    if not child_node.leaf:
        new_node.children = child_node.children[t:(2 * t)]
        child_node.children = child_node.children[0:t]

פונקציות מפתח בתהליך ההכנסה:

• insert(tree, key): זוהי פונקציית ההכנסה הראשית. היא בודקת אם צומת השורש מלא. אם כן, היא מפצלת את השורש ויוצרת שורש חדש. אחרת, היא קוראת ל-insert_non_full כדי להכניס את המפתח לעץ.
• insert_non_full(tree, node, key): פונקציה זו מכניסה את המפתח לצומת שאינו מלא. אם הצומת הוא צומת עלה, היא מכניסה את המפתח לצומת. אם הצומת אינו צומת עלה, היא מוצאת את צומת הילד המתאים להכנסת המפתח. אם צומת הילד מלא, היא מפצלת את צומת הילד ולאחר מכן מכניסה את המפתח לצומת הילד המתאים.
• split_child(tree, parent_node, i): פונקציה זו מפצלת צומת ילד מלא. היא יוצרת צומת חדש ומעבירה חצי מהמפתחות והילדים מצומת הילד המלא לצומת החדש. לאחר מכן היא מכניסה את המפתח האמצעי מצומת הילד המלא לצומת ההורה ועדכנית את מצביעי הילדים של צומת ההורה.

פעולת מחיקה

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

שיקולי ביצועים

הביצועים של אינדקס B-tree מושפעים רבות מכמה גורמים:

• סדר (t): סדר גבוה יותר מפחית את גובה העץ, מה שממזער פעולות I/O של הדיסק. עם זאת, הוא גם מגדיל את טביעת הרגל של הזיכרון של כל צומת. הסדר האופטימלי תלוי בגודל בלוק הדיסק ובגודל המפתח. לדוגמה, במערכת עם בלוקי דיסק בגודל 4KB, ניתן לבחור 't' כך שכל צומת ימלא חלק משמעותי מהבלוק.
• I/O של דיסק: צוואר הבקבוק העיקרי של הביצועים הוא I/O של הדיסק. מזעור מספר הגישות לדיסק חיוני. טכניקות כמו שמירת צמתים נגישים תכופות בזיכרון יכולות לשפר משמעותית את הביצועים.
• גודל מפתח: גדלי מפתח קטנים יותר מאפשרים סדר גבוה יותר, מה שמוביל לעץ רדוד יותר.
• מקביליות: בסביבות מקביליות, מנגנוני נעילה נאותים חיוניים להבטחת שלמות הנתונים ומניעת תנאי מרוץ.

טכניקות אופטימיזציה

מספר טכניקות אופטימיזציה יכולות לשפר עוד יותר את ביצועי עץ B:

• Caching: שמירת צמתים נגישים תכופות בזיכרון יכולה להפחית משמעותית את I/O של הדיסק. ניתן להשתמש באסטרטגיות כמו Least Recently Used (LRU) או Least Frequently Used (LFU) לניהול המטמון.
• חציצת כתיבה: איגום פעולות הכתיבה וכתיבתם לדיסק בגושים גדולים יותר יכול לשפר את ביצועי הכתיבה.
• Pre-fetching: צפייה בתבניות גישת נתונים עתידיות ו-pre-fetching של נתונים למטמון יכולים להפחית את השהיה.
• דחיסה: דחיסת מפתחות ונתונים יכולה להפחית את שטח האחסון ועלויות ה-I/O.
• יישור דפים: הבטחת שצמתי B-tree מיושרים עם גבולות דפי דיסק יכולה לשפר את יעילות ה-I/O.

יישומים בעולם האמיתי

עצי B משמשים באופן נרחב במערכות מסדי נתונים ומערכות קבצים שונות. להלן מספר דוגמאות בולטות:

• מסדי נתונים יחסיים: מסדי נתונים כמו MySQL, PostgreSQL ו-Oracle מסתמכים בכבדות על עצי B (או וריאציות שלהם, כמו עצי B+) לאינדוקס. מסדי נתונים אלה משמשים במגוון עצום של יישומים ברחבי העולם, מפלטפורמות מסחר אלקטרוני למערכות פיננסיות.
• מסדי נתונים NoSQL: מסדי נתונים NoSQL מסוימים, כמו Couchbase, משתמשים בעצי B לאינדוקס נתונים.
• מערכות קבצים: מערכות קבצים כמו NTFS (Windows) ו-ext4 (Linux) משתמשות בעצי B לארגון מבני ספרייה וניהול מטא-נתונים של קבצים.
• מסדי נתונים משובצים: מסדי נתונים משובצים כמו SQLite משתמשים בעצי B כשיטת האינדוקס העיקרית שלהם. SQLite נמצא באופן נפוץ באפליקציות מובייל, מכשירי IoT וסביבות מוגבלות במשאבים אחרים.

שקול פלטפורמת מסחר אלקטרוני הממוקמת בסינגפור. הם עשויים להשתמש במסד נתונים MySQL עם אינדקסי B-tree על מזהי מוצרים, מזהי קטגוריות ומחירים כדי לטפל ביעילות בחיפושי מוצרים, גלישת קטגוריות וסינון מבוסס מחיר. אינדקסי B-tree מאפשרים לפלטפורמה לאחזר במהירות מידע רלוונטי על מוצרים, גם עם מיליוני מוצרים במסד הנתונים.

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

עצי B+: וריאציה נפוצה

וריאציה פופולרית של עץ B היא עץ B+. ההבדל המרכזי הוא שב-עץ B+, כל רשומות הנתונים (או מצביעים לרשומות נתונים) מאוחסנות בצמתי העלים. צמתים פנימיים מכילים רק מפתחות להדרכת החיפוש. מבנה זה מציע מספר יתרונות:

• גישה סדרתית משופרת: מכיוון שכל הנתונים נמצאים בעלים, הגישה הסדרתית יעילה יותר. צמתי העלים מקושרים לעיתים קרובות יחד ליצירת רשימה סדרתית.
• fanout גבוה יותר: צמתים פנימיים יכולים לאחסן יותר מפתחות מכיוון שהם אינם צריכים לאחסן מצביעי נתונים, מה שמוביל לעץ רדוד יותר ופחות גישות לדיסק.

רוב מערכות מסדי הנתונים המודרניות, כולל MySQL ו-PostgreSQL, משתמשות בעיקר בעצי B+ לאינדוקס בגלל יתרונות אלה.

סיכום

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

להמשך למידה, חקור משאבים על עצי B+, בקרת מקביליות בעצי B, וטכניקות אינדוקס מתקדמות.