B+-Trees (PART 1) What is a B+ tree? Why B+ trees? Searching a B+ tree Insertion in a B+ tree NOTE: SOME EXAMPLES IN THIS LECTURE ARE ADOPTED FROM INTERNET SOURCES

What is a B+ tree? A B+-tree of order M ≥ 3 is an M-ary tree with the following properties: Leaves contain data items or references to data items all are at the same depth each leaf has L/2 to L data or data references (L may be equal to, less or greater than M; but usually L << M) Internal nodes contain searching keys The keys in each node are sorted in increasing order each node has at least M/2 and at most M subtrees The number of search keys in each node is one less than the number of subtrees key i in an internal node is the smallest key in subtree i+1 Root can be a single leaf, or has 2 to M children Node are at least half-full, so that the tree will not degenerate into simple binary tree or even link list 2

The internal node structure of a B+ tree Each leaf node stores key-data pair or key-dataReference pair. Data or data references are in leaves only. Leaves form a doubly-linked list that is sorted in increasing order of keys. Each internal node has the following structure: j a1 k1 a2 k2 a3 … kj aj+1 j == number of keys in node. ai is a reference to a subtree. ki == smallest key in subtree ai+1 and > largest key in subtree ai. k1 < k2 < k3 < . . . < kj 3

What is a B+ tree? Example: A B+ tree of order M = 5, L = 5 Records or references to records are stored at the leaves, but we only show the keys here At the internal nodes, only keys (and references to subtrees) are stored Note: The index set (i.e., internal nodes) contains distinct keys 4

What is a B+ tree? Example: A B+ tree of order M = 4, L = 4 Note: For simplicity the doubly linked list references that join leaf nodes are omitted 5

Why B+ trees? Like a B-tree each internal node and leaf node is designed to fit into one I/O block of data. An I/O block usually can hold quite a lot of data. Hence, an internal node can keep a lot of keys, i.e., large M. This implies that the tree has only a few levels and only a few disk accesses can accomplish a search, insertion, or deletion. B+-tree is a popular structure used in commercial databases. To further speed up searches, insertions, and deletions, the first one or two levels of the B+-tree are usually kept in main memory. The reason that B+ trees are used in databases is, unlike B-trees, B+ trees support both equality and range-searches efficiently: Example of equality search: Find a student record with key 950000 Example of range search: Find all student records with Exam grade greater than 70 and less than 90

Why B+ trees ? (Cont’d) A B+ tree supports equality and range-searches efficiently Index Entries Data Entries ("Sequence set") (Direct search) 7

B+ Trees in Practice For a B+ tree of order M and L = M, with h levels of index, where h  1: The maximum number of records stored is n = (M – 1)h The space required to store the tree is O(n) Inserting a record requires O(logMn) operations in the worst case Finding a record requires O(logMn) operations in the worst case Removing a (previously located) record requires O(logMn) operations in the worst case Performing a range query with k elements occurring within the range requires O(logMn + k) operations in the worst case. Example for a B+ tree of order M = 134 and L = 133: A tree with 3 levels stores a maximum of 1333 = 2,352,637 records A tree with 4 levels stores a maximum of: 1334 = 312,900,700 records 8

Searching a B+ Trees Searching KEY: Start from the root If an internal node is reached: Search KEY among the keys in that node linear search or binary search If KEY < smallest key, follow the leftmost child reference down If KEY >= largest key, follow the rightmost child reference down If Ki <= KEY < Kj, follow the child reference between Ki and Kj If a leaf is reached: Search KEY among the keys stored in that leaf If found, return the corresponding record; otherwise report not found

Searching a B+ Trees In processing a query, a path is traversed in the tree from the root to some leaf node. If there are K search-key values in the file, the path is no longer than  logm/2(K). With 1 million search key values and m = 100, at most log50(1,000,000) = 4 nodes are accessed in a lookup. 10

