CS 525: Advanced Database Organization. Execution Plan. Query Execution. How to estimate costs. 10: Query Execution. Estimating IOs: Boris Glavic

Transcription

1 SQL query CS 55: Advanced Database Organization 0: Query Execution Boris Glavic Slides: adapted from a course taught by Hector Garcia-Molina, Stanford InfoLab CS 55 Notes 0 - Query Execution parse parse tree convert logical query plan apply laws improved l.q.p estimate result sizes l.q.p. +sizes consider physical plans {P,P,..} statistics CS 55 Notes 0 - Query Execution answer execute Pi pick best {(P,C),(P,C)...} estimate costs Query Execution Here only: how to implement operators what are the costs of implementations how to implement queries Data flow between operators Next part: How to choose good plan Execution Plan A tree (DAG) of physical operators that implement a query May use indices May create temporary relations May create indices on the fly May use auxiliary operations such as sorting CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution How to estimate costs If everything fits into memory Standard computational complexity If not Assume fixed memory available for buffering pages Count I/O operations eal systems combine this with CPU estimations Estimating IOs: Count # of disk blocks that must be read (or written) to execute query plan CS 55 Notes 0 - Query Execution 5 CS 55 Notes 0 - Query Execution 6

2 To estimate costs, we may have additional parameters: B() = # of blocks containing tuples f() = max # of tuples of per block M = # memory blocks available To estimate costs, we may have additional parameters: B() = # of blocks containing tuples f() = max # of tuples of per block M = # memory blocks available HT(i) = # levels in index i LB(i) = # of leaf blocks in index i CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution 8 Clustered index Index that allows tuples to be read in an order that corresponds to physical order A A index CS 55 Notes 0 - Query Execution 9 Operators Overview (External) Sorting Joins (Nested Loop, Merge, Hash, ) Aggregation (Sorting, Hash) Selection, Projection (Index, Scan) Union, Set Difference Intersection Duplicate Elimination CS 55 Notes 0 - Query Execution 0 Operator Profiles Algorithm In-memory complexity: e.g., O(n ) Memory requirements untime based on available memory #I/O if operation needs to go to disk Disk space needed Prerequisites Conditions under which the operator can be applied CS 55 Notes 0 - Query Execution Execution Strategies Compiled Translate into C/C++/Assembler code Compile, link, and execute code Interpreted Generic operator implementations Generic executor Interprets query plan CS 55 Notes 0 - Query Execution

3 Virtual Machine Approach Implement virtual machine of low-level DBMS operations Compile query into machine-code for that machine Iterator Model Need to be able to combine operators in different ways E.g., join inputs may be scans, or outputs of other joins, -> define generic interface for operators be able to arbitrarily compose complex plans from a small set of operators CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution Iterator Model - Interface Open Prepare operator to read inputs Close Close operator and clean up Next eturn next result tuple Query Execution Iterator Model Iterator open close next Iterator open close next Iterator open close next Iterator open close next CS 55 Notes 0 - Query Execution 5 CS 55 Notes 0 - Query Execution 6 Query Execution Iterator Model Key Call Iterator open close next Query Execution Iterator Key Model eturn Tuple Call Iterator open close next Iterator open close next Iterator open close next Iterator open close next Iterator open close next Iterator open close next Iterator open close next CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution 8

4 Parallelism Iterator Model Pull-based query execution Potential types of parallelism Inter-query (every multiuser system) Intra-operator Inter-operator Intra-Operator Parallelism Execute portions of an operator in parallel Merge-Sort Assign a processor to each merge phase Scan Partition tables Each process scans one partition CS 55 Notes 0 - Query Execution 9 CS 55 Notes 0 - Query Execution 0 Inter-Operator Parallelism Each process executes one or more operators Pipelining Push-based query execution Chain operators to directly produce results Pipeline-breakers Operators that need to consume the whole input (or large parts) before producing outputs Pipelining Communication Queues Operators push their results to queues Operators read their inputs from queues Direct call Operator calls its parent in the tree with results Within one process CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution Key Append to queue Dequeue Direct Call Pipelines Pipeline-breakers Sorting All operators that apply sorting Aggregation Set Difference Some implementations of Join Union CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution

