cs 4432query processing - lecture 131 cs4432: database systems ii lecture #13 query processing...

CS 4432 query processing - lecture 13 1

CS4432: Database Systems IILecture #13

Query Processing

Professor Elke A. Rundensteiner


Query in SQL Query Plan in Algebra (logical) Other Query Plan in Algebra (logical)


Query plan 1 (in relational algebra)

B,D

R.A=“c” S.E=2 R.C=S.C

XR S


Query plan 2 (in relational algebra)

B,D

R.A = “c” S.E = 2

R S

natural join


Relational algebra optimization

• What are transformation rules ?– preserve equivalence

• What are good transformations?– reduce query execution costs


Rules: Natural joins & cross products & unionR S = S R(R S) T = R (S T)


Note:

• Carry attribute names in results, soorder is not important

• Can also write as trees, e.g.:

T R

R S S T


R x S = S x R(R x S) x T = R x (S x T)

R U S = S U RR U (S U T) = (R U S) U T

Rules: Natural joins & cross products & unionR S = S R(R S) T = R (S T)


Rules: Selects

p1p2(R) =

p1vp2(R)

=

p1 [ p2 (R)]

[ p1 (R)] U [ p2 (R)]


Bags vs. Sets

R = {a,a,b,b,b,c}S = {b,b,c,c,d}RUS = ?

• Option 1 SUMRUS = {a,a,b,b,b,b,b,c,c,c,d}

• Option 2 MAXRUS = {a,a,b,b,b,c,c,d}


Option 2 (MAX) makes this rule work:

p1vp2 (R) = p1(R) U p2(R)

Example: R={a,a,b,b,b,c}P1 satisfied by a,b; P2 satisfied by b,c

p1vp2 (R) = {a,a,b,b,b,c}

p1(R) = {a,a,b,b,b}

p2(R) = {b,b,b,c}

p1(R) U p2 (R) = {a,a,b,b,b,c}


“Sum” option makes more sense:

Senators (……) Rep (……)

T1 = yr,state Senators; T2 = yr,state Reps

T1 Yr State T2 Yr State 97 CA 99 CA 99 CA 99 CA 98 AZ 98 CA

Union?


Executive Decision

-> Use “SUM” option for bag unions-> Some rules cannot be used for

bags


Rules: Project

Let: X = set of attributesY = set of attributesXY = X U Y

xy (R) = x [y (R)]


Let p = predicate with only R attribs q = predicate with only S attribs m = predicate with only R,S attribs

p (R S) =

q (R S) =

Rules: combined

[p (R)] S

R [q (S)]


Some Rules can be Derived:

pq (R S) =

pqm (R S) =

pvq (R S) =

Rules: combined (continued)


Do one, others for homework:

pq (R S) = [p (R)] [q (S)]

pqm (R S) =

m [(p R) (q S)]pvq (R S) =

[(p R) S] U [R (q S)]


--> Derivation for first one:

pq (R S) =

p [q (R S) ] =

p [ R q (S) ] =

[p (R)] [q (S)]


Rules: combined

Let x = subset of R attributes z = attributes in predicate P

(subset of R attributes)

x[p (R) ] = {p [ x (R) ]} x xz


Rules: combined

Let x = subset of R attributes y = subset of S attributes

z = intersection of R,S attributes

xy (R S) =

xy{[xz (R) ] [yz (S) ]}


xy {p (R S)} =

xy {p [xz’ (R) yz’ (S)]}

z’ = z U {attributes used in P }


Rules for combined with X

similar...

e.g., p (R X S) = ?


p(R U S) = p(R) U p(S)

p(R - S) = p(R) - S = p(R) - p(S)

Rules U combined:


p1p2 (R) p1 [p2 (R)]

p (R S) [p (R)] S

R S S R

x [p (R)] x {p [xz (R)]}

Which are “good” transformations?


Conventional wisdom: do projects early

Example: R(A,B,C,D,E) x={E} P: (A=3) (B=“cat”)

x {p (R)} vs. E {p{ABE(R)}}


What if we have A, B indexes?

B = “cat” A=3

Intersect pointers to get

pointers to matching tuples

But


Bottom line:

• No transformation is always good• Usually good: early selections


In textbook: more transformations

• Eliminate common sub-expressions• Other operations, such as,

duplicate elimination and others.

cs 4432query processing - lecture 131 cs4432: database systems ii lecture #13 query processing...

Documents