Chapter 12: Query Processing

Chapter 12: Query Processing

Overview
Measures of Query Cost
Selection Operation
Sorting
Join Operation
 Basic Steps in Query Processing
1. Parsing and translation
2. Optimization
3. Evaluation
Basic Steps in Query Processing (Cont.)

Parsing and translation

translate the query into its internal form. This is then
translated into relational algebra.
Parser checks syntax, verifies relations
Evaluation
The query-execution engine takes a query-evaluation plan,
executes that plan, and returns the answers to the query.
Basic Steps in Query Processing : Optimization
A relational algebra expression may have many equivalent
expressions
E.g., salary75000(salary(instructor)) is equivalent to
salary(salary75000(instructor))
Each relational algebra operation can be evaluated using one of
several different algorithms
Correspondingly, a relational-algebra expression can be
evaluated in many ways.
Annotated expression specifying detailed evaluation strategy is
called an evaluation-plan.
E.g., can use an index on salary to find instructors with salary <
75000,
or can perform complete relation scan and discard instructors
with salary 75000
 Basic Steps: Optimization (Cont.)
Query Optimization: Amongst all equivalent evaluation plans
choose the one with lowest cost.
Cost is estimated using statistical information from the
database catalog
e.g. number of tuples in each relation, size of tuples, etc.
 Measures of Query Cost
Cost is generally measured as total elapsed time for answering
query
Many factors contribute to time cost
disk accesses, CPU, or even network communication
Typically disk access is the predominant cost, and is also
relatively easy to estimate. Measured by taking into account
Number of seeks * average-seek-cost
Number of blocks read * average-block-read-cost
Number of blocks written * average-block-write-cost
Cost to write a block is greater than cost to read a block
data is read back after being written to ensure that the
write was successful
 Measures of Query Cost (Cont.)
For simplicity we just use the number of block transfers from disk
and the number of seeks as the cost measures
tT time to transfer one block
tS time for one seek
Cost for b block transfers plus S seeks
b * tT + S * tS
We ignore CPU costs for simplicity
Real systems do take CPU cost into account
We do not include cost to writing output to disk in our cost formulae
 Measures of Query Cost (Cont.)
Several algorithms can reduce disk IO by using extra buffer
space
Amount of real memory available to buffer depends on other
concurrent queries and OS processes, known only during
execution
We often use worst case estimates, assuming only the
minimum amount of memory needed for the operation is
available
Required data may be buffer resident already, avoiding disk I/O
But hard to take into account for cost estimation
 Selection Operation
File scan
Algorithm A1 (linear search). Scan each file block and test all records
to see whether they satisfy the selection condition.
Cost estimate = br block transfers + 1 seek
b
r denotes number of blocks containing records from relation r
If selection is on a key attribute, can stop on finding record
cost = (br /2) block transfers + 1 seek
Linear search can be applied regardless of
selection condition or
ordering of records in the file, or
availability of indices
Note: binary search generally does not make sense since data is not
stored consecutively
except when there is an index available,
and binary search requires more seeks than index search
 Type of Indices

Primary index
A primary index is an index on a set of fields that
includes the unique primary key for the field and is
guaranteed not to contain duplicates.
Also Called a **Clustered index**.
eg. Employee ID can be Example of it.
Secondary index
A Secondary index is an index that is not a primary
index and may have duplicates.
eg. Employee name can be example of it. Because
Employee name can have similar values.

Database System Concepts - 6th Edition 12.11 Silberschatz, Korth and Sudarshan
 Selections Using Indices
Index scan search algorithms that use an index
Selection condition must be on search-key of index
A2 (primary index, equality on key). Retrieve a single record that
satisfies the corresponding equality condition
Cost = (hi + 1) * (tT + tS) (Where hi denotes the height of the index.)
Index lookup traverses the height of the tree plus one I/O to fetch the record;
each of these I/O operations requires a seek and a block transfer.
A3 (primary index, equality on nonkey) Retrieve multiple records
Records will be on consecutive blocks
Let b = number of blocks containing matching records
Cost = hi * (tT + tS) + tS + tT * b
 Selections Using Indices

