1. CPSC-608 Database Systems
Fall 2018
Instructor: Jianer Chen
Office: HRBB 315C
Phone:
Notes #20

2. parse tree-lqp convertor
Query Optimization
An input database program P
Prepare a collection C of efficient algorithms for operations in relational algebra;
parser
View processing,
Semantic checking
parse tree
preprocessing
parse tree
parse tree-lqp convertor
logic query plan
push selections,
group joins
apply logic laws
logic query plan
reduce the size of
intermediate results
Optimization via logic and size
logic query plan
Lqp-pqp convertor
take care of issues in optimization and security.
physical query plan
choices of algorithms,
data structures, and
computational modes
Optimization via algorithms and cost
Machine executable code

3. Improving logic plan via relation size
Major Steps:
Collect size parameters for stored relations: T(R), B(R), V(R,A) (the # of different values on attribute A)
Set up estimation rules for size parameters on relational algebraic operators;
Using logic laws to convert a logic query into the one that minimizes the (estimated) sizes of intermediate relations.

4. Estimating size parameters (T,B,V)
π, τ,×: size parameters can be calculated precisely
δ : T(δ(R)) = min{ T(R)/2, ΠAV(R,A) }
γ : T(γ(R)) = min{ T(R)/2, Πgrouping AV(R,A) }
σA=c: T(σA=c(R)) = T(R)/V(R,A)
σA<c: T(σA<c(R)) = T(R)/3
∩ : T(R ∩ S) = T(S)/2 (assume S is smaller)
U : T(R U S) = T(R)+T(S)/2 (assume S is smaller)
‒ : T(R ‒ S) = T(R) ‒ T(S)/2
: T(R S) = T(R)T(S)/max{V(R,A),V(S,A)}
C : T(R CS) = T(σC(R×S))

5. Estimating size parameters (T,B,V)
π, τ,×: size parameters can be calculated precisely
δ : T(δ(R)) ⟹ B(δ(R))
γ : T(γ(R)) ⟹ B(γ(R))
σA=c: T(σA=c(R)) ⟹ B(σA=c(R))
σA<c: T(σA<c(R)) ⟹ B(σA<c(R))
∩ : T(R ∩ S) ⟹ B(R ∩ S)
U : T(R U S) ⟹ B(R U S)
‒ : T(R ‒ S) ⟹ B(R ‒ S)
: T(R S) ⟹ B(R S)
C : T(R CS) ⟹ B(R CS)
B(W) = T(W)/#tuples-per-block

6. Estimating size parameters (T,B,V)
π, τ,×: size parameters can be calculated precisely
δ : V(δ(R),A) = V(R,A)
γ : V(γ(R),A) = V((R,A) (A is a grouping attribute)
σA=c: V(σA=c(R),B) = V(R,B), V(σA=c(R),A) = 1
σA<c: V(σA<c(R),B) = V(R,B), V(σA<c(R),A) = V(R,A)/3
∩ : V(R∩S,A) = V(S,A)/2 (assume V(R,A) ≥ V(S,A))
U : V(RUS,A) = V(R,A)+V(S,A)/2 (assume V(R,A) ≥ V(S,A))
‒ : V(R‒S,A) = V(R,A) ‒ max{R(R,A)/2,T(S,A)/2}
: V(R S,A) = min{V(R,A),V(S,A)} (A is a shared attribute)
V(R S,A) = max{V(R,A),V(S,A)} (A is non-shared)
C: V(R CS,A) = V(σC(R×S),A)

7. Logic Plan Improvement for Join via Size
Two techniques:
Estimating sizes of immediate relations
For natural join:
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)}
also note:
V(R(X, y) S(y, Z), y) = min{V(R, y), V(S, y)}
V(R(X, y) S(y, Z), z) = V(R, z) or V(S, z) for z ≠ y
Consider different order of an operation
(((R S) T) U) = (R U) (S T)

8. Consider: A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = 200
B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = 1000
D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
We want to have a good LQP for A B C D

9. Left-deep join tree

10. Left-deep join tree ? ? ? ?

11. Left-deep join tree (all 4! = 24 permutations)B C D A B D C A C B D A C D B A D B C A D C B B A C D B A D C B C A D B C D A B D A C B D C A C A B D C A D B C B A D C B D A C D A B C D B A D A B C D A C B D B A C D B C A D C A B D C B A