5 Operators Overview (External) Sorting Joins (Nested Loop, Merge, Hash, ) Aggregation (Sorting, Hash) Selection, Projection (Index, Scan) Union, Set Difference Intersection Duplicate Elimination Sorting Why do we want/need to sort Query requires sorting (ODE BY) Operators require sorted input Merge-join Aggregation by sorting Duplicate removal using sorting CS 55 Notes 0 - Query Execution 5 CS 55 Notes 0 - Query Execution 6 In-memory sorting Algorithms from data structures 0 Quick sort Merge sort Heap sort Intro sort External sorting Problem: Sort N pages of data with M pages of memory Solutions? CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution 8 First Idea Split data into runs of size M Sort each run in memory and write back to disk N/M sorted runs of size M Now what? M M M Merging uns Need to create bigger sorted runs out of sorted smaller runs Divide and Conquer Merge Sort? How to merge two runs that are bigger than M? CS 55 Notes 0 - Query Execution 9 CS 55 Notes 0 - Query Execution 0 5

6 Merging uns using pages Merging uns Merging sorted runs and Need pages One page to buffer pages from One page to buffer pages from One page to buffer the result Whenever this buffer is full, write it to disk read read merge write CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution -Way External Mergesort epeat process until we have one sorted run Each iteration (pass) reads and writes the whole table once: B() I/Os Each pass doubles the run size + log (B() / M) runs B() * ( + log (B() / M) ) I/Os Input Pass 0 Pass Pass Pass CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution N-Way External Mergesort Merging uns How to utilize M buffer during merging? Each pass merges M- runs at once One memory page as buffer for each run #I/Os read read merge write + log M- (B() / M) runs B() *( + log M- (B() / M) ) I/Os M- read CS 55 Notes 0 - Query Execution 5 CS 55 Notes 0 - Query Execution 6 6

7 How many passes do we need? N M= M=9 M=5 M=5 M=05 00,000 0,000 00,000 5,000, ,000, ,000,000,000,000, To put into perspective Scenario Page size KB TB of data (50,000,000) 0MB of buffer for sorting (50) Passes passes CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution 8 Merge In practice would want larger I/O buffer for each run Trade-off between number of runs and efficiency of I/O Improving in-memory merging Merging M runs To choose next element to output Have to compare M elements -> complexity linear in M: O(M) How to improve that? Use priority queue to store current element from each run -> O(log (M)) CS 55 Notes 0 - Query Execution 9 CS 55 Notes 0 - Query Execution 0 Priority Queue Queue for accessing elements in some given order pop-smallest = return and remove smallest element in set Insert(e) = insert element into queue Min-Heap Implementation of priority queue Store elements in a binary tree All levels are full (except leaf level) Heap property Parent is smaller than child Example: {,,, 0 } 0 CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution

8 Min-Heap Insertion insert(e)!. Add element at next free leaf node This may invalidate heap property. If node smaller than parent then Switch node with parent. epeat until ) cannot be applied anymore Min-Heap Dequeue pop-smallest!. eturn oot and use right-most leaf as new root This may invalidate heap property. If node smaller than child then Switch node with smaller child. epeat until ) cannot be applied anymore CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution Insertion Dequeue Insert Insert at first free position estore heap property CS 55 Notes 0 - Query Execution 5 CS 55 Notes 0 - Query Execution 6 Dequeue Min/Max-Heap Complexity Heap is a complete tree Height is O(log (n)) Insertion Maximal height of the tree switches -> O(log (n)) Dequeue Maximal height of the tree switches -> O(log (n)) CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution 8 8

