Hash-Based Indexes Chapter 11
Dec 21, 2015
1
Hash-Based Indexes
Chapter 11
2
Introduction : Hash-based Indexes
Best for equality selections.
Cannot support range searches.
Static and dynamic hashing techniques exist:
Trade-offs similar to ISAM vs. B+ trees.
3
Static Hashing
h(k) mod N = bucket to which data entry with key k belongs. (N = # of buckets)
h(key) mod N
hkey
Primary bucket pages Overflow pages
10
N-1
4
Static Hashing : h(k) mod N # primary pages fixed (N = # of buckets) allocated sequentially never de-allocated overflow pages if needed.
h(key) mod N
hkey
Primary bucket pages Overflow pages
20
N-1
5
Static Hashing h(k) mod N = bucket to which data entry
with key k belongs with N = # of buckets Hash function works on search key of record
r.
h() must distribute values over range [0 ...
N-1]. For example, h(key) = (a * key + b) a and b are constants lots known about how to tune h.
6
Static Hashing Cons
Primary pages fixed space static structure.
Fixed # bucket is the problem: Rehashing can be done Not good for search. In practice, instead use overflow chains.
Long overflow chains can develop and degrade performance.
Solution: Employ dynamic techniques to fix this problem: Extendible hashing, or Linear Hashing
7
Extendible Hashing Problem: Bucket (primary page) becomes full. Solution: Why not re-organize file by doubling #
of buckets? Reading and writing all pages is expensive!
Idea : Use directory of pointers to buckets instead of buckets double # of buckets by doubling the directory split just the bucket that overflowed!
Discussion : + Directory much smaller than file, so doubling is
cheaper. + Only one page of data entries is split.
+ No overflow pages ever.
Trick lies in how hash function is adjusted!
8
Example
Directory : array[4] To find bucket for r,
take last `global depth’ # bits of function h(r)
13*00
01
10
11
2
2
2
2
2
LOCAL DEPTH
GLOBAL DEPTH
DIRECTORY
Bucket A
Bucket B
Bucket C
Bucket D
DATA PAGES
10*
1* 21*
4* 12* 32* 16*
15* 7* 19*
5*
9
Example
If h(r) = 5 = 101, it is in bucket
pointed to by 01.
If h(r) = 4 = 100, it is in bucket
pointed to by 00.
13*00
01
10
11
2
2
2
2
2
LOCAL DEPTH
GLOBAL DEPTH
DIRECTORY
Bucket A
Bucket B
Bucket C
Bucket D
DATA PAGES
10*
1* 21*
4* 12* 32* 16*
15* 7* 19*
5*
10
Insertion
Splitting may : double the directory, or simply link in a new page.
To tell what to do :Compare global depth with local depth for split bucket.
13*00
01
10
11
2
2
2
2
2
LOCAL DEPTH
GLOBAL DEPTH
DIRECTORY
Bucket A
Bucket B
Bucket C
Bucket D
DATA PAGES
10*
1* 21*
4* 12* 32* 16*
15* 7* 19*
5* Insert: If bucket is full, split it (allocate new page, re-distribute content).
11
Insert h(r)= 6 = binary 110
13*00
01
10
11
2
2
2
2
2
LOCAL DEPTH
GLOBAL DEPTH
DIRECTORY
Bucket A
Bucket B
Bucket C
Bucket D
DATA PAGES
10*
1* 21*
4* 12* 32* 16*
15* 7* 19*
5*
12
Insert h(r)= 6 = binary 110
13*00
01
10
11
2
2
2
2
2
LOCAL DEPTH
GLOBAL DEPTH
DIRECTORY
Bucket A
Bucket B
Bucket C
Bucket D
DATA PAGES
10*
1* 21*
4* 12* 32* 16*
15* 7* 19*
5* 13*00
01
10
11
2
2
2
2
2
LOCAL DEPTH
GLOBAL DEPTH
DIRECTORY
Bucket A
Bucket B
Bucket C
Bucket D
DATA PAGES
10*
1* 21*
4* 12* 32* 16*
15* 7* 19*
5*
6*
13
Insert h(r)=20 = binary 10100
13*00
01
10
11
2
2
2
2
2
LOCAL DEPTH
GLOBAL DEPTH
DIRECTORY
Bucket A
Bucket B
Bucket C
Bucket D
DATA PAGES
10*
1* 21*
4* 12* 32* 16*
15* 7* 19*
5*
14
Insert h(r)=20
13*00
01
10
11
2
2
2
2
2
LOCAL DEPTH
GLOBAL DEPTH
DIRECTORY
Bucket A
Bucket B
Bucket C
Bucket D
DATA PAGES
10*
1* 21*
4* 12* 32* 16*
15* 7* 19*
5*
20*
3
Bucket A2
Split Bucket A into two buckets A1 and A2.
4* 12*
3
Bucket A132*16*
15
Insert h(r)=20
13*00
01
10
11
2
2
2
2
2
LOCAL DEPTH
GLOBAL DEPTH
DIRECTORY
Bucket A
Bucket B
Bucket C
Bucket D
DATA PAGES
10*
1* 21*
4* 12* 32* 16*
15* 7* 19*
5*
20*
3
Bucket A24* 12*
3
Bucket A132*16*
16
Insert h(r)=20
20*
00
01
10
11
2 2
2
2
LOCAL DEPTH 2
2
DIRECTORY
GLOBAL DEPTHBucket A
Bucket B
Bucket C
Bucket D
Bucket A2(`split image'of Bucket A)
1* 5* 21*13*
32*16*
10*
15* 7* 19*
4* 12*
19*
2
2
2
000
001
010
011
100
101
110
111
3
3
3DIRECTORY
Bucket A
Bucket B
Bucket C
Bucket D
Bucket A2(`split image'of Bucket A)
32*
1* 5* 21*13*
16*
10*
15* 7*
4* 20*12*
LOCAL DEPTH
GLOBAL DEPTH
17
Points to Note 20 = binary 10100. Last 2 bits (00) tell us r belongs in A (or not
A). Last 3 bits needed to tell A1 or A2 Using bits:
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 an entry belongs to this bucket.
18
More Points to Note
Bits: 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 an entry belongs to this bucket.
When does bucket split cause directory doubling? 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.
19
Extendible Hashing : Delete
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.
20
Comments on Extendible Hashing
If directory fits in memory, then equality search answered with one disk access; else two. 100MB file, 100 bytes/rec, 4K pages
contain 1,000,000 records (as data entries) and 25,000 directory elements; chances are high that directory will fit in memory.
Directory grows in spurts. If the distribution of hash values is
skewed, directory can grow large.
21
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 full bucket when new data to be added Directory to keep track of buckets, doubles
periodically