CHAPTER

12
Query Processing

Practice Exercises

12.1 Assume (for simplicity in this exercise) that only one tuple fits in a block
and memory holds at most 3 blocks. Show the runs created on each pass
of the sort-merge algorithm, when applied to sort the following tuples on
the first attribute: (kangaroo, 17), (wallaby, 21), (emu, 1), (wombat, 13),
(platypus, 3), (lion, 8), (warthog, 4), (zebra, 11), (meerkat, 6), (hyena, 9),
(hornbill, 2), (baboon, 12).
Answer: We will refer to the tuples (kangaroo, 17) through (baboon, 12)
using tuple numbers t1 through t12 . We refer to the j th run used by the i th
pass, as ri j . The initial sorted runs have three blocks each. They are:

r11 = {t3 , t1 , t2 }
r12 = {t6 , t5 , t4 }
r13 = {t9 , t7 , t8 }
r14 = {t12 , t11 , t10 }

Each pass merges three runs. Therefore the runs after the end of the first
pass are:

r21 = {t3 , t1 , t6 , t9 , t5 , t2 , t7 , t4 , t8 }
r22 = {t12 , t11 , t10 }

At the end of the second pass, the tuples are completely sorted into one
run:

r31 = {t12 , t3 , t11 , t10 , t1 , t6 , t9 , t5 , t2 , t7 , t4 , t8 }

12.2 Consider the bank database of Figure 12.13, where the primary keys are
underlined, and the following SQL query:
1
2 Chapter 12 Query Processing

select T.branch name

from branch T, branch S
where T.assets > S.assets and S.branch city = Brooklyn

Write an efficient relational-algebra expression that is equivalent to this

query. Justify your choice.
Answer:
Query:

5T.branch name ((5branch name, assets (r T (branch))) 1T.assets > S.assets

(5assets (s(branch city = Brooklyn) (r S (branch)))))

This expression performs the theta join on the smallest amount of data
possible. It does this by restricting the right hand side operand of the join
to only those branches in Brooklyn, and also eliminating the unneeded
attributes from both the operands.
12.3 Let relations r1 (A, B, C) and r2 (C, D, E) have the following properties: r1
has 20,000 tuples, r2 has 45,000 tuples, 25 tuples of r1 fit on one block, and
30 tuples of r2 fit on one block. Estimate the number of block transfers and
seeks required, using each of the following join strategies for r1 1 r2 :
a. Nested-loop join.
b. Block nested-loop join.
c. Merge join.
d. Hash join.
Answer:
r1 needs 800 blocks, and r2 needs 1500 blocks. Let us assume M pages
of memory. If M > 800, the join can easily be done in 1500 + 800 disk
accesses, using even plain nested-loop join. So we consider only the case
where M 800 pages.
a. Nested-loop join:
Using r1 as the outer relation we need 20000 1500 + 800 =
30, 000, 800 disk accesses, if r2 is the outer relation we need 45000
800 + 1500 = 36, 001, 500 disk accesses.

b. Block nested-loop join:

800
If r1 is the outer relation, we need M1 1500 + 800 disk accesses,
1500
if r2 is the outer relation we need M1 800 + 1500 disk accesses.

c. Merge-join:
Assuming that r1 and r2 are not initially sorted on the join key, the to-
tal sorting cost inclusive of the output is Bs = 1500(2log M1 (1500/M)+
 Exercises 3

2) + 800(2log M1 (800/M) + 2) disk accesses. Assuming all tuples

with the same value for the join attributes fit in memory, the total
cost is Bs + 1500 + 800 disk accesses.
d. Hash-join:
We assume no overflow occurs. Since r1 is smaller, we use it as the
build relation and r2 as the probe relation. If M > 800/M, i.e. no need
for recursive partitioning, then the cost is 3(1500 + 800) = 6900 disk
accesses, else the cost is 2(1500 + 800)log M1 (800) 1 + 1500 + 800
disk accesses.
12.4 The indexed nested-loop join algorithm described in Section 12.5.3 can be
inefficient if the index is a secondary index, and there are multiple tuples
with the same value for the join attributes. Why is it inefficient? Describe
a way, using sorting, to reduce the cost of retrieving tuples of the inner
relation. Under what conditions would this algorithm be more efficient
than hybrid merge join?
Answer:
If there are multiple tuples in the inner relation with the same value for
the join attributes, we may have to access that many blocks of the inner
relation for each tuple of the outer relation. That is why it is inefficient.
To reduce this cost we can perform a join of the outer relation tuples
with just the secondary index leaf entries, postponing the inner relation
tuple retrieval. The result file obtained is then sorted on the inner relation
addresses, allowing an efficient physical order scan to complete the join.
Hybrid merge join requires the outer relation to be sorted. The above
algorithm does not have this requirement, but for each tuple in the outer
relation it needs to perform an index lookup on the inner relation. If the
outer relation is much larger than the inner relation, this index lookup
cost will be less than the sorting cost, thus this algorithm will be more
efficient.
12.5 Let r and s be relations with no indices, and assume that the relations
are not sorted. Assuming infinite memory, what is the lowest-cost way
(in terms of I/O operations) to compute r 1 s? What is the amount of
memory required for this algorithm?
Answer:
We can store the entire smaller relation in memory, read the larger relation
block by block and perform nested loop join using the larger one as the
outer relation. The number of I/O operations is equal to br + b s , and
memory requirement is min(br , b s ) + 2 pages.
12.6 Consider the bank database of Figure 12.13, where the primary keys are
underlined. Suppose that a B+ -tree index on branch city is available on
relation branch, and that no other index is available. List different ways to
handle the following selections that involve negation:
a. s(branch city<Brooklyn) (branch)
4 Chapter 12 Query Processing