9 Min-Heap Implementation Full tree Use array to implement tree Compute positions Parent(n) = (n- ) / Children(n) = n +, n Merging with Priority Queue CS 55 Notes 0 - Query Execution 9 CS 55 Notes 0 - Query Execution 50 Merging with Priority Queue Merging with Priority Queue CS 55 Notes 0 - Query Execution 5 CS 55 Notes 0 - Query Execution 5 Using a heap to generate runs Using a heap to generate runs ead inputs into heap Until available memory is full eplace elements emove smallest element from heap If larger then last element written of current run then write to current run Else create a new run Add new element from input to heap CS 55 Notes 0 - Query Execution 5 CS 55 Notes 0 - Query Execution 5 9

10 Using a heap to generate runs Using a heap to generate runs CS 55 Notes 0 - Query Execution 55 CS 55 Notes 0 - Query Execution 56 Using a heap to generate runs Using a heap to generate runs CS 55 Notes 0 - Query Execution 5 CS 55 Notes 0 - Query Execution 58 Using a heap to generate runs Using a heap to generate runs CS 55 Notes 0 - Query Execution 59 CS 55 Notes 0 - Query Execution 60 0

11 Using a heap to generate runs Increases the run-length On average by a factor of (see Knuth) Use clustered B+-tree Keys in the B+-tree I are in sort order If B+-tree is clustered traversing the leaf nodes is sequential I/O! K = #keys/leaf node Approach Traverse from root to first leaf: HT(I) Follow sibling pointers: / K ead data blocks: B() CS 55 Notes 0 - Query Execution 6 CS 55 Notes 0 - Query Execution 6 I/O Operations HT(I) + / K + B() I/Os Less than B() = pass external mergesort ->Better than external merge-sort! CS 55 Notes 0 - Query Execution 6 Unclustered B+-tree? Each entry in a leaf node may point to different page of relation For each leaf page we may read up to K pages from relation andom I/O In worst-case we have K * B() K = * B() = 50 merge passes CS 55 Notes 0 - Query Execution 6 Sorting Comparison B() = number of block of M = number of available memory blocks #B = records per page HT = height of B+-tree (logarithmic) K = number of keys per leaf node Property Ext. Mergesort B+ (clustered) B+ (unclustered) untime O (N log M- (N)) O(N) O(N) #I/O (random) B() * ( + log M- (B() / M) ) HT + / K + B() Variants ) Merge with heap ) un generation with heap ) Larger Buffer CS 55 Notes 0 - Query Execution 65 HT + / K + K * #B Memory M (better HT + X) (better HT + X) Disk Space B() 0 0 Operators Overview (External) Sorting Joins (Nested Loop, Merge, Hash, ) Aggregation (Sorting, Hash) Selection, Projection (Index, Scan) Union, Set Difference Intersection Duplicate Elimination CS 55 Notes 0 - Query Execution 66

12 Scan Implements access to a table Combined with selection Probably projection too Variants Sequential Scan through all tuples of relation Index Use index to find tuples that match selection CS 55 Notes 0 - Query Execution 6 Operators Overview (External) Sorting Joins (Nested Loop, Merge, Hash, ) Aggregation (Sorting, Hash) Selection, Projection (Index, Scan) Union, Set Difference Intersection Duplicate Elimination CS 55 Notes 0 - Query Execution 68 Options Transformations: c, c Joint algorithms: Nested loop Merge join Join with index Hash join Outer join algorithms Nested Loop Join (conceptually) for each r do for each s do if (r,s) C then output (r,s) Applicable to: Any join condition C Cross-product CS 55 Notes 0 - Query Execution 69 CS 55 Notes 0 - Query Execution 0 Merge Join (conceptually) () if and not sorted, sort them () i ; j ; While (i T( )) (j T( )) do if { i }.C = { j }.C then outputtuples else if { i }.C > { j }.C then j j+ else if { i }.C < { j }.C then i i+ Applicable to: C is conjunction of equalities or </>: A = B AND AND A n = B n Procedure Output-Tuples While ( { i }.C = { j }.C) (i T( )) do [jj j; while ( { i }.C = { jj }.C) (jj T( )) do [output pair { i }, { jj }; jj jj+ ] i i+ ] CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution

