Cost-based optimization stands or falls on the quality of cardinality estimates (expected row counts). If the optimizer has incorrect information
to start with, it is quite unlikely
to produce good quality execution plans except by chance. There are many ways we can provide good starting information
to the optimizer, and even more ways for cardinality estimation
to go wrong. Good database people know this, and work hard
to write optimizer-friendly queries with a schema and metadata (e.g. statistics) that reduce the chances of poor cardinality estimation producing a sub-optimal plan. Today, I am going
to look at a case where poor cardinality estimation is Microsoft’s fault, and not yours. SQL Server 2005 SELECT
th.ProductID,
th.TransactionID,
th.TransactionDate
FROM Production.TransactionHistory AS th
WHERE
th.ProductID = 1
AND th.TransactionDate BETWEEN '20030901' AND '20031231';
The query plan on SQL Server 2005 is as follows (if you are using a more recent version of AdventureWorks, you will need
to change the year on the
date range from 2003
to 2007):
There is an Index Seek on ProductID = 1, followed by a Key Lookup
to find the Transaction
Date for each row, and finally a Filter
to restrict the results
to only those rows where Transaction
Date falls in the range specified. The cardinality estimate of 45 rows at the Index Seek is exactly correct. The table is not very large, there are up-to-date statistics associated with the index, so this is as expected.
The estimate for the Key Lookup is also exactly right. Each lookup into the Clustered Index
to find the Transaction
Date is guaranteed
to return exactly one row. The plan shows that the Key Lookup is expected
to be executed 45 times. The estimate for the Inner Join output is also correct – 45 rows from the seek joining
to one row each time, gives 45 rows as output.
The Filter estimate is also very good: the optimizer estimates 16.9951 rows will match the specified range of transaction dates. Eleven rows are produced by this query, but that small difference is quite normal and certainly nothing
to worry about here. All good so far.
SQL Server 2008 onward
The same query executed against an identical copy of AdventureWorks on SQL Server 2008 produces a different execution plan:
The optimizer has pushed the Filter conditions seen in the 2005 plan down
to the Key Lookup. This is a good optimization – it makes sense
to filter rows out as early as possible. Unfortunately, it has made a bit of a mess of the cardinality estimates.
The post-Filter estimate of 16.9951 rows seen in the 2005 plan has moved with the predicate on Transaction
Date. Instead of estimating one row, the plan now suggests that 16.9951 rows will be produced by each clustered index lookup – clearly not right! This misinformation also confuses SQL Sentry Plan Explorer:
Plan Explorer shows 765 rows expected from the Key Lookup (it multiplies a rounded estimate of 17 rows by 45 expected executions
to give 765 rows total).
Workarounds
One workaround is
to provide a covering non-clustered index (avoiding the lookup avoids the problem of course):
CREATE INDEX nc1
ON Production.TransactionHistory (ProductID)
INCLUDE (TransactionDate);
With the Transaction
Date filter applied as a residual predicate in the same operator as the seek, the estimate is again as expected:
We could also force the use of the ultimate covering index (the clustered one):
SELECT
th.ProductID,
th.TransactionID,
th.TransactionDate
FROM Production.TransactionHistory AS th WITH (INDEX(1))
WHERE
th.ProductID = 1
AND th.TransactionDate BETWEEN '20030901' AND '20031231';
Summary
Providing a covering non-clustered index for all possible queries is not always practical, and scanning the clustered index will rarely be optimal. Nevertheless, these are the best workarounds we have today.
In the meantime, watch out for poor cardinality estimates when a predicate is applied as part of a lookup.
The worst thing is that the estimate after the lookup join in the 2008+ plans is wrong. It’s not hopelessly wrong in this particular case (45 versus 16.9951 is not the end of the world) but it easily can be much worse, and there’s not much you can do about it. Any decisions made by the optimizer after such a lookup could be based on very wrong information – which can only be bad news.
If you think this situation should be improved, please vote for this Connect item.
© 2012 Paul White – All Rights Reserved
twitter: @SQL_Kiwi
email:
[email protected]