Insertion in B+ Trees Suppose that we want to insert a key K and its associated record into the B+ tree. A B+ tree has two OVERFLOW CONDITIONS: A leaf-node overflows if after insertion it contains L + 1 keys A root-node or an internal node of a B+ tree of order M overflows if, after a key insertion, it contains M keys. Insertion algorithm: Search for the appropriate leaf node x to insert the key. Note: Insertion of a key always starts at a leaf node. If the key exists in the leaf node x, report an error, else Insert the key in its proper sorted order in the leaf node If the leaf does not overflow (If x contains less than L+1 keys after insertion), the insertion is done, else If a leaf node overflows, split it into two, COPY the smallest key y of right splinted node to the parent of the node (Records with keys < y go to the left leaf node. Records with keys >= y go to the right leaf node). If the parent overflows, split the parent into two (keys < middle key go to the left node. keys > middle key go to the right node. The middle key PROPAGATES to the parent of the splinted parent. The process propagates upward until a parent that does not overflow is reached or the root node is reached. If the root node is reached and it overflows, create a new root node. 11

Insertion in B+ Trees: No overflow Insert KEY: Search for KEY using search operation If the key is found in a leaf node report an error Insert KEY into that leaf If the leaf does not overflow (contains <= L keys), just insert KEY into it If the leaf overflows (contains L+1 keys), splitting is necessary An example of inserting O into a B+ tree of order M = 4, L = 3. Search for O; this leaf has 2 keys. Insert O and maintain the order. 12

Insertion in B+ Trees: Splitting a Leaf Node If the leaf overflows (contains L+1 keys after insertion), splitting is necessary Splitting leaf: Split it into 2 new leaves LeftLeaf and RightLeaf LeftLeaf has the (L+1) / 2 smallest keys RightLeaf has the remaining (L+1) / 2 keys Make a copy of the smallest key in RightLeaf, say MinKeyRight, to be the parent of LeftLeaf and RightLeaf [COPY UP] Insert MinKeyRight, together with LeftLeaf and RightLeaf, into the original parent node An example of inserting T into a B+ tree of order M = 4 and L= 3 Overflow Search for T; this leaf has 3 keys. 13

Insertion in B+ Trees: Splitting Leaf (Cont’d) xL xR Split the leaf (xL gets (L+1)/2 keys, xR gets  (L+1)/2) keys , takes the minimum key in xR be the parent of xL and XR. Make S the parent of the two new leaves, and insert S to the parent. Since the parent only has 2 keys (U, Y), we can insert the subtree rooted at S to it. Insert S into the parent. Maintain the order of keys and child references (DONE). 14

Insertion in B+ Trees: Splitting Internal Node An insertion in a full parent node causes the parent to overflow, in that case this internal node must be split. Splitting internal node: Split it into 2 new internal nodes LeftNode and RightNode LeftNode has the smallest M/2 -1 keys RightNode has the largest M/2 keys  NumberOfKeys in LeftNode <= NumberOfKeysInRightNode Note that the M/2 th key is not in either node. Make the M/2 th key, say “MiddleKey”, to be the parent of LeftNode and RightNode [PROPAGATE UP] Insert “MiddleKey”, together with LeftNode and RightNode, into the original parent node Splitting root: Follow exactly the same procedure as splitting an internal node “MiddleKey”, the parent of LeftNode and RightNode, is now set to be the root of the tree After splitting the root, the depth of the tree increases by 1 15

Insertion in B+ Trees An example of inserting M into a B+ tree of order M= 4 and L = 3 Search for M; this leaf has 3 keys. Insert M and B+ tree condition is violated. Split the leaf and distribute the keys. 16

Insertion in B+ Trees Split the leaf and distribute the keys. Make L the parent of the two new leaves. However, we cannot just insert L into the parent as it is already full. Insert L and its child references into the parent. 17

Insertion in B+ Trees xL xR Since the parent is not full, we can just insert the subtree rooted at J to the parent  Done. The key J becomes the parent of the two internal nodes. Insert J into the next parent. 18

Insertion in B+ Trees Insert 16 then 8 in the following B+ tree of order M = 5, L = 4: Note: A * in a leaf node key indicates a key-dataReference pair Root 13 17 24 30 2* 3* 5* 7* 8* 14* 15* 16* overflow! 2* 5* 7* 3* 17 24 30 13 8* One new child (leaf node) generated; must add one more reference to its parent, thus one more key value as well. 19

Insertion in B+ Trees Inserting 8* (cont.) Copy up the middle value (leaf split) 13 17 24 30 Entry to be inserted in parent node. 5 (Note that 5 is s copied up and continues to appear in the leaf.) 2* 3* 5* 7* 8* overflow! 5 13 17 24 30 20

Insertion in B+ Trees 5 13 17 24 30 We split this node, redistribute entries evenly, and propagate up middle key.  appears once in the index. Contrast Entry to be inserted in parent node. this with a leaf split.) 5 24 30 17 13 (Note that 17 is pushed up and only 21

Insertion in B+ Trees Root 17 5 13 24 30 2* 3* 5* 7* 8* 14* 15* 19* 20* 22* 24* 27* 29* 33* 34* 38* 39* Notice that root was split, leading to increase in height. 22

Inserting a Data Entry into a B+ Tree: Summary Find correct leaf X. Put data entry onto X. If X has enough space, done! Else, must split X (into X and a new node X2) Redistribute entries evenly, put middle key in X2 copy up middle key. Insert reference (index entry) refering to X2 into parent of X. This can happen recursively To split index node, redistribute entries evenly, but push (propagate) up middle key. (Contrast with leaf splits.) Splits “grow” tree; root split increases height. Tree growth: gets wider or one level taller at top. 23