13 Example i {i}.c {j}.c j Index nested loop (Conceptually) For each r do Assume.C index [ X index (, C, r.c) for each s X do output (r,s) pair] Note: X index(rel, attr, value) then X = set of rel tuples with attr = value CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution Hash join (conceptual) Hash function h, range 0 k Buckets for : G 0, G,... G k Buckets for : H 0, H,... H k Applicable to: C is conjunction of equalities A = B AND AND A n = B n Hash join (conceptual) Hash function h, range 0 k Buckets for : G 0, G,... G k Buckets for : H 0, H,... H k Algorithm () Hash tuples into G buckets () Hash tuples into H buckets () For i = 0 to k do match tuples in G i, H i buckets CS 55 Notes 0 - Query Execution 5 CS 55 Notes 0 - Query Execution 6 Simple example hash: even/odd Factors that affect performance Buckets 5 Even: Odd: CS 55 Notes 0 - Query Execution () Tuples of relation stored physically together? () elations sorted by join attribute? () Indexes exist? CS 55 Notes 0 - Query Execution 8

14 Example (a) NL Join elations not contiguous ecall T( ) = 0,000 T( ) = 5,000 S( ) = S( ) =/0 block MEM=0 blocks Example (a) Nested Loop Join elations not contiguous ecall T( ) = 0,000 T( ) = 5,000 S( ) = S( ) =/0 block MEM=0 blocks Cost: for each tuple: [ead tuple + ead ] Total =0,000 [+500]=5,00,000 IOs CS 55 Notes 0 - Query Execution 9 CS 55 Notes 0 - Query Execution 80 Can we do better? Can we do better? Use our memory () ead 00 blocks of () ead all of (using block) + join () epeat until done CS 55 Notes 0 - Query Execution 8 CS 55 Notes 0 - Query Execution 8 Cost: for each chunk: ead chunk: 00 IOs ead : 500 IOs 600 Cost: for each chunk: ead chunk: 00 IOs ead : 500 IOs 600 Total =,000 x 600 = 6,000 IOs 00 CS 55 Notes 0 - Query Execution 8 CS 55 Notes 0 - Query Execution 8

15 Can we do better? Can we do better? E everse join order: Total = 500 x (00 +,000) = 00 5 x,00 = 5,500 IOs CS 55 Notes 0 - Query Execution 85 CS 55 Notes 0 - Query Execution 86 Cost of Block Nested Loop E everse join order: Total = B() x (min(b(), M-) + B()) M- Block-Nested Loop Join (conceptual) for each M- blocks of do read M- blocks of into buffer for each block of do read next block of for each tuple r in block for each tuple s in block if (r,s) C then output (r,s) CS 55 Notes 0 - Query Execution 8 CS 55 Notes 0 - Query Execution 88 Note How much memory for buffering inner and for outer chunks? for inner would minimize I/O But, larger buffer better for I/O M - k M - k M - k k k k k k k CS 55 Notes 0 - Query Execution 89 CS 55 Notes 0 - Query Execution 90 5

16 Example (b) Merge Join Both, ordered by C; relations contiguous Memory Example (b) Merge Join Both, ordered by C; relations contiguous Memory Total cost: ead cost + read cost = =,500 IOs CS 55 Notes 0 - Query Execution 9 CS 55 Notes 0 - Query Execution 9 A a b a c d e 5 Merge Join Example B=C S B Output: (a,,,x) S C D Z Z S x y e 6 q d A Merge Join Example B=C S B a b Z a c d e 5 Output: (b,,,x) S C D Z S x y e 6 q d CS 55 Notes 0 - Query Execution 9 CS 55 Notes 0 - Query Execution 9 Merge Join Example B=C S.B > S.C: advance Z S S A B C D a Z S x b y a Z e c 6 q d d e 5 A Merge Join Example B=C S B Output: (a,,,y) S a b Z S a Z c d e 5 C D x y e 6 q d CS 55 Notes 0 - Query Execution 95 CS 55 Notes 0 - Query Execution 96 6

