1. CPSC-608 Database Systems Fall 2011 Instructor: Jianer Chen Office: HRBB 315C Phone: 845-4259 Email: chen@cse.tamu.edu 1 Notes #10

2. secondary storage (disks) in tables (relations) database administrator DDL language database programmer DML (query) language DBMS file manager buffer manager main memory buffers index/file manager DML complier DDL complier query execution engine transaction manager concurrency control lock table logging & recovery graduate database

3. The Main Purpose of Index Structures 3

4. Speedup the search process 4 index σ a=6 (R) blocks contianing the desired tuples quickly figure out disks

5. The Main Purpose of Index Structures Speedup the search process 5 index σ a=6 (R) blocks contianing the desired tuples quickly figure out disks otherwise have to scan the entire R

6. The Main Purpose of Index Structures Speedup the search process 6 index σ a=6 (R) blocks contianing the desired tuples quickly figure out disks otherwise have to scan the entire R But also need to handle dynamic changes of R

7. B+Trees Support fast search Support range search Support dynamic changes Could be either dense or sparse dense: pointers to all records sparse: one pointer per block A B+tree node (of order n): 7 pnpn knkn k2k2 p1p1 k1k1 p0p0 p2p2 ……

8. root B+Tree Exampleorder n = 3 100 120 150 180 30 3 5 11 30 35 100 101 110 120 130 150 156 179 180 200 8

9. Sample non-leaforder n = 3 to keys to keysto keys to keys < 5757  k < 81 81  k < 95  95 9 57 8195

10. Sample leaf nodeorder n = 3 10 To record With key 57 To record With key 81 To record With key 85 57 8195 From non-leaf node To next leaf in sequence (in our algorithm, assume this is p 0 )

11. A B+ Tree of order n Each node has:n+1 pointers n keys These are fixed 11

12. Don’t want nodes to be too empty Use at least Non-leaf:  (n+1)/2  pointers (to children) Leaf:  (n+1)/2  pointers to data (plus a “sequence pointer” to the next leaf) 12

13. Full nodeMin. node Non-leaf Leaf Example (B+ tree of order n=3) 120 150 180 30 3 5 11 30 35 13

14. B+tree rules Rule 1. All leaves are at same lowest level (balanced tree) Rule 2. Pointers in leaves point to records except for “sequence pointer” 14

15. Rule 3. Number of pointers/keys for B+tree Non-leaf (non-root) n+1 n  (n+1)/ 2   (n+1)/ 2  – 1 Leaf (non-root) n+1 n Rootn+1 n 21 Max Max Min Min ptrs keys ptrs  data keys  (n+ 1) / 2  15 could be 1

16. Search in a B+tree Start from the root Search in a leaf block May not have to go to the data file 16

17. Pseudo Code for Search in a B+tree Search(ptr, k); \\ search a record of key value k in the subtree rooted at *ptr Case 1. *ptr is a leaf \\ p n is the sequence pointer IF (k = k i ) for a key k i in *ptr THEN return(p i-1 ); ELSE return(Null); Case 2. *ptr is not a leaf find a key k i in *ptr such that k i ≤ k < k i+1 ; return(Search(p i, k)); 17

18. Range Search in B+tree To research all records whose key values are between k 1 and k 2 : 18

19. Range Search in B+tree To research all records whose key values are between k 1 and k 2 : Step 1. Call Search(ptr, k 1 ); 19

20. Range Search in B+tree To research all records whose key values are between k 1 and k 2 : Step 1. Call Search(ptr, k 1 ); Step 2. Follow the sequence pointers until the search key value is larger than k 2. 20

21. Insert into B+tree (a) simple case (space available in leaf) (b) leaf overflow (c) non-leaf overflow (d) new root 21

