Beruflich Dokumente
Kultur Dokumente
Administrivia
The new Homework 3 now available Due 1 week from Sunday Homework 4 available the week after
Midterm exams available here
Review
Last time discussed File Organization Unordered heap files Sorted Files Clustered Trees Unclustered Trees Unclustered Hash Tables Indexes B-Trees dynamic, good for changing data, range queries Hash tables fastest for equality queries, useless for range queries
Review (2)
For any index, 3 alternatives for data entries k*: Data record with key value k <k, rid of data record with search key value k> <k, list of rids of data records with search key k> Choice orthogonal to the indexing technique
Today:
Indexes Composite Keys, Index-Only Plans B-Trees details of insertion and deletion
Hash Indexes How to implement with changing data sets
This can happen recursively To split index node, redistribute entries evenly, but push up middle key. (Contrast with leaf splits.) Splits grow tree; root split increases height. Tree growth: gets wider or one level taller at top.
10,12
20,12
sue 13
75
10
20
Data entries in index sorted by search key to support range queries. Lexicographic order, or Spatial order.
75,13
80,11 <sal, age>
75
80 <sal>
Index-Only Plans
<E.dno>
A number of queries <E.dno,E.eid> SELECT D.mgr, E.eid FROM Dept D, Emp E can be answered Tree index! WHERE D.dno=E.dno without retrieving any tuples from one SELECT E.dno, COUNT(*) <E.dno> FROM Emp E or more of the relations involved if GROUP BY E.dno a suitable index is SELECT E.dno, MIN(E.sal) <E.dno,E.sal> FROM Emp E available. Tree index! GROUP BY E.dno <E. age,E.sal> SELECT AVG(E.sal) or FROM Emp E <E.sal, E.age> WHERE E.age=25 AND Tree! E.sal BETWEEN 3000 AND 5000
SELECT E.dno, COUNT (*) FROM Emp E WHERE E.age>30 GROUP BY E.dno
This means that after deletion, nodes will often be < 50% full
B-Tree Demo
Hashing
Static and dynamic hashing techniques exist; trade-offs based on data change over time
Static Hashing Good if data never changes Extendable Hashing Uses directory to handle changing data Linear Hashing Avoids directory, usually faster
Static Hashing
# primary pages fixed, allocated sequentially, never de-allocated; overflow pages if needed. h(k) mod N = bucket to which data entry with key k belongs. (N = # of buckets)
0 2
h(key) mod N
key h
N-1
Primary bucket pages Overflow pages
Extendible Hashing
Situation: Bucket (primary page) becomes full. Why not re-organize file by doubling # of buckets? Reading and writing all pages is expensive!
Idea: Use directory of pointers to buckets, double # of buckets by doubling the directory,
splitting just the bucket that overflowed! Directory much smaller than file, doubling much cheaper. No overflow pages! Trick lies in how hash function is adjusted!
Example
Directory is array of size 4. To find bucket for r, take last `global depth # bits of h(r); we denote r by h(r).
00 01 10 11
10*
Bucket C
DIRECTORY
DATA PAGES
Insert: If bucket is full, split it (allocate new page, re-distribute). If necessary, double the directory. (As we will see, splitting a bucket does not always require doubling; we can tell by comparing global depth with local depth for the split bucket.)
10*
2 DIRECTORY 15* 7* 19*
Bucket C
010
011
100 Bucket D 101 110 111
011
100 101 110 111
011
100 101 110 111
5* 21* 13*
Bucket B2
Points to Note
20 = binary 10100. Last 2 bits (00) tell us r belongs in A or A2. Last 3 bits needed to tell which. Global depth of directory: Max # of bits needed to tell which bucket an entry belongs to. Local depth of a bucket: # of bits used to determine if splitting bucket will also double directory When does bucket split cause directory doubling? If, before insert, local depth of bucket = global depth.
Insert causes local depth to become > global depth; directory is doubled by copying it over and `fixing pointer to split image page. (Use of least significant bits enables efficient doubling via copying of directory!)
Directory Doubling
Why use least significant bits in directory? Allows for doubling via copying!
2 4* 12* 32* 16* 000 2 00 01 10 11 2 1* 5* 21* 13* 001 010 011 2 1* 5* 21* 13* 3
2
4* 12* 32* 16*
2
10*
100
2 10*
101 110
2 15* 7* 19*
111
2 15* 7* 19*
Deletion
Delete: If removal of data entry makes bucket empty, can be merged with `split image. If each directory element points to same bucket as its split image, can halve directory.
2 4* 12* 32* 16* 1 4* 12* 32* 16*
2 00 01 10 11
2 1*
Delete 10
5* 21* 13*
00 01
2 1*
5* 21* 13*
2 10*
10 11
2 15*
2 15*
Deletion (cont)
Delete: If removal of data entry makes bucket empty, can be merged with `split image. If each directory element points to same bucket as its split image, can halve directory. 1
2 1 4* 12* 32* 16* 00 4* 12* 32* 16*
Delete 15
01 10
1 1* 5* 21* 13*
2 00 01 10 11
2 1*
11
5* 21* 13*
1 0 2 15* 1
1
1* 5* 21* 13*
Biggest problem: Multiple entries with same hash value cause problems! If bucket already full of same hash value, will keep doubling forever! So must use overflow buckets if dups.
Linear Hashing
This is another dynamic hashing scheme, an alternative to Extendible Hashing.
LH handles the problem of long overflow chains without using a directory, and handles duplicates. Idea: Use a family of hash functions h0, h1, h2, ... hi(key) = h(key) mod(2iN); N = initial # buckets h is some hash function (range is not 0 to N-1) If N = 2d0, for some d0, hi consists of applying h and looking at the last di bits, where di = d0 + i. hi+1 doubles the range of hi (similar to directory doubling)
Add 9
32* 16*
Next
1* 10*
5* 21* 13*
9*
Add 20
32* 16*
Nround
15*
Nround
15* 4* 12*
Next
1* 10*
5* 21* 13*
9*
Nround
Add 17
32* 16* 9* 1* 13*
Next
1*
5* 21* 13*
10* 6*
Next
Nround
Nround
Current round number also called Level. Search: To find bucket for data entry r, find hround(r): If hround(r) in range `Next to NR , r belongs here. Else, r could be hround(r) or hround(r) + NR;
must apply hround+1(r) to find out.
Overview of LH File
In the middle of a round.
Bucket to be split Next Buckets that existed at the beginning of this round: this is the range of Buckets split in this round: If h Level ( search key value ) is in this range, must use h Level+1 ( search key value ) to decide if entry is in `split image' bucket.
hLevel
`split image' buckets: created (through splitting of other buckets) in this round
Doubling of directory in Extendible Hashing is similar; switching of hash functions is implicit in how the # of bits examined is increased.
h
1 000 001
h 0 00
PRIMARY Next=0 PAGES 32*44* 36* 9* 25* 5* Data entry r with h(r)=5 Primary bucket page
h
1 000 001
h 0 00
OVERFLOW PAGES
01
10 11
Next=1 9* 25* 5* 01 10 11 00
010 011
Round=1 PRIMARY PAGES Next=0 32* 9* 25* 66* 18* 10* 34* 43* 35* 11* 44* 36* 5* 37* 29* 14* 30* 22* 31* 7*
OVERFLOW PAGES
h1 000
50*
11
00 11 10 11
44*36*
5* 37*29* 14*30* 22*
LH Described as a Variant of EH
The two schemes are actually quite similar: Begin with an EH index where directory has N elements. Use overflow pages, split buckets round-robin. First split is at bucket 0. (Imagine directory being doubled at this point.) But elements <1,N+1>, <2,N+2>, ... are the same. So, need only create directory element N, which differs from 0, now.
When bucket 1 splits, create directory element N+1, etc.
So, directory can double gradually. Also, primary bucket pages are created in order. If they are allocated in sequence too (so that finding ith is easy), we actually dont need a directory! Voila, LH.
Summary
Hash-based indexes: best for equality searches, cannot support range searches. Static Hashing can lead to long overflow chains.
Extendible Hashing avoids overflow pages by splitting a full bucket when a new data entry is to be added to it. (Duplicates may require overflow pages.) Directory to keep track of buckets, doubles periodically. Can get large with skewed data; additional I/O if this does not fit in main memory.
Summary (Contd.)
Linear Hashing avoids directory by splitting buckets round-robin, and using overflow pages. Overflow pages not likely to be long. Duplicates handled easily. Space utilization could be lower than Extendible Hashing, since splits not concentrated on `dense data areas. Can tune criterion for triggering splits to trade-off slightly longer chains for better space utilization. For hash-based indexes, a skewed data distribution is one in which the hash values of data entries are not uniformly distributed!