17 A Merge Join Example B=C S B Output: (a,,,e) S a b a Z Z S c d e 5 C D x y e 6 q d Merge Join Example B=C S.B > S.C: advance Z S S A B C D a x b y a Z S e c Z 6 q d d e 5 CS 55 Notes 0 - Query Execution 9 CS 55 Notes 0 - Query Execution 98 Merge Join Example B=C S.B < S.C: advance Z S A B C D a x b y a e c Z Z S 6 q d d e 5 Merge Join Example B=C S.B < S.C: advance Z S A B C D a x b y a e c Z S 6 q d Z d e 5 CS 55 Notes 0 - Query Execution 99 CS 55 Notes 0 - Query Execution 00 Merge Join Example Example (c) Merge Join A a b a c d e 5 B=C S B.B < S.C: DONE Z Z S S C D x y e 6 q d, not ordered, but contiguous --> Need to sort, first CS 55 Notes 0 - Query Execution 0 CS 55 Notes 0 - Query Execution 0

18 One way to sort: Merge Sort (i) For each 00 blk chunk of : - ead chunk - Sort in memory - Write to disk Memory... sorted chunks (ii) ead all chunks + merge + write out Sorted file Memory Sorted Chunks CS 55 Notes 0 - Query Execution 0 CS 55 Notes 0 - Query Execution 0 Cost: Sort Each tuple is read,written, read, written so... Sort cost : x,000 =,000 Sort cost : x 500 =,000 Example (d) Merge Join (continued), contiguous, but unordered Total cost = sort cost + join cost = 6,000 +,500 =,500 IOs CS 55 Notes 0 - Query Execution 05 CS 55 Notes 0 - Query Execution 06 Example (c) Merge Join (continued), contiguous, but unordered Total cost = sort cost + join cost = 6,000 +,500 =,500 IOs But: Iteration cost = 5,500 so merge joint does not pay off! But say = 0,000 blocks contiguous = 5,000 blocks not ordered Iterate: 5000 x (00+0,000) = 50 x 0,00 00 = 505,000 IOs Merge join: 5(0,000+5,000) = 5,000 IOs Merge Join (with sort) WINS! CS 55 Notes 0 - Query Execution 0 CS 55 Notes 0 - Query Execution 08 8

19 How much memory do we need for merge sort? E.g: Say I have 0 memory blocks chunks to merge, need 00 blocks! In general: Say k blocks in memory x blocks for relation sort # chunks = (x/k) size of chunk = k CS 55 Notes 0 - Query Execution 09 CS 55 Notes 0 - Query Execution 0 In general: Say k blocks in memory x blocks for relation sort # chunks = (x/k) size of chunk = k # chunks < buffers available for merge In general: Say k blocks in memory x blocks for relation sort # chunks = (x/k) size of chunk = k # chunks < buffers available for merge so... (x/k) k or k x or k x CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution In our example is 000 blocks, k.6 is 500 blocks, k.6 Can we improve on merge join? Hint: do we really need the fully sorted files? Need at least buffers Join? Again: in practice we would not want to use only one buffer per run! sorted runs CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution 9