A4 (secondary index, equality).

Retrieve a single record if the search-key is a candidate key
Cost = (hi + 1) * (tT + tS)
Retrieve multiple records if search-key is not a candidate key
each of n matching records may be on a different block
Cost = (hi + n) * (tT + tS)
Can be very expensive!
 Selections Involving Comparisons
Can implement selections of the form AV (r) or A V(r) by using
a linear file scan,
or by using indices in the following ways:
A5 (primary index, comparison). (Relation is sorted on A)
For A V(r) use index to find first tuple v and scan relation sequentially
from there
For AV (r) just scan relation sequentially till first tuple > v; do not use
index
A6 (secondary index, comparison).
For A V(r) use index to find first index entry v and scan index
sequentially from there, to find pointers to records.
For AV (r) just scan leaf pages of index finding pointers to records, till
first entry > v
In either case, retrieve records that are pointed to

requires an I/O for each record

Linear file scan may be cheaper
 Join Operation
Several different algorithms to implement joins
Nested-loop join
Block nested-loop join
Indexed nested-loop join
Merge-join
Hash-join
Choice based on cost estimate
Examples use the following information
STUDENT TAKES (two relations students and takes)
Number of records of student: 5,000 takes: 10,000
Number of blocks of student: 100 takes: 400
 Nested-Loop Join

To compute the join r s

for each tuple tr in r do begin
for each tuple ts in s do begin
test pair (tr,ts) to see if they satisfy the join condition
if they do, add tr ts to the result.
end
end
r is called the outer relation and s the inner relation of the join.
Requires no indices and can be used with any kind of join
condition.
Expensive since it examines every pair of tuples in the two
relations.
 Nested-Loop Join (Cont.)

The number of pairs of tuples to be considered is nr ns, where nr

