Tree-Structured Indexes

Transcription

1 Tree-Structured Indexes Yanlei Diao UMass Amherst Slides Courtesy of R. Ramakrishnan and J. Gehrke

2 Access Methods v File of records: Abstraction of disk storage for query processing (1) Sequential scan; (2) Locate a record using record id (rid) v Indexes: E.g., retrieve all sailor records, or a record with (Page 4, Slot 2) Auxiliary data structures. Associative search: Given a value in the index search key field(s), find the (record ids of) records with this value. E.g., find all students with age > 18. 2

3 I. Overview of Indexes v An index on a file speeds up selections on the search key for the index. Any subset of attributes of a relation can be the search key. Search key for an index key of a relation! v An index contains data entries, and supports efficient retrieval of all data entries k* with a given key value k. Data entry in an index vs. data record in a file? 3

4 B+ Tree Indexes Non-leaf Pages Leaf Pages (Sorted by search key) v Leaf pages contain data entries: Leaf pages are chained using prev & next pointers Data entries are sorted by the search key value 4

5 B+ Tree Indexes Non-leaf Pages Leaf Pages (Sorted by search key) v Non-leaf pages have index entries, used only to direct searches. index entry P 0 K 1 P 1 K 2 P 2 K m P m 5

6 Example B+ Tree Root 17 Entries < 17 Entries * 3* 5* 7* 8* 14* 16* 22* 24* 27* 29* 33* 34* 38* 39* Data entries are sorted. v Equality selection: find 28*? 29*? v Range selection: find all > 15* and < 30* v Insert/delete: Find the data entry in a leaf, then change it. More later 6

7 Example B+ Tree Root * 3* 5* 7* 8* 14* 16* 22* 24* 27* 29* 33* 34* 38* 39* v Values in the index entries, when projected onto a line, form a partition of the values in the leaf pages! 7

8 Alternatives for Data Entry k* in Indexes v In a data entry k*, we can store: Alternative 1: <k, data record with search key value k> Alternative 2: <k, rid of a record with search key value k> v Choice of an alternative for data entries is orthogonal to an indexing technique used. Indexing techniques: B+ tree, R-tree, hashing, 8

9 Alternative 1 for Data Entries v Alternative 1: Data records are physically stored in leaf pages. Given a collection of data records, at most one index can use Alternative 1. Why? Data records in leaf pages are sorted by some attribute(s). One copy of data supports one way of ordering; otherwise, need to replicate data. If data records are large, need lots of of leaf pages. Size of the index to direct searches (e.g., non-leaf nodes in B+ tree) can also be large, hence slow searches. 9

10 Alternative 2 for Data Entries v Alternatives 2: <k, rid>: store rid, not the record. Need to chase the pointer (one more I/O) to find the record. Data entries are typically much smaller than data records. Index structure used to direct search is much smaller. Can have many indexes in Alternative 2. 10