20 Cost of improved merge join: C = ead + write into runs + read + write into runs + join =,000 +,000 +,500 =,500 --> Memory requirement? Example (d) Index Join Assume.C index exists; levels Assume contiguous, unordered Assume.C index fits in memory CS 55 Notes 0 - Query Execution 5 CS 55 Notes 0 - Query Execution 6 Cost: eads: 500 IOs for each tuple: - probe index - free - if match, read tuple: IO What is expected # of matching tuples? (a) say.c is key,.c is foreign key then expect = (b) say V(,C) = 5000, T( ) = 0,000 with uniform assumption expect = 0,000/5,000 = CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution 8 What is expected # of matching tuples? (c) Say DOM(, C)=,000,000 T( ) = 0,000 with alternate assumption Expect = 0,000 =,000, Total cost with index join (a) Total cost = () = 5,500 (b) Total cost = () = 0,500 (c) Total cost = (/00)=550 CS 55 Notes 0 - Query Execution 9 CS 55 Notes 0 - Query Execution 0 0

21 What if index does not fit in memory? Example: say.c index is 0 blocks Keep root + 99 leaf nodes in memory Expected cost of each probe is E = (0)99 + () Total cost (including probes) = [Probe + get records] = [0.5+] uniform assumption = 500+,500 =,000 (case b) CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution Total cost (including probes) = [Probe + get records] = [0.5+] uniform assumption = 500+,500 =,000 (case b) So far Nested Loop 5500 Merge join 500 Sort+Merge Join C Index C Index For case (c): = [0.5 + (/00) ] = = 050 IOs CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution Example (e) Partition Hash Join, contiguous (un-ordered) Use 00 buckets ead, hash, + write buckets -> Same for -> ead one bucket; build memory hash table -using different hash function h -> ead corresponding bucket + hash probe memory 0 blocks Then repeat for all buckets CS 55 Notes 0 - Query Execution 5 CS 55 Notes 0 - Query Execution 6

22 Cost: Cost: Bucketize: ead + write Bucketize: ead + write ead + write ead + write Join: ead, Join: ead, Total cost = x [ ] = 500 Total cost = x [ ] = 500 Note: this is an approximation since buckets will vary in size and we have to round up to blocks CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution 8 Why is Hash Join good? Minimum memory requirements: Size of bucket = (x/k) k = number of memory buffers x = number of blocks So... (x/k) < k S S k > x need: k+ total memory buffers CS 55 Notes 0 - Query Execution 9 CS 55 Notes 0 - Query Execution 0 Can we use Hash-join when buckets do not fit into memory?: Treat buckets as relations and apply Hash-join recursively join Duality Hashing-Sorting Both partition inputs Until input fits into memory Logarithmic number of phases in memory size CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution

23 Trick: keep some buckets in memory E.g., k = in memory G0 G buckets = blocks keep in memory... -= called hybrid hash-join Trick: keep some buckets in memory E.g., k = in memory G0 G buckets = blocks keep in memory... Memory use: G 0 buffers G buffers Output - buffers input Total 9 buffers 6 buffers to spare!! -= called hybrid hash-join CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution Next: Bucketize buckets =500/= 6 blocks Two of the buckets joined immediately with G 0,G Finally: Join remaining buckets for each bucket pair: read one of the buckets into memory join with second bucket in memory G0 G buckets 6 buckets ans out memory one full bucket Gi buckets 6 buckets... -=... -= one buffer... -=... -= CS 55 Notes 0 - Query Execution 5 CS 55 Notes 0 - Query Execution 6 Cost Bucketize = 000+ =96 To bucketize, only write buckets: so, cost = =996 To compare join ( buckets already done) read + 6=5 How many buckets in memory? in memory memory G0 G O... in G0? Total cost = = See textbook for answer... CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution 8