b. s(branch city=Brooklyn) (branch)

c. s(branch city<Brooklyn assets<5000) (branch)
Answer:
a. Use the index to locate the first tuple whose branch city field has
value Brooklyn. From this tuple, follow the pointer chains till the
end, retrieving all the tuples.
b. For this query, the index serves no purpose. We can scan the file
sequentially and select all tuples whose branch city field is anything
other than Brooklyn.
c. This query is equivalent to the query

s(br anch city Brooklyn assets<5000) (bra nch)

Using the branch-city index, we can retrieve all tuples with branch-city
value greater than or equal to Brooklyn by following the pointer
chains from the first Brooklyn tuple. We also apply the additional
criteria of a ssets < 5000 on every tuple.
12.7 Write pseudocode for an iterator that implements indexed nested-loop
join, where the outer relation is pipelined. Your pseudocode must define
the standard iterator functions open(), next(), and close(). Show what state
information the iterator must maintain between calls.
Answer: Let outer be the iterator which returns successive tuples from
the pipelined outer relation. Let inner be the iterator which returns suc-
cessive tuples of the inner relation having a given value at the join at-
tributes. The inner iterator returns these tuples by performing an index
lookup. The functions IndexedNLJoin::open, IndexedNLJoin::close and
IndexedNLJoin::next to implement the indexed nested-loop join iterator
are given below. The two iterators outer and inner, the value of the last
read outer relation tuple tr and a flag done r indicating whether the end of
the outer relation scan has been reached are the state information which
need to be remembered by IndexedNLJoin between calls.

IndexedNLJoin::open()
begin
outer.open();
inner.open();
done r := false;
if(outer.next() 6= false)
move tuple from outers output buffer to tr ;
else
done r := true;
end
 Exercises 5

IndexedNLJoin::close()
begin
outer.close();
inner.close();
end

boolean IndexedNLJoin::next()
begin
while(done r )
begin
if(inner.next(tr [JoinAttrs]) 6= false)
begin
move tuple from inners output buffer to ts ;
compute tr 1 ts and place it in output buffer;
return true;
end
else
if(outer.next() 6= false)
begin
move tuple from outers output buffer to tr ;
rewind inner to first tuple of s;
end
else
done r := true;
end
return false;
end

12.8 Design sort-based and hash-based algorithms for computing the relational
division operation (see Practise Exercises of Chapter 6 for a definition of
the division operation).
Answer: Suppose r (T S) and s(S) be two relations and r s has to be
computed.
For sorting based algorithm, sort relation s on S. Sort relation r on
(T, S). Now, start scanning r and look at the T attribute values of the first
tuple. Scan r till tuples have same value of T. Also scan s simultaneously
and check whether every tuple of s also occurs as the S attribute of r , in
a fashion similar to merge join. If this is the case, output that value of T
and proceed with the next value of T. Relation s may have to be scanned
multiple times but r will only be scanned once. Total disk accesses, after
6 Chapter 12 Query Processing

sorting both the relations, will be |r | + N |s|, where N is the number of

distinct values of T in r.
We assume that for any value of T, all tuples in r with that T value fit in
memory, and consider the general case at the end. Partition the relation r
on attributes in T such that each partition fits in memory (always possible
because of our assumption). Consider partitions one at a time. Build a
hash table on the tuples, at the same time collecting all distinct T values
in a separate hash table. For each value of T, Now, for each value VT of
T, each value s of S, probe the hash table on (VT , s). If any of the values is
absent, discard the value VT , else output the value VT .
In the case that not all r tuples with one value for T fit in memory, partition
r and s on the S attributes such that the condition is satisfied, run the
algorithm on each corresponding pair of partitions ri and si . Output the
intersection of the T values generated in each partition.
12.9 What is the effect on the cost of merging runs if the number of buffer
blocks per run is increased, while keeping overall memory available for
buffering runs fixed?
Answer: Seek overhead is reduced, but the the number of runs that can
be merged in a pass decreases potentially leading to more passes. A value
of b b that minimizes overall cost should be chosen.