CSE 530A. Query Planning. Washington University Fall 2013

Transcription

1 CSE 530A Query Planning Washington University Fall 2013

2 Scanning When finding data in a relation, we've seen two types of scans Table scan Index scan There is a third common way Bitmap scan

3 Bitmap Scans When performing an index scan it is usually necessary to also retrieve the actual matching records from the table Most often, the records in the table file are not in the order accessed This leads to many random accesses in the table file Sequential file access is generally faster than random access If we could access the table file in sequentially then performance could be increased

4 Bitmap Scans In a bitmap scan, a bitmap is created while performing an index scan The bitmap indicates the position of the matching records in the table file (also called the heap) The index scan step is called a bitmap index scan A scan of the heap (table file) is then done, retrieving the records indicated by the bitmap The table scan step is called a bitmap heap scan

5 Lossy Bitmap Scans If a table is too large to efficiently create a bitmap of the records then a bitmap of the pages can be used The bitmap indicates which table pages contain records that match the predicate The bitmap heap scan then fetches the indicated pages in sequential order Must recheck the records in each fetched page to find the ones that match the predicate

6 Disjunctions Bitmap scans can be helpful in implementing queries with disjunctions If we have a query like " WHERE year < '2010' OR major = 'CSE'" and separate indexes on year and major then we could do an index scan on year to create the bitmap do an index scan on major and set the matching bits in the bitmap do the bitmap heap scan

7 Query Planning We now have three ways of scanning a relation table scan index scan bitmap index scan When should each method be used? Answer is not always obvious

8 Query Planning If we need to access every record in the relation Do a table scan. Accessing the index is just unnecessary overhead. If no appropriate index is available Table scan is only option. If index is available Best method depends on size of table and percentage of matching records If the table is small enough then it might be fastest to just do a table scan If the number of matching records is small then an index scan is probably fastest If the number of matching records is above some limit then a bitmap scan or table scan might be fastest

9 Query Planning What is the limit at which we should switch from index scan to bitmap or table scan? No hard and fast rule Some references say just 5% or greater matching records (Seems a little low to me)

10 Query Planning Three ways of scanning relations table scan index scan bitmap index scan Three ways of joining relations nested loop join merge join hash join

11 Query Planning Selecting from a single table gives 3 possible options 3 ways of scanning Joining two tables gives 3 3 options 3 for selecting from each table 3 for the actual join Each additional table joined multiplies the possibilities by for selecting from the additional table 3 for joining In addition, there are often multiple possibilities for when to handle the predicates How does the DBMS choose a query plan?

12 Query Planning A query plan can be represented as a tree leaves are scans inner nodes are joins, sorts, materializations nested loop join condition: students.mid = majors.mid table scan on students condition: year='2010' index scan on majors condition: title='cse'

13 Query Planning Some joins can be done in different orders For example, if we have x inner join y inner join z we'll get the same result if x join y is done first and then joined to z or y join z is done first and then joined to x join join join z x join x y y z

14 Query Planning It is the job of the query planner to pick the minimum cost plan Two issues The number of possible plans grows exponentially in the number of joined tables How is the cost of a plan calculated?

15 Query Planning We can assign a cost to a plan node if given The cost of the child nodes The size of the sets generated by the child nodes The cost of the actual operations of the node

16 Query Planning What do we mean by "cost"? Time! We're looking for the plan that takes the shortest time The cost of an operation is generally calculated as a function of the number of page fetches/writes and the CPU time spent I/O time usually dominates, but CPU time also plays a part Also often subdivided into sequential page and random page access as these can take different times Number of page accesses and CPU time directly dependent on size of data

17 Query Planning For a given plan node, the query planner tries to estimate both the cost (in some unit of time) and the size of the resulting set based on the type of operation and the size of the input sets The cost of a node in the plan tree includes the cost of its children So the cost of the root node is the total estimated cost of executing the plan

