B+ Trees COMP 261 2015

(Can't fit all the nodes on slide) B Trees Example of a B tree with m = 5 nodes contain 3..5 children 2..4 values Maximally full depth 3 tree (Can't fit all the nodes on slide) DC FZ MA TB AN BB BZ CT DP DY EF EY GB GY HM JK NB NO OP QA TF TZ UC VB DF DG DL DM DQ DS DT DV DZ EA EB EE EH EM EN ES EZ FA FT FX

Traversing a B Tree Listing all the items in order is a bit messy: Have to constantly return to higher nodes. DC FZ MA TB AN BB BZ CT DP DY EF EY TF TZ UC VB DF DG DL DM DQ DS DT DV DZ EA EB EE EH EM EN ES EZ FA FT FX

Sets versus Key-Value pairs What are the items we are storing? Set: B-Tree contains a set of values Only need to store the values you are searching on. Map / Dictionary / database table B-Tree contains a set of key-value pairs Search down the tree governed only by the keys Need to store each value with its key ⇒ B-tree nodes can't have as many keys ⇒ lower branching factor ⇒ deeper trees If node is of fixed capacity and value is large (eg, a whole record from a database table) then may only fit a very few key-value pairs in a node.

keys and child pointers B+ Trees The most commonly used variant of B Trees. Intended for storing key–value (or key–record) pairs. Leaves contain key-value pairs, Keys are repeated in the internal nodes. Internal nodes contain keys, but no values. Leaves are linked to enable traversal keys and child pointers k …… k k k … k-v k-v k-v k-v k-v k-v keys and values

K0-V0, K1-V1, K2-V2, …, Kleaf.size-1-Vleaf.size-1 B+ Trees: Leaves Each leaf node contains between maxL /2 and maxL key-value pairs, a link to the next leaf in the tree For each key Ki in the leaf : Ki < Ki+1 The value might be either the actual associated value (if it is small) the index of a data block where value can be found (maybe in another file) K0-V0, K1-V1, K2-V2, …, Kleaf.size-1-Vleaf.size-1

B+ Trees: Internal Nodes Except root may have fewer Each internal node contains between maxN /2 and maxN keys, and up to maxN +1 child node indexes Branching factor = maxN +1 For each key X in the subtree at Ci : Ki ≤ X < Ki+1 Ki will the be the leftmost key in the subtree at Ci ie, the first key in leftmost leaf of Ci C0, C1, C2, Cnode.size-1 Cnode.size K1 K2 … Knode.size … Ki Ki+1 … Ci Ki X

B+ example 3-degree, Add in order: M H T S R Q B A F D Z

K0-V0, K1-V1, K2-V2, …, Kleaf.size-1-Vleaf.size-1 B+ Tree: Find To find value associated with a key: Find(key): if root is empty return null else return Find(key, root) Find(key, node): if node is a leaf for i from 0 to node.size-1 if key = node.keys[ i ] return node.values[ i ] return null if node is an internal node for i from 1 to node.size if key < node.keys[ i ] return Find(key, getNode(node.child[i-1])) return Find(key, getNode(child[node.size] )) C0, C1, C2, Cnode.size-1 Cnode.size K1 K2 … Knode.size Could use binary search K0-V0, K1-V1, K2-V2, …, Kleaf.size-1-Vleaf.size-1

B+ Tree Add Find leaf node where item belongs Insert in leaf . If node too full, split, and promote middle key up to parent, middle key also go to the right If root split, create new root containing promoted key

Splitting a B+-Tree Leaf If a leaf overflows: The left most m keys are left in the node, The right most m + 1 keys are moved to a new node, The (m + 1)-st key is propagated to the parent node A non leaf node splits as in a common B-tree The right sub-tree of each non leaf node contains greater or equal key values parent 13 15 17 19 18 18 17 Split

B+-Tree Insertion Example Given a B+-tree Insert key 28

B+-Tree Insertion Example (cont.) Insert key 70

B+-Tree Insertion Example (cont.) The middle key of 60 is placed in the node between 50 and 75 Insert 95

B+-Tree Insertion Example (cont.) Split the leaf and promote the middle key to the parent node

B+-Tree Deletion When a record is deleted from a B+-tree it is always removed from the leaf level If the deletion of the key does not cause the leaf underflow Delete the key from the leaf If the key of the deleted record appears in an index node, use the next key to replace it If deletion causes the leaf and the corresponding index node underflow Redistribute, if there is a sibling with more than m keys Merge, if there is no sibling with more than m keys Adjust the index node to reflect the change

B+-Tree Deletion Example Delete 70

B+-Tree Deletion Example (cont.) Delete 25

B+-Tree Deletion Example (cont.) Delete 60

An Indexed-Sequential File To achieve efficient both direct and sequential access to records, we store whole records in the leaves of a B+-tree: Now, B+-tree leaves are data blocks, B+-tree leaves are now called sequence sets A sequence set contains whole records as a data area block, but like a B+-tree leaf it: Splits, Distributes, and Merges

A Coarse Representation of an IS File To access a random record, we use the upper level nodes of the B+-tree To process the file sequentially, we use sequence sets, which are linked sequential blocks of records Levels 0 to h – 2 of a B+-tree Sequence Set 0 Sequence Set 1 Sequence Set n …

Summary The B+-tree is a variant of the B-tree: All key values are stored in leaf nodes and some of them are duplicated in non leaf nodes, A non leaf node has only key values and child pointers, Leaves have only key values and record addresses All leaves are linked into a sequential file The B+-tree gives raise to index-sequential files, which are good for both direct and sequential processing