11 Index Classification v Clustered index: order of data records is the same as or `close to order of (sorted) data entries in the index. Alternative 1: such a tree index is always clustered. Alternative 2: the records in the data file are (almost) sorted by the index s search key. A data file can have at most one clustered index. v Unclustered index: otherwise Multiple unclustered indexes on a data file. 11

12 Benefits of Clustering CLUSTERED (Alt. 2) UNCLUSTERED Data entries Data entries (Index File) (Data file) Data Records Data Records v Retrieve a range of data records matching a search key value: Clustered index: fast, with one or a few (sequential) I/Os. Unclustered index: can be slow, toughing many pages of data records. 1 random I/O per data record in the worst case. 12

13 II. Properties of a B+ Tree v Height-balanced given arbitrary inserts/deletes. Fanout: # child pointers in a non-leaf node F = avg. fanout Height: # levels below the root of the tree (Root: level 0,, Leaf: level H) N = # leaf pages H = Log F N Index Entries (Direct search) Data Entries ("Sequence set") 13

14 Properties of a B+ Tree v Minimum 50% occupancy (except for the root). Order of the tree (m): max # of keys in a node. Can be computed using the page size, key size, pointer size. Each non-root node is at least half full, containing [ m/2, m ] entries. Root node can have [1, m] entries. Index Entries (Direct search) Data Entries ("Sequence set") 14

15 B+ Trees in Practice v Typical order is 200. Typical fill-factor (occupancy) is 67%. Average fanout = 133 Level 0=1 page; Level 1=133 pages; Level 2=133 2 pages... v Typical capacities: Height 2: = 2,352,637 data entries Height 3: = 312,900,700 data entries v Can often hold top levels in buffer pool: Level 0 = 1 page = 8 KBytes Level 1 = 133 pages = 1 MByte Level 2 = 17,689 pages = 133 MBytes 15

16 Insert a Data Entry k* into a B+ Tree v Find correct leaf L via a top-down search. v Put data entry * into L. If L has enough space, done! Else, must split L (into L and a new node L2) Redistribute data entries evenly, copy up middle key k, insert (k, pointer to L2) into parent of L. Splitting can happen recursively to non-leaf nodes Redistribute index entries evenly, but push up middle key. (Contrast with leaf splits.) v Splits grow the tree! First wider, then one level taller when the root splits. 16

17 An Example B+ Tree Root <13 13 <17 17 <24 24 < * 3* 5* 7* 14* 16* 19* 20* 22* 24* 27* 29* 33* 34* 38* 39* 17

18 Insert 8* into an Example B+ Tree Order m = 4 Root * 3* 5* 7* 14* 16* 19* 20* 22* 24* 27* 29* 33* 34* 38* 39* 18

19 Insert 8* into the Leaf Page, Split 5 Entry to be inserted in parent node. (Note that 5 is copied up and continues to appear in the leaf.) 2* 3* 5* 7* 8* v Minimum occupancy is guaranteed in node splits. v Copy up: key value of an inserted entry must appear in a leaf node! 19

20 Insert into a Non-Leaf Node * 3* 5* 7* 8* 17 Entry to be inserted in parent node. (Note that 17 is pushed up and only appears once in the index v v Push up: Any key value can appear at most once in non-leaf nodes! Note difference between copy-up and push-up. Reasons? 20

21 Example B+ Tree After Inserting 8* Root * 3* 5* 7* 8* 14* 16* 19* 20* 22* 24* 27* 29* 33* 34* 38* 39* v Root was split, leading to increase in height! 21

22 Delete a Data Entry k* from a B+ Tree v Start at root, find leaf L where the entry belongs. v Remove the entry. If L is at least half-full, done! If L has only m/2-1 entries, First try to re-distribute, borrowing from a sibling node (an adjacent node with the same parent as L). If re-distribution fails, merge L and the sibling. Must delete an index entry (pointing to L or the sibling) from the parent of L. v Merge could propagate to the root, decreasing the height. 22

23 Current B+ Tree Delete 19* Delete 20* Root * 3* 5* 7* 8* 14* 16* 19* 20* 22* 24* 27* 29* 33* 34* 38* 39* 23

24 Example Tree After Deleting 19*, 20*... Root * 3* 5* 7* 8* 14* 16* 22* 24* 27* 29* 33* 34* 38* 39* v Deleting 19* is easy. v Deleting 20* is done with re-distribution. Notice how middle key is copied up. 24

25 Delete 24* from the New B+ Tree... Delete 24* Root 2* 3* * 7* 8* 14* 16* 22* 24* 27* 29* 33* 34* 38* 39*

26 Result of Deleting 24* v Must merge nodes. v Toss index entry when merging leaf nodes. v Pull down of index entry when merging non-leaf nodes * 27* 29* 33* 34* 38* 39* Root * 3* 5* 7* 8* 14* 16* 22* 27* 29* 33* 34* 38* 39* 26

27 Example of Non-leaf Re-distribution Root * 3* 5* 7* 8* 14* 16* 17* 18* 20* 21* 22* 27* 29* 33* 34* 38* 39* v Tree is shown below during deletion of 24*. (What could be a possible initial tree?) v In contrast to previous example, can re-distribute entry from left child of root to right child. 27

28 After Re-distribution Root * 3* 5* 7* 8* 14* 16* 17* 18* 20* 21* 22* 27* 29* 33* 34* 38* 39* v Intuitively, entries are re-distributed by `pushing through the splitting entry in the parent node. v It suffices to re-distribute index entry with key 20; we ve re-distributed 17 as well for illustration. 28