1. B+ Trees COMP

2. (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

3. 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

4. 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.

5. 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

6. 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

7. 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 Cnode.size
K K … Knode.size …
Ki Ki+1 … Ci Ki X

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

9. 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 Cnode.size
K K … Knode.size
Could use
binary search
K0-V0, K1-V1, K2-V2, …, Kleaf.size-1-Vleaf.size-1

10. 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

11. 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

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

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

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

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

16. 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

17. B+-Tree Deletion Example
Delete 70

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

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

20. 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

21. 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 …

22. 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