denotes the number of tuples in r, and ns denotes the number of
tuples in s.
For each record in r,we have to perform a complete scan on s.
In the worst case, if there is enough memory only to hold one
block of each relation, the estimated cost is
nr bs + br block transfers, plus
nr + br seeks (br and bs the number of blocks containing
tuples of r and s
If the smaller relation fits entirely in memory, use that as the inner
relation.
Reduces cost to br + bs block transfers and 2 seeks
 Example: Nested-Loop Join (Cont.)
Assuming worst case memory availability cost estimate is
with student as outer relation:
5000 400 + 100 = 2,000,100 block transfers,
5000 + 100 = 5100 seeks
with takes as the outer relation
10000 100 + 400 = 1,000,400 block transfers and 10,400 seeks
If smaller relation (student) fits entirely in memory, the cost estimate
will be 500 block transfers.

nr bs + br block transfers, plus

nr + br seeks (br and bs the number of blocks containing tuples of r and s

STUDENT TAKES (two relations students and takes)

Number of records of student: 5,000 takes: 10,000
Number of blocks of student: 100 takes: 400
 Nested-Loop Join
The nested loops join, also called nested iteration, uses one join input as the
outer input table and one as the inner input table. The outer loop consumes the
outer input table row by row. The inner loop, executed for each outer row,
searches for matching rows in the inner input table.
In the simplest case, the search scans an entire table or index; this is called a
naive nested loops join.
If the search exploits an index, it is called an index nested loops join.
If the index is built as part of the query plan (and destroyed upon completion of
the query), it is called a temporary index nested loops join.
All these variants are considered by the query optimizer.
A nested loops join is particularly effective if the outer input is small and the
inner input is preindexed and large.
In many small transactions, such as those affecting only a small set of rows,
index nested loops joins are superior to both merge joins and hash joins.
In large queries, however, nested loops joins are often not the optimal choice.
https://technet.microsoft.com/en-us/library/ms191318(v=sql.105).aspx
 Block Nested-Loop Join
If the buffer is too small to hold either relation entirely in memory
We can still obtain a major saving in block accesses if we process the relations on a
per-block basis, rather than on a per-tuple basis.
Variant of nested-loop join in which every block of inner relation is
paired with every block of outer relation.
Within each pair of blocks, every tuple in one block is paired with every tuple in the
other block, to generate all pairs of tuples
for each block Br of r do begin
for each block Bs of s do begin
for each tuple tr in Br do begin
for each tuple ts in Bs do begin
Check if (tr,ts) satisfy the join condition
if they do, add tr ts to the result.
end
end
end
end
 Block Nested-Loop Join (Cont.)

The primary difference in cost between the block nested-loop join and
the basic nested-loop join is that, in the worst case, each block in the
inner relation s is read only once for each block in the outer relation,
instead of once for each tuple in the outer relation.
Worst case estimate: br bs + br block transfers + 2 * br seeks
Each block in the inner relation s is read once for each block in the outer
relation
Each scan of the inner relation requires one seek, and the scan of the
outer relation requires one seek per block, leading to a total of 2 br
seeks.
Clearly, it is more efficient to use the smaller relation as the outer relation,
in case neither of the relations fits in memory.
Best case where the inner relation fits in memory, there will be br + bs
block transfers + 2 seeks (we would choose the smaller relation as the
inner relation in this case).
 Example: Block Nested-Loop Join
Computing student takes, using the block nested-loop join
algorithm.
In the worst case, we have to read each block of takes once for
each block of student.
Thus, in the worst case, a total of 100 400+100 = 40,100 block
transfers plus 2100 = 200seeks are required.
This cost is a significant improvement over the 5000400+100 =
2,000,100 block transfers plus 5100 seeks needed in the worst
case for the basic nested-loop join.
The best-case cost remains the samenamely, 100 + 400 = 500
block transfers and 2 seeks.
 Indexed Nested-Loop Join

Index lookups can replace file scans if

join is an equi-join or natural join and
an index is available on the inner relations join attribute
Can construct an index just to compute a join.
For each tuple tr in the outer relation r, use the index to look up
tuples in s that satisfy the join condition with tuple tr.
Worst case: buffer has space for only one page of r, and, for each
tuple in r, we perform an index lookup on s.
Cost of the join: br (tT + tS) + nr c
Where c is the cost of traversing index and fetching all matching s
tuples for one tuple or r
c can be estimated as cost of a single selection on s using the join
condition.
If indices are available on join attributes of both r and s,
use the relation with fewer tuples as the outer relation.
 Example of Nested-Loop Join Costs
Compute student takes, with student as the outer relation.
Let takes have a primary B+-tree index on the attribute ID, which
contains 20 entries in each index node.
Since takes has 10,000 tuples, the height of the tree is 4, and one
more access is needed to find the actual data
student has 5000 tuples
Cost of block nested loops join
400*100 + 100 = 40,100 block transfers + 2 * 100 = 200 seeks
assuming worst case memory
may be significantly less with more memory
Cost of indexed nested loops join
100 + 5000 * 5 = 25,100 block transfers and seeks.
CPU cost likely to be less than that for block nested loops join
 Hash-Join
Applicable for equi-joins and natural joins.
A hash function h is used to partition tuples of both relations
The basic idea is to partition the tuples of each of the relations into sets that
have the same hash value on the join attributes.
h maps JoinAttrs values to {0, 1, ..., n}, where JoinAttrs denotes the common
attributes of r and s used in the natural join.
r0, r1, . . ., rn denote partitions of r tuples
Each tuple tr r is put in partition ri where i = h(tr [JoinAttrs]).
r0,, r1. . ., rn denotes partitions of s tuples
Each tuple ts s is put in partition si, where i = h(ts [JoinAttrs]).

Note: In book, ri is denoted as Hri, si is denoted as Hsi and

n is denoted as nh.
Hash-Join (Cont.)
 Hash-Join (Cont.)
r tuples in ri need only to be compared with s tuples in si

Need not be compared with s tuples in any other partition, since:

an r tuple and an s tuple that satisfy the join condition will have
the same value for the join attributes.
If that value is hashed to some value i, the r tuple has to be in ri
and the s tuple in si.
For example, if d is a tuple in student, c a tuple in takes, and h a hash function
on the ID attributes of the tuples, then d and c must be tested only if h(c) =
h(d).
If h(c) <> h(d), then c and d must have different values for ID.
However, if h(c) = h(d), we must test c and d to see whether the values in their
join attributes are the same, since it is possible that c and d have different iids
that have the same hash value.
 Hash-Join Algorithm

The hash-join of r and s is computed as follows.

1. Partition the relation s using hashing function h. When
partitioning a relation, one block of memory is reserved as
the output buffer for each partition.
2. Partition r similarly.
3. For each i:
(a) Load si into memory and build an in-memory hash index
on it using the join attribute. This hash index uses a
different hash function than the earlier one h.
(b) Read the tuples in ri from the disk one by one. For each
tuple tr locate each matching tuple ts in si using the in-
memory hash index. Output the concatenation of their
attributes.
Relation s is called the build input and r is called the probe input.
 Hash-Join algorithm (Cont.)
The value n and the hash function h is chosen such that each si
should fit in memory.
Typically n is chosen as bs/M * f where f is a fudge factor,
typically around 1.2
The probe relation partitions ri need not fit in memory
Recursive partitioning required if number of partitions n is greater
than number of pages M of memory.
instead of partitioning n ways, use M 1 partitions for s
Further partition the M 1 partitions using a different hash
function
Use same partitioning method on r
Rarely required: e.g., with block size of 4 KB, recursive
partitioning not needed for relations of < 1GB with memory size
of 2MB, or relations of < 36 GB with memory of 12 MB
 Hash-Join algorithm (Cont.)

For hash join algorithm, if we consider a memory

size of 256 megabytes, divided into 512-kilobyte
blocks. What size of relation can be partitioned by
using memory of this size without recursive
partitioning?
Solution:
Memory size=256 MB= 228
Block Size= 512 KB= 219
Number of black in memory= 228-19 =29 blocks
Which can partition a relation of size up to 29 29 blocks = 218
block, or a relation of size 237 bytes or 128 gigabytes

Database System Concepts - 6th Edition 12.30 Silberschatz, Korth and Sudarshan
 Handling of Overflows

Partitioning is said to be skewed if some partitions have significantly

more tuples than some others
Hash-table overflow occurs in partition si if si does not fit in memory.
Reasons could be
Many tuples in s with same value for join attributes
Bad hash function
Overflow resolution can be done in build phase
Partition si is further partitioned using different hash function.
Partition ri must be similarly partitioned.
Overflow avoidance performs partitioning carefully to avoid overflows
during build phase
E.g. partition build relation into many partitions, then combine them
Both approaches fail with large numbers of duplicates
Fallback option: use block nested loops join on overflowed partitions
 Cost of Hash-Join

If recursive partitioning is not required: cost of hash join is

3(br + bs) +4 nh block transfers +
2( br / bb + bs / bb ) seeks
If recursive partitioning required:
number of passes required for partitioning build relation s to
less than M blocks per partition is log M/bb 1(bs/M)
best to choose the smaller relation as the build relation.
Total cost estimate is:
2(br + bs) log M/bs 1(bs/M) + br + bs block transfers +
2( br / bb + bs / bb ) log M/bb 1(bs/M) seeks
If the entire build input can be kept in main memory no
partitioning is required
Cost estimate goes down to br + bs.
 Example of Cost of Hash-Join
instructor teaches

Assume that memory size is 20 blocks

binstructor= 100 and bteaches = 400.

instructor is to be used as build input. Partition it into five

partitions, each of size 20 blocks. This partitioning can be done
in one pass.
Similarly, partition teaches into five partitions,each of size 80.
This is also done in one pass.
Therefore total cost, ignoring cost of writing partially filled
blocks:
3(100 + 400) = 1500 block transfers +
2( 100/3 + 400/3 ) = 336 seeks
End of Chapter