12. Left-deep join tree (all 4! = 24 permutations)B C D A B D C A C B D A C D B A D B C A D C B B A C D B A D C B C A D B C D A B D A C B D C A C A B D C A D B C B A D C B D A C D A B C D B A D A B C D A C B D B A C D B C A D C A B D C B A

13. Left-deep join tree (all 4! = 24 permutations)B C D A B D C A C B D A C D B A D B C A D C B B A C D B A D C B C A D B C D A B D A C B D C A C A B D C A D B C B A D C B D A C D A B C D B A D A B C D A C B D B A C D B C A D C A B D C B A

14. Left-deep join tree (all 4! = 24 permutations)B C D A B D C A C B D A C D B A D B C A D C B B A C D B A D C B C A D B C D A B D A C B D C A C A B D C A D B C B A D C B D A C D A B C D B A D A B C D A C B D B A C D B C A D C A B D C B A

15. Left-deep join tree (all 4! = 24 permutations)B C D A B D C A C B D A C D B A D B C A D C B B A C D B A D C B C A D B C D A B D A C B D C A C A B D C A D B C B A D C B D A C D A B C D B A D A B C D A C B D B A C D B C A D C A B D C B A

16. Left-deep join tree D C C A A B B D
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = 200
B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = 1000
D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y)⋈S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)}
T(R(X, y1,y2)⋈S(y1, y2, Z)) = T(R)•T(S)/max{V(R, y1), V(S, y1)}max{V(R, y2), V(S, y2)}

17. Left-deep join tree D C C A A B B D
5000
V(*, c) = 500
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = 200
B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = 1000
D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y)⋈S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)}
T(R(X, y1,y2)⋈S(y1, y2, Z)) = T(R)•T(S)/max{V(R, y1), V(S, y1)}max{V(R, y2), V(S, y2)}

18. Left-deep join tree D C C A A B B D
10000
5000
V(*, c) = 500
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = 200
B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = 1000
D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y)⋈S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)}
T(R(X, y1,y2)⋈S(y1, y2, Z)) = T(R)•T(S)/max{V(R, y1), V(S, y1)}max{V(R, y2), V(S, y2)}

19. Left-deep join tree D C C A A B B D
10000
5000
V(*, c) = 500
cost = 15000
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = 200
B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = 1000
D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y)⋈S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)}
T(R(X, y1,y2)⋈S(y1, y2, Z)) = T(R)•T(S)/max{V(R, y1), V(S, y1)}max{V(R, y2), V(S, y2)}

20. Left-deep join tree D C C A A B B D
10000
50000
5000
V(*, c) = 500
V(*, a) = 50
V(*,b) = 100
cost = 15000
cost =
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = 200
B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = 1000
D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y)⋈S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)}
T(R(X, y1,y2)⋈S(y1, y2, Z)) = T(R)•T(S)/max{V(R, y1), V(S, y1)}max{V(R, y2), V(S, y2)}

21. Left-deep join tree D C C A A B B D
10000
50000
5000
V(*, c) = 500
V(*, a) = 50
V(*,b) = 100
cost = 15000
cost =
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = 200
B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = 1000
D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y)⋈S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)}
T(R(X, y1,y2)⋈S(y1, y2, Z)) = T(R)•T(S)/max{V(R, y1), V(S, y1)}max{V(R, y2), V(S, y2)}

22. Left-deep join tree (all 4! = 24 permutations)B C D A B D C A C B D A C D B A D B C A D C B
15000
55000
60000
20000 B A C D B A D C B C A D B C D A B D A C B D C A
12000
4000 C A B D C A D B C B A D C B D A C D A B C D B A
11000
3000 D A B C D A C B D B A C D B C A D C A B D C B A

23. Left-deep join tree (all 4! = 24 permutations)B C D A B D C A C B D A C D B A D B C A D C B
15000
55000
60000
20000 B A C D B A D C B C A D B C D A B D A C B D C A
12000
4000 C A B D C A D B C B A D C B D A C D A B C D B A
11000
3000 D A B C D A C B D B A C D B C A D C A B D C B A