24 Another hash join trick: Only write into buckets <val,ptr> pairs When we get a match in join phase, must fetch tuples To illustrate cost computation, assume: 00 <val,ptr> pairs/block expected number of result tuples is 00 CS 55 Notes 0 - Query Execution 9 CS 55 Notes 0 - Query Execution 0 To illustrate cost computation, assume: 00 <val,ptr> pairs/block expected number of result tuples is 00 Build hash table for in memory 5000 tuples 5000/00 = 50 blocks ead and match ead ~ 00 tuples To illustrate cost computation, assume: 00 <val,ptr> pairs/block expected number of result tuples is 00 Build hash table for in memory 5000 tuples 5000/00 = 50 blocks ead and match ead ~ 00 tuples Total cost = ead : 500 ead : 000 Get tuples: CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution So far: Iterate 5500 Merge join 500 Sort+merge joint 500.C index C index Build.C index Build.C index Hash join 500+ with trick, first with trick, first Hash join, pointers 600 CS 55 Notes 0 - Query Execution Yet another hash join trick: Combine the ideas of block nested-loop with hash join Use memory to build hash-table for one chunk of relation Find join partners in O() instead of O(M) Trade-off Space-overhead of hash-table Time savings from look-up CS 55 Notes 0 - Query Execution

25 Summary Nested Loop ok for small relations (relative to memory size) Need for complex join condition For equi-join, where relations not sorted and no indexes exist, hash join usually best Sort + merge join good for non-equi-join (e.g.,.c >.C) If relations already sorted, use merge join If index exists, it could be useful (depends on expected result size) CS 55 Notes 0 - Query Execution 5 CS 55 Notes 0 - Query Execution 6 Join Comparison N i = number of tuples in i B( i ) = number of blocks of i #P = number of partition steps for hash join P ij = average number of join partners Algorithm #I/O Memory Disk Space Nested Loop (block) B( ) / (M-) *! [min(b(),m-) + B( )] 0 Index Nested Loop B( ) + N * P B(Index) + 0 Merge (sorted) B( ) + B( ) Max tuples = 0 Merge (unsorted) B( ) + B( )+ (sort pass) Hash (#P + ) (B( ) + B( )) sort B( ) + B( ) root(max(b( ), B( )), #P + ) ~B( ) + B( ) Why do we need nested loop? emember not all join implementations work for all types of join conditions Algorithm Type of Condition Example Nested Loop any a LIKE %hello% Index Nested Loop Supported by index: Equi-join (hash) Equi or range (B-tree) a = b a < b Merge Equalities and ranges a < b, a = b AND c = d Hash Equi-join a = b CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution 8 Outer Joins Merge Left Outer Join How to implement (left) outer joins? Nested Loop and Merge Use a flag that is set to true if we find a match for an outer tuple If flag is false fill with NULL Hash If no matching tuple fill with NULL A a d e 5 B=C S B Output: (a,,,x) S C D Z Z S x y e 6 q d CS 55 Notes 0 - Query Execution 9 CS 55 Notes 0 - Query Execution 50 5

26 Merge Left Outer Join Merge Left Outer Join B=C S No match for (d,) Output: (d,,null,null) S B=C S No match for (e,5) Output: (e,5,null,null) S A B a d e 5 Z Z S C D x y e 6 q d A B a d e 5 Z Z S C D x y e 6 q d CS 55 Notes 0 - Query Execution 5 CS 55 Notes 0 - Query Execution 5 Operators Overview (External) Sorting Joins (Nested Loop, Merge, Hash, ) Aggregation (Sorting, Hash) Selection, Projection (Index, Scan) Union, Set Difference Intersection Duplicate Elimination Aggregation Have to compute aggregation functions for each group of tuples from input Groups Determined by equality of group-by attributes CS 55 Notes 0 - Query Execution 5 CS 55 Notes 0 - Query Execution 5 Aggregation Example SELECT sum(a),b! FOM! GOUP BY b! a b sum(a) b 6 6 Aggregation Function Interface init()! Initialize state update(tuple)! Update state with information from tuple close()! eturn result and clean-up CS 55 Notes 0 - Query Execution 55 CS 55 Notes 0 - Query Execution 56 6