18 Query Planning The number of possible plans increases exponentially with the complexity of the query Quickly becomes impossible for a query planner to evaluate all possible plans The query planner itself needs to be fast Since the planner is choosing among various trees which often have identical subtrees, dynamic programming techniques (e.g., memoization) can be used Still may not have enough time to evaluate all possible plans

19 Query Planning Some query optimizers favor left-deep trees A left-deep tree adds each new table as the right child of a join left-deep right-deep bushy join join join join d a join join join join c b join a b c d a b c d

20 Query Planning The nodes can be made interchangeable by using an iterator interface Each child supplies the set resulting from its operation as an iterator to its parent Using an iterator interface also facilitates pipelining A parent node doesn't need to know if the child has a materialized set or is providing elements on demand

21 Query Planning Part of estimating the cost for a node requires estimating the number of records resulting from a scan or join For a select without a predicate we could use the number of rows in the table For an equals predicate on a unique column we know there will be at most one How do we know how many rows a scan with a predicate will return before actually doing the scan?

22 Query Planning The query planner tries to estimate the selection factor of predicates by using statistics on the distribution of values for each column Basically keeps a histogram for each column

23 Query Planning If the statistics kept by the DBMS for a column are significantly wrong then the performance of queries using that column can be greatly impacted The query planner could have vastly incorrect cost estimates and therefore pick a bad plan Tables with lots of modifications (inserts/updates/deletes) should periodically be analyzed The DBMS will scan the table and regenerate its histograms

24 Sargable Predicates A predicate is sargable if it does not interfere with the DBMS's ability to use an index Applying a function to a column in the WHERE clause usually makes it non-sargable Non-Sargable: WHERE year(date) = 2012 Sargable: WHERE date BETWEEN ' ' AND ' Non-Sargable: WHERE substring(model, 6) = 'Toyota' Sargable: WHERE model LIKE 'Toyota%' ("sargable" comes from Search ARGument ABLE)

25 Explain PostgreSQL has an EXPLAIN command that will give details on the chosen plan for a query Other DBMSs have similar features, but there is no standard EXPLAIN SELECT * FROM tenk1; QUERY PLAN Seq Scan on tenk1 (cost= rows=10000 width=244)

26 Explain EXPLAIN SELECT * FROM tenk1; QUERY PLAN Seq Scan on tenk1 (cost= rows=10000 width=244) The first cost value is the estimated start-up cost That is, the time before scan of the output can start The second cost value is the estimated cost to retrieve all the requested rows The time values are in arbitrary units based on the configured cost parameters (by default, in units of page fetches) The rows value is the estimated number of rows output by this node The width value is the estimated average width (in bytes) of the output rows

27 Explain EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 7000; QUERY PLAN Seq Scan on tenk1 (cost= rows=7033 width=244) Filter: (unique1 < 7000) Added a WHERE clause Number of rows has gone down Time has gone up slightly Reflects the extra CPU time used in checking the condition

28 Explain EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 100; QUERY PLAN Bitmap Heap Scan on tenk1 (cost= rows=106 width=244) Recheck Cond: (unique1 < 100) -> Bitmap Index Scan on tenk1_unique1 (cost= rows=106 width=0) Index Cond: (unique1 < 100) EXPLAIN outputs a textual representation of the plan tree The '->' indicates a child node and the level of indentation indicates the parent So in this example, the Bitmap Index Scan node is a child of the Bitmap Heap Scan node These generally always go together

29 Explain EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 100; QUERY PLAN Bitmap Heap Scan on tenk1 (cost= rows=106 width=244) Recheck Cond: (unique1 < 100) -> Bitmap Index Scan on tenk1_unique1 (cost= rows=106 width=0) Index Cond: (unique1 < 100) By changing the predicate, the estimated number of matching rows has dropped drastically which caused the planner to pick a different plan Note that the costs for the parent node includes the costs for the child nodes