22. Pseudo Code for Insertion in a B+tree Insert(ptr, (k,p), (k',p')); \\ p is a pointer to a data record with key value k, which are inserted into the subtree rooted at \\ *ptr; p' is a pointer to a new brother of *ptr, if created, in which k' is the smallest key value; Case 1. *ptr = (p 0, k 1, p 1,..., k i, p i ) is a leaf \\ p 0 is the sequence pointer IF (i < n) THEN insert (k,p) into *ptr; return(k'=0, p'=Null); ELSE re-arrange (k 1, p 1 ),..., (k n, p n ), and (k, p) into (k 1, p 1,..., k n+1, p n+1 ); create a new leaf q; put (p 0, k r+1, p r+1, …, k n+1, p n+1 ) in *q; \\ r =  (n+1)/2  put (q, k 1, p 1,..., p r-2, k r, p r ) in *ptr; \\ p 0 and q are sequence pointers in *q and *ptr, resp. IF *ptr is the root THEN create a new root with children ptr and q (and key k r ) ELSE return( k‘ = k r+1, p' = q ); Case 2. *ptr is not a leaf find a key k i in *ptr such that k i ≤ k < k i+1 ; Insert(p i, (k, p), (k", p")); IF (p" = Null) THEN return(k'=0, p'=Null); ELSE IF there is room in *ptr, THEN insert (k", p") into *ptr; return(k'=0, p'=Null); ELSE re-arrange the content in *ptr and (k", p") into (p 0, k 1, p 1,..., k n+1, p n+1 ); leave (p 0, k 1,..., p r-2, k r-1, p r-1 ) in *ptr; \\ r =  (n+1)/2  create a new leaf q; put (p r, k r+1,..., p n, k n+1, p n+1 ) in *q; IF *ptr is the root THEN create a new root with children ptr and q (and key k r ) ELSE return( k'= k r, p' = q ); 22

23. (a) Insert key = 32 order n=3 3 5 11 30 31 30 100 23

24. (a) Insert key = 32 order n=3 3 5 11 30 31 30 100 24 32 < 100

25. (a) Insert key = 32 order n=3 3 5 11 30 31 30 100 25 32 < 100 32 ≥ 30

26. (a) Insert key = 32 order n=3 3 5 11 30 31 30 100 26 32 < 100 32 ≥ 30 There is room for 32

27. (a) Insert key = 32 order n=3 3 5 11 30 31 30 100 32 27

28. (b) Insert key = 7 order n=3 3 5 11 30 31 30 100 28

29. (b) Insert key = 7 order n=3 3 5 11 30 31 30 100 29 7

30. (b) Insert key = 7 order n=3 30 31 30 100 30 3 5 7 11

31. (b) Insert key = 7 order n=3 30 31 30 100 31 3 5 7 11

32. (b) Insert key = 7 order n=3 7 11 30 31 30 100 3535 7 32

33. (c) Insert key = 160 order n=3 100 120 150 180 150 156 179 180 200 33

34. (c) Insert key = 160 order n=3 100 120 150 180 150 156 179 180 200 34 160

35. (c) Insert key = 160 order n=3 100 120 150 180 150 156 180 200 160 179 35

36. (c) Insert key = 160 order n=3 100 120 150 156 180 200 160 179 36 180 160

37. (c) Insert key = 160 order n=3 100 160 120 150 156 180 200 160 179 37 180

38. (d) New root, insert 45 order n=3 10 20 30 123123 10 12 20 25 30 32 40 38

39. (d) New root, insert 45 order n=3 10 20 30 123123 10 12 20 25 30 32 40 30 new root 40 45 40 39

40. (a)Simple case (b)Re-distribute keys among siblings (c) Coalesce with a sibling and delete a pointer from its father (d) Cases (b) or (c) at non-leaf Deletion from B+tree 40

41. (a) Simple case –Delete 35 10 40 100 10 20 30 35 40 50 order n=4 41

42. (a) Simple case –Delete 35 10 40 100 10 20 30 40 50 order n=4 42

43. (b) Coalesce with sibling –Delete 50 10 40 100 10 20 30 40 50 order n=4 43

44. (b) Coalesce with sibling –Delete 50 10 40 100 10 20 30 40 50 order n=4 40 44

45. (c) Redistribute keys –Delete 50 10 40 100 10 20 30 35 40 50 order n=4 45

46. (c) Redistribute keys –Delete 50 10 40 100 10 20 30 35 40 50 order n=4 35 46

47. 40 45 30 37 25 26 20 22 10 14 1313 10 2030 40 (d) Non-leaf coalesce –Delete 37 order n=4 25 30 40 25 new root 47

48. B+tree deletions in practice –Often, coalescing is not implemented –Too hard and not worth it! 48

49. Variation on B+tree: B-tree (no “+”) Idea: –Avoid duplicate keys –Have record pointers in non-leaf nodes 49

50. to record to record to record with K1 with K2 with K3 to keys to keys to keys to keys k3 K1 P1K2 P2K3 P3 50

51. B-tree examplen=2 65 125 145 165 85 105 25 45 10 20 30 40 110 120 90 100 70 80 170 180 50 60 130 140 150 160 51

52. B-tree examplen=2 65 125 145 165 85 105 25 45 10 20 30 40 110 120 90 100 70 80 170 180 50 60 130 140 150 160 sequence pointers not useful now! 52

53. B-tree examplen=2 65 125 145 165 85 105 25 45 10 20 30 40 110 120 90 100 70 80 170 180 50 60 130 140 150 160 sequence pointers not useful now! 53

54. Tradeoffs: B-trees have faster lookup than B+trees  in B-tree, non-leaf & leaf different sizes  in B-tree, insertion and deletion more complicated  B+trees preferred! 54