27 Implementation SUM(A) init()! sum := 0! update(tuple)! sum += tuple.a! close()! return sum! CS 55 Notes 0 - Query Execution 5 Aggregation Implementations Sorting Sort input on group-by attributes On group boundaries output tuple Hashing Store current aggregated values for each group in hash table Update with newly arriving tuples Output result after processing all inputs CS 55 Notes 0 - Query Execution 58 Grouping by sorting Similar to Merge join Sort on group-by attribute Scan through sorted input If group-by values change Output using close() and call init() Otherwise Call update() a b Aggregation Example SELECT sum(a),b! FOM! GOUP BY b! sort a b init() 0 CS 55 Notes 0 - Query Execution 59 CS 55 Notes 0 - Query Execution 60 Aggregation Example SELECT sum(a),b! FOM! GOUP BY b! Aggregation Example SELECT sum(a),b! FOM! GOUP BY b! a b update(,) a b update(,) 6 CS 55 Notes 0 - Query Execution 6 CS 55 Notes 0 - Query Execution 6

28 Aggregation Example SELECT sum(a),b! FOM! GOUP BY b! a b Group by changed! close(), init(), update(,) 6 0 output Grouping by Hashing Create in-memory hash-table For each input tuple probe hash table with group by values If no entry exists then call init(), update(), and add entry Otherwise call update() for entry Loop through all entries in hash-table and ouput calling close() CS 55 Notes 0 - Query Execution 6 CS 55 Notes 0 - Query Execution 6 Aggregation Example SELECT sum(a),b! FOM! GOUP BY b! Aggregation Example SELECT sum(a),b! FOM! GOUP BY b! Init() and update(,) a b a b CS 55 Notes 0 - Query Execution 65 CS 55 Notes 0 - Query Execution 66 Aggregation Example SELECT sum(a),b! FOM! GOUP BY b! Init() and update(,) Aggregation Example SELECT sum(a),b! FOM! GOUP BY b! update(,) a b a b 6 CS 55 Notes 0 - Query Execution 6 CS 55 Notes 0 - Query Execution 68 8

29 Aggregation Example SELECT sum(a),b! FOM! GOUP BY b! a b Loop through hash table entries Output tuples 6 6 Aggregation Summary Hashing No sorting -> no extra I/O Hash table has to fit into memory No outputs before all inputs have been processed Sorting No memory required Output one group at a time CS 55 Notes 0 - Query Execution 69 CS 55 Notes 0 - Query Execution 0 Operators Overview (External) Sorting Joins (Nested Loop, Merge, Hash, ) Aggregation (Sorting, Hash) Selection, Projection (Index, Scan) Union, Set Difference Intersection Duplicate Elimination Duplicate Elimination Equivalent to group-by on all attributes -> Can use aggregation implementations Optimization Hash Directly output tuple and use hash table only to avoid outputting duplicates CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution Operators Overview (External) Sorting Joins (Nested Loop, Merge, Hash, ) Aggregation (Sorting, Hash) Selection, Projection (Index, Scan) Union, Set Difference Intersection Duplicate Elimination Set Operations Can be modeled as join with different output requirements As aggregation/group by on all columns with different output requirements CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution 9

30 Union Bag union Append the two inputs E.g., using three buffers Set union Apply duplicate removal to result Intersection Set version Equivalent to join + project + duplicate removal -state aggregate function (found left, found right, found both) Bag version Join + project + min(i,j) Aggegate min(count(i),count(j)) CS 55 Notes 0 - Query Execution 5 CS 55 Notes 0 - Query Execution 6 Set Difference Using join methods Find matching tuples If no match found, then output Using aggregation count(i) count(j) (bag) true(i) AND false(j) (set) Summary Operator implementations Joins! Other operators Cost estimations I/O memory Query processing architectures CS 55 Notes 0 - Query Execution CS 55 Notes 0 - Query Execution 8 Next Query Optimization Physical -> How to efficiently choose an efficient plan CS 55 Notes 0 - Query Execution 9 0