30 Explain EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 3; QUERY PLAN Index Scan using tenk1_unique1 on tenk1 (cost= rows=2 width=244) Index Cond: (unique1 < 3) Changing the predicate again has again drastically reduced the estimated number of rows and changed the selected plan Why was table scan picked for the large number of rows? index scan picked for the small number of rows? bitmap scan picked for the medium number of rows?

31 Explain EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 3 AND stringu1 = 'xxx'; QUERY PLAN Index Scan using tenk1_unique1 on tenk1 (cost= rows=1 width=244) Index Cond: (unique1 < 3) Filter: (stringu1 = 'xxx'::name) Added a conjunction to the predicate Number of rows is smaller Cost is (very slightly) higher

32 Explain EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 100 AND unique2 > 9000; QUERY PLAN Bitmap Heap Scan on tenk1 (cost= rows=11 width=244) Recheck Cond: ((unique1 < 100) AND (unique2 > 9000)) -> BitmapAnd (cost= rows=11 width=0) -> Bitmap Index Scan on tenk1_unique1 (cost= rows=106 width=0) Index Cond: (unique1 < 100) -> Bitmap Index Scan on tenk1_unique2 (cost= rows=1042 width=0) Index Cond: (unique2 > 9000) In this example, the results of two bitmap index scans are being ANDed together before performing the bitmap heap scan Can be done since indexes exist on both columns Could also have been done by doing a bitmap scan on the one column and filtering by the other predicate

33 Explain EXPLAIN SELECT * FROM tenk1 t1, tenk2 t2 WHERE t1.unique1 < 100 AND t1.unique2 = t2.unique2; QUERY PLAN Nested Loop (cost= rows=106 width=488) -> Bitmap Heap Scan on tenk1 t1 (cost= rows=106 width=244) Recheck Cond: (unique1 < 100) -> Bitmap Index Scan on tenk1_unique1 (cost= rows=106 width=0) Index Cond: (unique1 < 100) -> Index Scan using tenk2_unique2 on tenk2 t2 (cost= rows=1 width=244) Index Cond: (t2.unique2 = t1.unique2) This example uses a nested loop join

34 Explain SET enable_nestloop = off; EXPLAIN SELECT * FROM tenk1 t1, tenk2 t2 WHERE t1.unique1 < 100 AND t1.unique2 = t2.unique2; QUERY PLAN Hash Join (cost= rows=106 width=488) Hash Cond: (t2.unique2 = t1.unique2) -> Seq Scan on tenk2 t2 (cost= rows=10000 width=244) -> Hash (cost= rows=106 width=244) -> Bitmap Heap Scan on tenk1 t1 (cost= rows=106 width=244) Recheck Cond: (unique1 < 100) -> Bitmap Index Scan on tenk1_unique1 (cost= rows=106 width=0) Index Cond: (unique1 < 100) Here's the same example with nested loop joins disabled Generally not a good idea to disable features like this. Note the increased query cost.

35 Explain Analyze EXPLAIN ANALYZE can be used to compare the estimated costs with the actual costs Note that EXPLAIN ANALYZE will cause the query to actually be executed Might want to perform in a transaction and rollback

36 Explain Analyze EXPLAIN ANALYZE SELECT * FROM tenk1 t1, tenk2 t2 WHERE t1.unique1 < 100 AND t1.unique2 = t2.unique2; QUERY PLAN Nested Loop (cost= rows=106 width=488) (actual time= rows=100 loops=1) -> Bitmap Heap Scan on tenk1 t1 (cost= rows=106 width=244) (actual time= rows=100 loops=1) Recheck Cond: (unique1 < 100) -> Bitmap Index Scan on tenk1_unique1 (cost= rows=106 width=0) (actual time= rows=100 loops=1) Index Cond: (unique1 < 100) -> Index Scan using tenk2_unique2 on tenk2 t2 (cost= rows=1 width=244) (actual time= rows=1 loops=100) Index Cond: (t2.unique2 = t1.unique2) Total runtime: ms The actual times are in milliseconds