24. Left-deep tree: general algorithm
Input: n relations R1, R2, …, Rn
Output: the best left-deep join of R1, R2, …, Rn
Construct a left-deep tree T of n leaves;
For each P of the permutations of the n relations R1, R2, …, Rn Do
assign the n relations to the leaves of T in order of P;
evaluate the cost of the plan;
3. Pick the plan with the permutation that gives the minimum cost.

25. Dynamic Programming
Consider all tree structures.

26. Dynamic Programming Consider all tree structures.
Again consider A B C D
Five tree structures:
Each of (a)-(d) has 12 different assignments, and (e) has 3 different assignments. So totally there are 51 different ways to join the 4 relations.
Too many when the number of relations is relatively large.
(a)
(b)
(c)
(d)
(e)

27. Dynamic Programming
Consider D D D D C B A A A B A C C B B C

28. Dynamic Programming
Consider D D D D C B A A A B A C C B B C

29. Dynamic Programming Consider
We really only need to find the best way to join
A B C , then join D with this best join. D D D D C B A A A B A C C B B C

30. Dynamic Programming Consider
We really only need to find the best way to join
A B C , then join D with this best join.
How do we find the best join of A B C? D D D D C B A A A B A C C B B C

31. Dynamic Programming Consider
We really only need to find the best way to join
A B C , then join D with this best join.
How do we find the best join of A B C?
We consider all possible ways:
(A B) C, (A C) B, (B C) A. D D D D C B A A A B A C C B B C

32. Dynamic programming: general algorithm
Input: n relations R1, R2, …, Rn
Output: the best join of R1, R2, …, Rn
FOR each Ri DO {cost(Ri) = 0; size(Ri) = 0};
FOR each pair of Ri and Rj DO {cost(Ri, Rj) = 0; compute size(Ri Rj)};
FOR k = 3 TO n DO
FOR any k relations S1, S2, …, Sk of R1, R2, …, Rn DO
FOR each partition P = {(Si1, …, Sij ), (Sij+1,…, Sik )} of S1, S2, …, Sk DO
cost(P) = cost(Si1, …, Sij) + size(Si1 … Sij) +
cost(Sij+1, …, Sik) + size(Sij+1 … Sik );
let cost(S1, S2, …, Sk) be the smallest cost(P) among the above partitions;
compute size(S1 S2 … Sk) (and remember this partition P);
Return cost(R1, R2, …, Rn).

33. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0

34. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000

35. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
A, B, D
A, C, D
B, C, D

36. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
A, B, D
A, C, D
B, C, D

37. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
A, B, D
A, C, D
B, C, D D C B B C B D C D

38. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
A, B, D
A, C, D
B, C, D D C B B C B D C D

39. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
A, B, D
A, C, D
B, C, D D C B B C B D C D

40. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
A, B, D
A, C, D
B, C, D
2000 D C B B C B D C D

41. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
A, B, D
A, C, D
B, C, D
2000 D C B B C B D C D
2000

42. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
A, B, D
A, C, D
B, C, D
2000
1000 D C B B C B D C D
2000
1000

43. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
A, B, D
A, C, D
B, C, D
2000
1000 D C B B C B D C D
2000
1000

44. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
A, B, D
A, C, D
B, C, D
cost = 1000
size = 2000 B C D

45. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
cost = 2000
size = 10000
A, B, D
cost = 5000
size = 50000
A, C, D
cost = 1000
size = 10000
B, C, D
cost = 1000
size = 2000 B C D

46. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
cost = 2000
size = 10000
A, B, D
cost = 5000
size = 50000
A, C, D
cost = 1000
size = 10000
B, C, D
cost = 1000
size = 2000 B C D
A, B, C, D

47. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
cost = 2000
size = 10000
A, B, D
cost = 5000
size = 50000
A, C, D
cost = 1000
size = 10000
B, C, D
cost = 1000
size = 2000 B C D
A, B, C, D A
{B,C,D} B
{A,C,D} C
{A,B,D} D
{A,B,C}
{A,B}
{C,D}
{A,C}
{B,D}
{A,D}
{B,C}

48. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
cost = 2000
size = 10000
A, B, D
cost = 5000
size = 50000
A, C, D
cost = 1000
size = 10000
B, C, D
cost = 1000
size = 2000 B C D
A, B, C, D A
{B,C,D} B
{A,C,D} C
{A,B,D} D
{A,B,C}
{A,B}
{C,D}
{A,C}
{B,D}
{A,D}
{B,C}
3000

49. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
cost = 2000
size = 10000
A, B, D
cost = 5000
size = 50000
A, C, D
cost = 1000
size = 10000
B, C, D
cost = 1000
size = 2000 B C D
A, B, C, D A
{B,C,D} B
{A,C,D} C
{A,B,D} D
{A,B,C}
{A,B}
{C,D}
{A,C}
{B,D}
{A,D}
{B,C}
3000
6000

50. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
cost = 2000
size = 10000
A, B, D
cost = 5000
size = 50000
A, C, D
cost = 1000
size = 10000
B, C, D
cost = 1000
size = 2000 B C D
A, B, C, D A
{B,C,D} B
{A,C,D} C
{A,B,D} D
{A,B,C}
{A,B}
{C,D}
{A,C}
{B,D}
{A,D}
{B,C}
3000
11000
55000
12000
6000
12000

51. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
cost = 2000
size = 10000
A, B, D
cost = 5000
size = 50000
A, C, D
cost = 1000
size = 10000
B, C, D
cost = 1000
size = 2000 B C D
A, B, C, D A
{B,C,D} B
{A,C,D} C
{A,B,D} D
{A,B,C}
{A,B}
{C,D}
{A,C}
{B,D}
{A,D}
{B,C}
3000
11000
55000
12000
6000
12000

52. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
cost = 2000
size = 10000
A, B, D
cost = 5000
size = 50000
A, C, D
cost = 1000
size = 10000
B, C, D
cost = 1000
size = 2000 B C D
A, B, C, D A A
{B,C,D} B
{A,C,D} C
{A,B,D} D
{A,B,C}
{A,B}
{C,D}
{A,C}
{B,D}
{A,D}
{B,C}
3000
11000
55000
12000
6000
12000

53. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
cost = 2000
size = 10000
A, B, D
cost = 5000
size = 50000
A, C, D
cost = 1000
size = 10000
B, C, D
cost = 1000
size = 2000 B C D
A, B, C, D A A
{B,C,D} B
{A,C,D} C
{A,B,D} D
{A,B,C}
{A,B}
{C,D}
{A,C}
{B,D}
{A,D}
{B,C}
3000
11000
55000
12000
6000
12000

54. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
cost = 2000
size = 10000
A, B, D
cost = 5000
size = 50000
A, C, D
cost = 1000
size = 10000
B, C, D
cost = 1000
size = 2000 B C D
A, B, C, D A B C D A
{B,C,D} B
{A,C,D} C
{A,B,D} D
{A,B,C}
{A,B}
{C,D}
{A,C}
{B,D}
{A,D}
{B,C}
3000
11000
55000
12000
6000
12000

55. Dynamic Programming: Example
A(a, b): T(A) = 1000, V(A, a) = 100, V(A, b) = B(b, c): T(B) = 1000, V(B, b) = 100, V(B, c) = 500
C(c, d): T(C) = 1000, V(C, c) = 20, V(C, d) = D(d, a): T(D) = 1000, V(D, d) = 1000, V(D, a) = 50
T(R(X, y) S(y, Z)) = T(R)•T(S)/max{V(R, y), V(S, y)} A
cost = 0
size = 0 B
cost = 0
size = 0 C
cost = 0
size = 0 D
cost = 0
size = 0
A, B
cost = 0
size = 5000
A, C
cost = 0
size =
A, D
cost = 0
size = 10000
B, C
cost = 0
size = 2000
B, D
cost = 0
size =
C, D
cost = 0
size = 1000
A, B, C
cost = 2000
size = 10000
A, B, D
cost = 5000
size = 50000
A, C, D
cost = 1000
size = 10000
B, C, D
cost = 1000
size = 2000
A, B, C, D
cost = 3000 A B C D A
{B,C,D} B
{A,C,D} C
{A,B,D} D
{A,B,C}
{A,B}
{C,D}
{A,C}
{B,D}
{A,D}
{B,C}
3000
11000
55000
12000
6000
12000

56. Summary: Logic Plan Improvement for Join via Size:
Estimating sizes of immediate relations
Consider different order of an operation
left-deep tree
dynamic programming