- Hash Function used
in Extensible Hashing:
The bucket index consists of the first i bits in the hash function value.
- The number of bits i is dynamic !!!
(You can use the last i bits instead of the first i bits
I follow the presentation of the text book)
- New things
in extensible hashing:
- Each bucket consists
of:
- Exactly 1 disk block
I.e.: there are no overflow blocks !!!
- Exactly 1 disk block
- Each bucket (disk block)
contains an
integer indicating:
- The number bits of the hash function value used to hash the search keys into the bucket
- Example:
using i = 2 bits
- Each bucket consists
of:
- There are 2 integers used in
Extensible Hashing that
require some explaination:
- The global parameter i:
This parameter controls the number of buckets (= 2i ) of the hash index
- Global parameter i = the number of bits used in the hash(key) to lookup a (hash) bucket
- The bucket label parameter i:
This parameter controls the size of the prefix of the hash index of the search keys that are stored in the bucket
- The following
property holds:
global parameter i ≥ any bucket label parameter i
- The global parameter i:
- Notation:
- The array (in memory)
that contains the
bucket indexes:
is called: bucket[ ] in the algorithm
- The array (in memory)
that contains the
bucket indexes:
- Insert Algorithm:
Parameter: i Insert( x, recordPtr(x) ) { k = h(x); // Genenral Hash function value j = first i bits of k; // Extensible hash function value Read bucket[j] (1 block) into memory; if ( bucket[j] block has space for a search key ) { Insert (x, recordPtr(x) ) into the block; Write block back to disk; return; // Done ! } else { /* ------------------------------------- bucket[j] disk block is full ------------------------------------- */ Let i' = integer label of bucket[j] block;
/* ------------------------------------------------------------
Split bucket j (that has overflowed !!)
into 2 buckets: j0 and j1
------------------------------------------------------------ */
Allocate 2 disk block: j0 and j1;
for ( each search key x' ∈ bucket[j] block ) do
{
/* ===============================================================
Re-hash all keys in bucket[j] using (i'+1) bits in hash value
=============================================================== */
k' = h(x'); // Find hash function value
j' = the first i'+1 bits of k'; // Use 1 more bit !
if ( the last bit in j' == 0 )
store (x', recordPtr(x')) in block j0;
else
store (x', recordPtr(x')) in block j1;
}
(Result:
)
/* ------------------------------------------------
Update the tag of the new blocks j0 and j1
------------------------------------------------ */
Tag the blocks j0 and j1 with the value i'+1;
/* ======================================================
Update pointers to the bucket j (it is now 2 buckets)
====================================================== */
if ( i' < i )
{ /* ===============================================
Note: i' < i indicates that bucket[j'] and its
"copy" points to the SAME disk block
=============================================== */
Situation:
/* -------------------------------------------
We have a spare bucket pointer
No need to allocate more pointers !
------------------------------------------- */
bucket[j'<<1 + 0] = block address j0;
bucket[j'<<1 + 1] = block address j1;
Result:
}
else
{
Situation:
/* =============================================
We need more pointers....
============================================= */
double the bucket array (and copy bucket ptrs) as follows:
bucket[j<<1 + 0] = block address j0
bucket[j<<1 + 1] = block address j1
Result:
set i = i + 1; // Use 1 more bit to hash
}
/* =======================================================
We handled the overflow by allocating an extra bucket
Now we can insert the key (and its rec ptr)
======================================================= */
Insert (x, recordPtr(x)) using the new configuration;
}
}
- Example:
Extensible Hash Table
- Initial State:
- Insert a record
X such that:
h(X) = 1010:
Bucket 1 is full !!!
- Split
the bucket "1" into
buckets "10" and "11":
- Because i' == i
(i.e., we used more bits than
the Extensible Hashing currently
allows),
we must double the
bucket array:
After updating the bucket pointers:
Observe that:
- i' < i means:
- bucket[j'] and
its copy
points to
the same block !!!
See: bucket[00] and bucket[01] !!!
- bucket[j'] and
its copy
points to
the same block !!!
- i' < i means:
- Now we
can insert X using the
new (increased) configuration:
Result:
- Initial State:
- Example continued:
Insert a record
X
such that:
h(X) = 0000:
- Initial State:
- Inserting a record
X
such that:
h(X) = 0000:
Result:
Note:
- You may think that
you are using 2 bits of
the hash value to determine
the hash bucket...
But you are not !!!
- That's because
both pointers
bucket[00] and
bucket[01] are
pointing to the
same bucket !!!
So you are really only using the first bit of the hash value
- Initial State:
- Example continued:
Insert a record
X
such that:
h(X) = 0100:
- Initial State:
- Inserting a record
X
such that:
h(X) = 0100:
Split the bucket "0" into buckets "00" and "01":
Result:
- Try again using the
new configuration:
Result:
- Initial State:
- The delete algorithm is
the same as
the standard
delete algorithm
for hashing
- We do not
consolidate
buckets in
deletion
(Because the ossicilation problem can cause severe performance degradation in Extensible Hashing)
- We do not
consolidate
buckets in
deletion
- Instead of
consolidating:
- Periodically perform rehashing on all search keys in the Extensible Hash Table
- Advantage:
- Always access 1 hash table block to lookup a record
- Problem:
- The size of the
hash table
will double each time
when we extend the table.
- Exponential rate of increase....
Better solution:
- Increase the
hash table size
linearly !!!
- Linear hashing !!! (discussed next)
- The size of the
hash table
will double each time
when we extend the table.