Search results matching tag 'Undocumented'

Execution Plan Analysis: The Mystery Work Table

Paul White — Thu, 07 Mar 2013 19:42:04 GMT

I love SQL Server execution plans. It is often easy to spot the cause of a performance problem just by looking at one. The task is considerably easier if the plan includes run-time information (a so-called ‘actual’ execution plan), but even a compiled plan can be very useful. Nevertheless, there are still times where the execution plan does not tell the whole story, and we need to think more deeply about query execution to really understand a performance problem. This post looks at one such example, based on a recent question posted on the SQL Performance Q & A site.

The Execution Plan

This plan is reasonably large (20MB cached plan size) but not massively complex once you break it down (click on the image above to view it full-size in a new window). The context of the question is that this query usually executes in less than a minute, but sometimes it runs for nearly twenty minutes – though the plan appears identical.

High-Cost Operators

There are many different things to look for in execution plans. What you choose to look at first is as much a matter of personal preference as anything, but many people are drawn to high-cost operators, so I will start there. In this plan, the cost of one operator dominates all others, shown as being responsible for 100% of the cost of the query. It is highlighted in red in Plan Explorer; I have expanded the relevant plan section (the top right) below:

There is no doubt that this seek is busy little thing. It is executed 249,484 times, though it only produces a grand total of 167,813 rows over all iterations of the loop join – an average of just 0.7 rows per seek. There are all sorts of interesting details in the plan about this seek – I could write a whole blog post about it – but two details that stand out are the “Force Seek: True” and “Partitioned: True” attributes. These tell us that the base table is partitioned, and the query writer had to use a FORCESEEK table hint to get this plan.

Without this hint, the optimizer would almost certainly choose a Hash Match or Merge Join rather than Nested Loops. This is understandable given the optimizer’s cost model and the simplifying assumptions it makes (such as assuming every query starts with a cold buffer cache). That’s fine, but we can see from the query plan that the inner-side table has 643 million rows. Left to its own devices, the optimizer would estimate that it would be faster to perform a sequential scan of 643 million rows (with large-block read-ahead) than it would be to run a quarter-million randomly-distributed seeks driven by a Nested Loops join.

I doubt that the optimizer’s reasoning here is sound (at least on any reasonably modern hardware) but there we go. The query author probably knows that a good fraction of this table is likely to be in cache, so with all that in mind, I think we can reasonably assume at this stage that the FORCESEEK hint is genuinely needed here, and this part of the plan is at least reasonably optimal.

Important note: The seek certainly does not account for 100% of the runtime cost of this query. Remember cost percentages are always estimates – even in ‘actual’ plans. It can be useful to check the reasons for high-estimated-cost operators, but they should never be used as a primary tuning metric.

Execution Warnings

This query was executed on SQL Server 2012, so there is a handy warning triangle on the Sort operator indicating that one or more sort runs had to be spilled to physical tempdb disk. The plan clearly shows this spilling is a result of an inaccurate cardinality estimate at the Filter operator (the estimates are not bad at all prior to this). The Sort expects 9,217 rows totalling approximately 5MB, but actually encountered 61,846 rows in 35MB. As you may know, memory for sorts and hashes is allocated before execution starts, and generally cannot expand dynamically at run time.

The spilled sort is undesirable, of course, but it is unlikely to be a major cause of the occasional poor performance given the small size of the spilled data. Nevertheless, this might be a good place to split this query up. The idea would be to write the results of the query (up to and including the Filter) to a temporary heap table using SELECT INTO, and then create a clustered index with the same keys as the Sort operator. The temporary table would not be large, and may well perform better overall than the spilled sort, including the cost of creating the clustered index. Of course, creating this index will involve a sort, but it will be one based on the known cardinality of the temporary heap table. The part of the plan that could be replaced by a temporary table is shown below:

I am a big fan of simplifications like this. Smaller execution plans tend to optimize better for all sorts of reasons, and the source code usually becomes easier to maintain as well. I should mention there is another warning triangle in the 2012 execution plan (shown on the root icon), which relates to some implicit conversions that I will mention later.

I/O Information

The execution plan was captured with Plan Explorer, so we can also easily see I/O statistics for the two executions. The first is for a fast (sub-60-second) run:

Overall, these I/O numbers show pretty much what we would expect: a decent number of logical reads associated with the seeks into the Trans table (but certainly not 100% of the total, ha ha), a very small number of physical reads, and a small amount of read-ahead activity on a couple of tables.

The second set of I/O data is from a slow run (18 minutes or so):

The very obvious difference is the appearance of a work table, with 178 million logical reads and 130 million LOB logical reads. It seems very likely this work table, and its 300 million logical reads, is responsible for the dramatic decrease in query performance. But given that the execution plans are identical (right down to the XML) what is causing this?

My answer to that question (on the Q & A site) was that it is related to the increased level of read-ahead activity, but to see why that is the case, we will need to reproduce the issue and dig a bit deeper.

Execution Outline

Before we really get going on this, it will be useful to take a look at what the execution plan is doing in outline. We saw the first part of the plan earlier when looking at the spilling sort. The data set at that point (which we would like to write to a temporary table, remember) essentially represents source data for a second query, which uses a series of Nested Loops Left Joins to lookup information from other tables:

The inner side of each join involves some reasonably involved logic, which is thankfully not important to the present discussion. What is important is that the result of each lookup is a LOB data type. This begins to shed some light on the LOB logical reads reported against the work table, but it does not explain why the work table (and the 300 million associated reads) do not appear when the query runs quickly (with the same execution plan).

Reproducing the problem

Table Creation

The first part of the repro involves creating six tables that represent the lookup tables in the original query plan. Each table will have 10,000 rows, consisting of a sequential reference number and a second column containing a 2048 single-byte-character string. The source table used to drive the lookups will be a regular Numbers table containing just a single integer column.

     CREATE TABLE dbo.T1 (id integer IDENTITY PRIMARY KEY, d char(2048));

    CREATE TABLE dbo.T2 (id integer IDENTITY PRIMARY KEY, d char(2048));

    CREATE TABLE dbo.T3 (id integer IDENTITY PRIMARY KEY, d char(2048));

    CREATE TABLE dbo.T4 (id integer IDENTITY PRIMARY KEY, d char(2048));

    CREATE TABLE dbo.T5 (id integer IDENTITY PRIMARY KEY, d char(2048));

    CREATE TABLE dbo.T6 (id integer IDENTITY PRIMARY KEY, d char(2048));

    GO

    INSERT dbo.T1 WITH (TABLOCKX)

    SELECT REPLICATE('A', 2048)

    FROM dbo.Numbers AS n WHERE n BETWEEN 1 AND 10000;

    GO

    INSERT dbo.T2 WITH (TABLOCKX)

    SELECT REPLICATE('B', 2048)

    FROM dbo.Numbers AS n WHERE n BETWEEN 1 AND 10000;

    GO

    INSERT dbo.T3 WITH (TABLOCKX)

    SELECT REPLICATE('C', 2048)

    FROM dbo.Numbers AS n WHERE n BETWEEN 1 AND 10000;

    GO

    INSERT dbo.T4 WITH (TABLOCKX)

    SELECT REPLICATE('D', 2048)

    FROM dbo.Numbers AS n WHERE n BETWEEN 1 AND 10000;

    GO

    INSERT dbo.T5 WITH (TABLOCKX)

    SELECT REPLICATE('E', 2048)

    FROM dbo.Numbers AS n WHERE n BETWEEN 1 AND 10000;

    GO

    INSERT dbo.T6 WITH (TABLOCKX)

    SELECT REPLICATE('F', 2048)

    FROM dbo.Numbers AS n WHERE n BETWEEN 1 AND 10000;

The next step is to ensure that each lookup table is optimally organized for read-ahead:

    ALTER TABLE dbo.T1 REBUILD WITH (MAXDOP = 1);

    ALTER TABLE dbo.T2 REBUILD WITH (MAXDOP = 1);

    ALTER TABLE dbo.T3 REBUILD WITH (MAXDOP = 1);

    ALTER TABLE dbo.T4 REBUILD WITH (MAXDOP = 1);

    ALTER TABLE dbo.T5 REBUILD WITH (MAXDOP = 1);

    ALTER TABLE dbo.T6 REBUILD WITH (MAXDOP = 1);

Test Query

The original query translates into our simplified test rig as:

    DECLARE @d nvarchar(max) = NCHAR(10000);

    SELECT n.n,

        DATALENGTH

        (

            CONCAT

            (

                (SELECT CONCAT(t.d, t.d, t.d, t.d, t.d, t.d, @d) FROM dbo.T1 AS t WHERE t.id = n.n),

                (SELECT CONCAT(t.d, t.d, t.d, t.d, t.d, t.d, @d) FROM dbo.T2 AS t WHERE t.id = n.n),

                (SELECT CONCAT(t.d, t.d, t.d, t.d, t.d, t.d, @d) FROM dbo.T3 AS t WHERE t.id = n.n),

                (SELECT CONCAT(t.d, t.d, t.d, t.d, t.d, t.d, @d) FROM dbo.T4 AS t WHERE t.id = n.n),

                (SELECT CONCAT(t.d, t.d, t.d, t.d, t.d, t.d, @d) FROM dbo.T5 AS t WHERE t.id = n.n),

                (SELECT CONCAT(t.d, t.d, t.d, t.d, t.d, t.d, @d) FROM dbo.T6 AS t WHERE t.id = n.n)

            )

        )

    FROM dbo.Numbers AS n

    WHERE n.n BETWEEN 1 AND 10000

    ORDER BY n.n

    OPTION (LOOP JOIN, FORCE ORDER, MAXDOP 1);

The broad idea there is to concatenate our 2048-character column to itself five times and include a Unicode character that was used in the original query as a delimiter that could not appear in the source data. Each lookup performs the same basic operation against its target table, and the final result is the result of concatenating all the intermediate results. The query hints are necessary to get the right plan shape, just because my test rig tables are so much smaller than the real ones.

Note that the Unicode delimiter means the 2048-character single-byte data is implicitly converted to Unicode, doubling in size. It is not a crucial feature of the test, but it did appear in the original query and explains the type conversion warnings in the execution plan I mentioned earlier. The execution plan for the test query is (click to enlarge if necessary):

I should also stress that the CONCAT operator (new in SQL Server 2012) is not crucial either. If you are using an earlier version of SQL Server, an equivalent query (for present purposes) is shown below. I’m going to stick with CONCAT for the remainder of the post, however.

    DECLARE @d nvarchar(max) = NCHAR(10000);

    SELECT n.n,

        DATALENGTH

        (

            (SELECT @d+t.d+t.d+t.d+t.d+t.d+t.d FROM dbo.T1 AS t WHERE t.id = n.n) +

            (SELECT @d+t.d+t.d+t.d+t.d+t.d+t.d FROM dbo.T2 AS t WHERE t.id = n.n) +

            (SELECT @d+t.d+t.d+t.d+t.d+t.d+t.d FROM dbo.T3 AS t WHERE t.id = n.n) +

            (SELECT @d+t.d+t.d+t.d+t.d+t.d+t.d FROM dbo.T4 AS t WHERE t.id = n.n) +

            (SELECT @d+t.d+t.d+t.d+t.d+t.d+t.d FROM dbo.T5 AS t WHERE t.id = n.n) +

            (SELECT @d+t.d+t.d+t.d+t.d+t.d+t.d FROM dbo.T6 AS t WHERE t.id = n.n)

        )

    FROM dbo.Numbers AS n

    WHERE n.n BETWEEN 1 AND 10000

    ORDER BY n.n

    OPTION (LOOP JOIN, FORCE ORDER, MAXDOP 1);

Warm cache results

With all data in memory, the test query (in either form) completes in about 1.6 seconds on my laptop. The result shows that each output row contains 147,468 bytes of Unicode character data. A typical set of I/O statistics follows:

Nothing too exciting to see there, but this is just our baseline.

Cold cache results

    CHECKPOINT;

    DBCC DROPCLEANBUFFERS;

With no data in memory, the test query now runs for 18.6 seconds – almost 12x slower. The I/O statistics show the expected (but still mysterious!) work table and its associated reads:

The Extended Events wait statistics show SQL Server spent very little of that time waiting on my laptop’s slow hard drive – just 402 ms:

Explanation

The are a number of factors in play here that we will look at in turn.

Nested Loops Prefetching

One of the reasons the optimizer prefers Hash Match and Merge Join for larger inputs is that the data access patterns tend to favour large sequential read-ahead. Both hash and merge tend to scan (range-scan in the case of a seek) their inputs, and the SQL Server Storage Engine automatically issues read-ahead when it detects this type of access. There is nothing in the execution plan to show that a base table will be read with read-ahead, it just happens.

A very basic implementation of Nested Loops join would not benefit from read-ahead at all on its inner side. The outer (driving) side of the loops join might well be a scan or range-scan of an index, and so benefit from automatic read-ahead, of course. The inner side is executed once per outer row, resulting in a rapid succession of small index seeks for different values. These small seeks will typically not be large enough to trigger the automatic read-ahead mechanism. Indeed, in our test, each inner side seek is for precisely one value.

SQL Server improves on this by implementing a second read-ahead mechanism especially for Nested Loops joins (not all N-L joins, it is a cost-based decision the optimizer makes). The basic idea is to buffer extra rows from the outer side of the join, and to use the row values in the buffer to drive read-ahead for the inner side. The effect is that the Nested Loops join becomes a partly blocking operator as outer-side rows are read into the buffer and read-ahead issued based on buffered index key values.

This read-ahead may be either order-preserving or not, and is indicated in the execution plan by the Nested Loop attributes With Ordered Prefetch and With Unordered Prefetch, respectively. When unordered prefetch occurs, the inner side is processed in whatever order the asynchronous reads happen to complete. With ordered prefetching, the mechanism is careful to ensure that the order of rows entering the join is preserved on the output.

In the test rig, the ORDER BY clause means there is a need to preserve row order, so Ordered Prefetch is used:

The issue described in this post is not specific to ordered prefetching – the same behaviour is just as likely with unordered prefetching. The point is that Nested Loops prefetching is one of the requirements.

Documented trace flags 652 and 8744 may be used (with care, and after serious testing) to disable automatic read-ahead and Nested Loops prefetching respectively. This is sometimes beneficial where all data is expected to be in memory (in which case read-ahead processing consumes resources better used by query execution) or where the I/O subsystem is extremely fast. In case you were wondering, there is no background thread for prefetching – all the work of checking whether the data is in memory, and issuing I/O if not, is performed by the worker thread executing the query.

I should stress that read-ahead and Nested Loops prefetching is generally A Very Good Thing with typical storage solutions (e.g. SANs) and both work best (or at all) when indexes have low logical fragmentation.

Manufactured LOBs

The issue described here also requires that a large object data type is manufactured before prefetching. The Compute Scalar operators in the test execution plan perform that function:

By ‘manufactured’, I mean that the source columns are not LOB types, but the expression output is – notice the implicit conversion to nvarchar(max). To be clear about it, the issue we are analysing here does not occur when Nested Loops prefetching occurs with an expression that was a LOB type to begin with.

The Outer Join

The optimizer is quite good, generally speaking, at moving scalar expressions around. If the query had featured inner joins (whether by query design or through optimizer activities) the chances are quite good that the problematic expressions (the LOB manufacturers) would have moved beyond the prefetching, and so out of harm’s way. It is quite tricky to preserve NULL-extension and other outer-join semantics properly when moving expressions above an outer join, so the optimizer generally does not even try. In essence, the outer join represents an optimization barrier to the LOB-manufacturing expressions.

Memory Allocation

When Nested Loops prefetching occurs with a manufactured LOB, the question arises of where to store the created LOBs when buffering rows for prefetch. If the source data were already a LOB type, the execution engine would already have memory structures in place to handle them. When prefetching encounters a manufactured LOB, it needs to store it somewhere, since the engine is no longer processing a stream of one row at a time. It turns out that there is a small memory buffer set aside for this eventuality, which empirical tests show to be 24KB.

However, this 24KB (directly allocated, not via workspace memory grant) is shared across all concurrently executing prefetching joins in the query. With six such joins in the test rig plan and large manufactured LOBs, the buffer stands no chance. As a result, query execution engages a bail-out option: a work table created in tempdb. Though the pages of the worktable may in fact remain memory-resident, overheads (including latching and using general-purpose code interfaces for access to the buffered rows) mean this is very much slower than using the direct-memory cache.

As with most internal work tables, the logical reads reported on this work table indicate the number of rows processed (not 8KB pages, as for regular I/O statistics). This fact, together with the large number of items processed via the worktable in our test, accounts for the millions of reads reported.

The creation and use of the work table depends on run time conditions and timing. If execution finds the data it needs is already in memory, the prefetch checks are still performed, but no asynchronous read requests end up being posted. The 24KB buffer is never filled, so the need to create a work table never arises. The more prefetch that actually occurs, the higher the chances that the buffer will fill. It is quite possible to experience a low level of prefetch with manufactured LOBs without the engine needing to bail out to a work table, especially if the LOBs are not very big and the I/O system is quite fast.

Workaround

We can rewrite the query to avoid feeding manufactured LOB data to the prefetch buffer. The idea is to use OUTER APPLY to return the data that contributes to the concatenation, rather than the result of the concatenation. We can then perform the CONCAT operation (which handles NULLs nicely without extra work) after the join, avoiding the prefetch buffer issue completely. In SQL Server versions prior to 2012, we would need to use direct string concatenation, and handle rows that are NULL-extended explicitly using ISNULL or COALESCE.

    DECLARE @d nvarchar(max) = NCHAR(10000);

    SELECT 

        n.n,

        DATALENGTH

        (

            CONCAT

            (

                CONCAT(oa1.i0, oa1.i1, oa1.i2, oa1.i3, oa1.i4, oa1.i5, oa1.i6),

                CONCAT(oa2.i0, oa2.i1, oa2.i2, oa2.i3, oa2.i4, oa2.i5, oa2.i6),

                CONCAT(oa3.i0, oa3.i1, oa3.i2, oa3.i3, oa3.i4, oa3.i5, oa3.i6),

                CONCAT(oa4.i0, oa4.i1, oa4.i2, oa4.i3, oa4.i4, oa4.i5, oa4.i6),

                CONCAT(oa5.i0, oa5.i1, oa5.i2, oa5.i3, oa5.i4, oa5.i5, oa5.i6),

                CONCAT(oa6.i0, oa6.i1, oa6.i2, oa6.i3, oa6.i4, oa6.i5, oa6.i6)

            )

        )

    FROM dbo.Numbers AS n

    OUTER APPLY (SELECT i0 = @d, i1 = t.d, i2 = t.d, i3 = t.d, i4 = t.d, i5 = t.d, i6 = t.d FROM dbo.T1 AS t WHERE t.id = n.n) AS oa1

    OUTER APPLY (SELECT i0 = @d, i1 = t.d, i2 = t.d, i3 = t.d, i4 = t.d, i5 = t.d, i6 = t.d FROM dbo.T2 AS t WHERE t.id = n.n) AS oa2

    OUTER APPLY (SELECT i0 = @d, i1 = t.d, i2 = t.d, i3 = t.d, i4 = t.d, i5 = t.d, i6 = t.d FROM dbo.T3 AS t WHERE t.id = n.n) AS oa3

    OUTER APPLY (SELECT i0 = @d, i1 = t.d, i2 = t.d, i3 = t.d, i4 = t.d, i5 = t.d, i6 = t.d FROM dbo.T4 AS t WHERE t.id = n.n) AS oa4

    OUTER APPLY (SELECT i0 = @d, i1 = t.d, i2 = t.d, i3 = t.d, i4 = t.d, i5 = t.d, i6 = t.d FROM dbo.T5 AS t WHERE t.id = n.n) AS oa5

    OUTER APPLY (SELECT i0 = @d, i1 = t.d, i2 = t.d, i3 = t.d, i4 = t.d, i5 = t.d, i6 = t.d FROM dbo.T6 AS t WHERE t.id = n.n) AS oa6

    WHERE n.n BETWEEN 1 AND 10000

    ORDER BY n.n

    OPTION (LOOP JOIN, FORCE ORDER, MAXDOP 1);

The execution plan for the rewritten query looks visually similar to the problematic one:

However, the Compute Scalars no longer manufacture a LOB data type, they just emit column and variable references:

All the concatenation work (and LOB manufacture) is performed by the final top-level Compute Scalar in a single monster expression [Expr1056]:

Warm cache results

With all data in memory, the new query completes in 1.8 seconds (very slightly up on 1.6 seconds before):

Cold cache results

When all data must be fetched from disk, the query issues optimal prefetching and completes in 7.3 seconds (down from 18.6 seconds) with no work table:

The Extended Events wait statistics now show 3.8 seconds spent waiting for my laptop’s slow spinning disk (which is a good thing!)

Final Thoughts

Work tables can appear in STATISTICS IO output for a wide range of reasons, but if you encounter one with a very large number of reads – particularly LOB reads – you may be encountering this issue. The rewrite proposed above may not always be possible, but you should be able to refactor your query to avoid the issue now you know it exists.

I am not a fan of doing large amounts of string manipulation in SQL Server. I am always particularly suspicious of the perceived need to split or concatenate large volumes of strings.

I am, however, a fan of always using explicit data types (rather than relying on implicit conversions) and generating relatively small query plans that offer the query optimizer clear and obvious choices. By necessity, this often means writing small SQL queries in logical steps (and no, long chains of common table expressions do not count!)

The real world does not always make these things possible, of course, but it is good to have goals :)

Screenshots acquired using SnagIt by TechSmith
Query plan details obtained using Plan Explorer PRO by SQLSentry

Incorrect Results with Indexed Views

Paul White — Tue, 05 Feb 2013 22:18:11 GMT

Summary: If you use MERGE, indexed views and foreign keys, your queries can return incorrect results.

Microsoft have released a fix for incorrect results returned when querying an indexed view. The problem applies to:

SQL Server 2012
SQL Server 2008 R2
SQL Server 2008

The Knowledge Base article does not go into much detail, or provide a reproduction script, but this blog entry does :)

The KB does say that reproducing the bug requires these features:

An indexed view on two tables that have a foreign key relationship
An update performed against the base tables
A query executed against the indexed view using a NOEXPAND hint

There are two important details I would like to add right away:

The NOEXPAND hint is not required to reproduce the bug on Enterprise Edition
The update must be performed by a MERGE statement

The fix is available in the following cumulative update packages:

Cumulative Update 2 for SQL Server 2012 SP1 [build 11.0.3339]
Cumulative Update 5 for SQL Server 2012 RTM [build 11.0.2395]
Cumulative Update 4 for SQL Server 2008 R2 SP2 [build 10.50.4270]
Cumulative Update 10 for SQL Server 2008 R2 SP1 [build 10.50.2868]
Cumulative Update 8 for SQL Server 2008 SP3 [build 10.00.5828]

No service pack contains this fix, you must apply one of the hotfix packages above.

Steps to Reproduce

The first thing we will need is two tables:

     CREATE TABLE dbo.Parent 

    (

        parent_id integer IDENTITY NOT NULL,

        value varchar(20) NOT NULL,

        CONSTRAINT PK_Parent_id 

            PRIMARY KEY CLUSTERED (parent_id)

    );

    GO

    CREATE TABLE dbo.Child

    (

        child_id integer IDENTITY NOT NULL,

        parent_id integer NOT NULL,

        CONSTRAINT PK_Child_id 

            PRIMARY KEY CLUSTERED (child_id)

    );

And a few rows of data:

    INSERT dbo.Child (parent_id)

    SELECT New.parent_id 

    FROM 

        (

        INSERT Parent 

        OUTPUT inserted.parent_id 

        VALUES 

            ('Apple'), 

            ('Banana'), 

            ('Cherry')

        ) AS New;

The tables now look like this (parent first):

We can now add the required FOREIGN KEY relationship:

    ALTER TABLE dbo.Child

    ADD CONSTRAINT FK_Child_Parent

    FOREIGN KEY (parent_id)

    REFERENCES dbo.Parent (parent_id);

Next, a very simple indexed view that joins the two tables (the view could contain more complex features like aggregates):

    CREATE VIEW dbo.ParentsAndChildren

    WITH SCHEMABINDING 

    AS

    SELECT 

        p.parent_id, 

        p.value, 

        c.child_id

    FROM dbo.Parent AS p

    JOIN dbo.Child AS c ON 

        c.parent_id = p.parent_id;

    GO

    CREATE UNIQUE CLUSTERED INDEX cuq 

    ON dbo.ParentsAndChildren (child_id);

The final step is to use a MERGE statement to make some changes to the Parent table:

    DECLARE @ParentMerge AS TABLE

    (

        parent_id integer PRIMARY KEY, 

        value varchar(20) NOT NULL

    );

    INSERT @ParentMerge

        (parent_id, value)

    VALUES

        (1, 'Kiwi Fruit'),

        (4, 'Dragon Fruit');

    MERGE dbo.Parent AS p

    USING @ParentMerge AS s ON 

        s.parent_id = p.parent_id

    WHEN MATCHED THEN 

        UPDATE SET value = s.value

    WHEN NOT MATCHED THEN 

        INSERT (value) VALUES (s.value)

    OUTPUT 

        $action, 

        inserted.parent_id, 

        deleted.value AS old_value, 

        inserted.value AS new_value;

This MERGE performs two actions:

Updates the value column of parent row 1 from Apple to Kiwi Fruit
Adds a new parent row 4 for Dragon Fruit

The statement includes an OUTPUT clause to show the changes it makes (this is not required for the repro):

This confirms that the changes have been made as we requested: parent row 1 has changed; and row 4 has been added. The changes are reflected in the base tables:

    SELECT * FROM dbo.Parent AS p;

    SELECT * FROM dbo.Child AS c;

As highlighted, row 1 has changed from Apple to Kiwi Fruit and row 4 has been added.

We do not expect to see row 4 in the indexed view because there are no child records for that row, and the indexed view uses an inner join. Checking the indexed view using the NOEXPAND table hint (required in non-Enterprise SKUs to use indexes on a view):

    SELECT *

    FROM dbo.ParentsAndChildren 

    WITH (NOEXPAND);

The results are incorrect. They show the old value of the data for parent row 1.

Now we try using the EXPAND VIEWS query hint to force SQL Server to access the base tables rather than reading view indexes:

    SELECT *

    FROM dbo.ParentsAndChildren

    OPTION (EXPAND VIEWS);

This query produces correct results.

On SQL Server Enterprise Edition, the optimizer chooses whether to access the indexed view or the base tables. For following query, without any hints, the optimizer chooses not to expand the view. It reads the view index and produces incorrect results:

    -- Enterprise Edition ONLY

    SELECT * 

    FROM dbo.ParentsAndChildren;

Perhaps adding a child row to match the new parent row 4 will somehow fix things up?

    INSERT dbo.Child (parent_id) VALUES (4);

    GO

    SELECT * FROM dbo.ParentsAndChildren WITH (NOEXPAND);

    SELECT * FROM dbo.ParentsAndChildren OPTION (EXPAND VIEWS);

No. The query plan that accesses the view index still returns an incorrect value for row 1. It seems MERGE has corrupted our indexed view.

Analysis using DBCC CHECKTABLE

Checking the view with DBCC CHECKTABLE returns no errors:

    DBCC CHECKTABLE (ParentsAndChildren);

Unless we use the EXTENDED_LOGICAL_CHECKS option:

    DBCC CHECKTABLE (ParentsAndChildren) WITH EXTENDED_LOGICAL_CHECKS;

The damage is repairable:

    ALTER DATABASE Sandpit 

    SET SINGLE_USER 

    WITH ROLLBACK IMMEDIATE;

    GO

    DBCC CHECKTABLE (ParentsAndChildren, REPAIR_REBUILD) WITH EXTENDED_LOGICAL_CHECKS;

    GO

    DBCC CHECKTABLE (ParentsAndChildren) WITH EXTENDED_LOGICAL_CHECKS;

    GO

    ALTER DATABASE Sandpit SET MULTI_USER;

You probably do not want to set your database to SINGLE_USER mode and run a DBCC repair after every MERGE statement, however. We could also rebuild the indexed view’s clustered index manually, of course.

Cause

For the MERGE statement above, the query optimizer builds a plan that does not update the indexed view (click to enlarge):

In a version of SQL Server with the fix applied, the same MERGE statement produces a plan that does maintain the indexed view:

The plan operators used to keep the view index in step with the base tables are highlighted. Without these operators, the changes to the base table are not correctly written to any indexes defined on the view. The root cause is related to the same simplification that allows the optimizer to remove the reference to the Parent table in this query:

    SELECT 

        COUNT_BIG(*)

    FROM dbo.Parent AS p 

    JOIN dbo.Child AS c ON 

        c.parent_id = p.parent_id;

The FOREIGN KEY relationship and NOT NULL constraints on the referencing column together mean that the join to Parent cannot affect the result of the query, so the join is simplified away. In SQL Server 2012, we can see when this simplification is performed because the following message appears when undocumented trace flags 8619 and 3604 are enabled during compilation:

The same message is emitted when a MERGE statement contains a WHEN MATCHED THEN UPDATE clause and either a WHEN NOT MATCHED THEN INSERT or WHEN MATCHED … THEN DELETE clause. These conditions combine such that the optimizer incorrectly concludes that a table reference can be removed, when in fact it is needed later on when the update side of the plan is built.

Other details of the query and database can affect whether the simplification can be misapplied. For example, if the FOREIGN KEY constraint contains an ON DELETE CASCADE clause, and the MERGE contains a DELETE clause, the simplification is not performed, the TF 8619 message does not appear, and the bug does not manifest.

The key to determining whether a particular query is vulnerable to this bug (TF 8619 aside) is to check whether the query plan includes operators to maintain the indexed view. At a minimum, you should see a update operator for the view:

SQL Sentry Plan Explorer identifies the operator as applying to a view explicitly, in SSMS you need to click on the graphical operator and inspect the Properties window.

Summary

The updated conditions for incorrect results are:

An indexed view that joins tables
Two of the tables have a single-column FOREIGN KEY constraint
A MERGE statement contains an UPDATE action that affects one of the tables
The MERGE statement also contains an INSERT or DELETE action (or both)
The optimizer applies a simplification that removes a table reference based on the FK relationship and other metadata
As a result, the MERGE execution plan does not contain the operators necessary to correctly maintain the indexed view
A subsequent query plan accesses an index on the view, either explicitly or via indexed-view matching (Enterprise Edition)

Note:

The simplification is not applied in tempdb
The simplification is not applied to multi-column foreign key constraints

Under these conditions, the indexes on the view do not reflect the state of the base tables and incorrect results are returned. Once the hot fix is applied, the optimizer does not misapply the simplification so the correct indexed view maintenance features are built into execution plans.

Update: I am adding this based on Ian Yates’ great question in the comments: my expectation is that applying this hotfix will not remove any existing indexed view corruption. You would need to test the hotfix as usual, apply it, and then either rebuild all affected indexed views manually, or run DBCC CHECKDB with the EXTENDED_LOGICAL_CHECKS option (which could take a long time).

Twitter: @SQL_Kiwi
Email: SQLKiwi@gmail.com

Deletes that Split Pages and Forwarded Ghosts

Paul White — Thu, 30 Aug 2012 16:09:00 GMT

Can DELETE operations cause pages to split? Yes. It sounds counter-intuitive on the face of it; deleting rows frees up space on a page, and page splitting occurs when a page needs additional space. Nevertheless, there are circumstances when deleting rows causes them to expand before they can be deleted. The mechanism at work here is row versioning (extract from Books Online below):

Isolation Levels

The relationship between row-versioning isolation levels (the first bullet point) and page splits is reasonably clear. Any data that existed before either of the isolation levels was enabled will need to have the 14 bytes added by future data modifications, perhaps causing pages to split. In this scenario, tables will likely contain a mix of records to start with, but over time (particularly as index maintenance is performed) the database will end up with row versions on most records, reducing the chances of a page split for that particular reason.

There is nevertheless a window of opportunity where adding the 14 bytes to an existing record could cause a page split. No doubt there’s a recommendation out there somewhere to rebuild all tables and indexes when enabling or disabling a row-versioning isolation level on a database. This is not all that interesting though, so let’s look at the second bullet point instead:

Triggers

The documentation says that versioning information is added if the table has a trigger. What it doesn’t say is:

The extra bytes for row versioning can be added even where both READ_COMMITTED_SNAPSHOT and SNAPSHOT isolation are OFF.
This only applies to AFTER triggers, not INSTEAD OF triggers
The AFTER trigger also needs to be enabled to generate row versions, the mere existence of a trigger is not enough.
There is a very important exception to all the above…

SQL Server can still avoid adding the row-versioning information even where an enabled AFTER TRIGGER exists (the remainder of this post assumes that both row-versioning isolation levels are OFF, by the way).

Avoiding Row Versioning with Triggers

To explore this behaviour in a bit of detail, we’ll need a test rig:

     USE tempdb;

    GO

    IF  OBJECT_ID(N'dbo.Test', N'U') IS NOT NULL

        DROP TABLE dbo.Test;

    GO

    -- Test table

    CREATE TABLE dbo.Test

    (

        ID          integer IDENTITY PRIMARY KEY,

        Column01    nvarchar(20) NULL,

        Column02    nvarchar(4000) NULL,

    );

    GO

    -- Add some rows

    INSERT dbo.Test WITH (TABLOCKX)

        (Column01)

    SELECT TOP (100000)

        CONVERT(nvarchar(20), N'X')

    FROM sys.columns AS c

    CROSS JOIN sys.columns AS c2

    CROSS JOIN sys.columns AS c3

    OPTION (MAXDOP 1);

    GO

    -- A trigger that does nothing

    CREATE TRIGGER trg

    ON dbo.Test

    AFTER DELETE

    AS RETURN;

    GO

    -- Write any dirty pages to disk

    CHECKPOINT;

    GO

    -- Physical storage before any changes

    SELECT

        ddips.index_type_desc,

        ddips.alloc_unit_type_desc,

        ddips.page_count,

        ddips.record_count,

        ddips.max_record_size_in_bytes

    FROM sys.dm_db_index_physical_stats(

        DB_ID(), OBJECT_ID(N'dbo.Test', N'U'), NULL, NULL, 'DETAILED') AS ddips

    WHERE

        ddips.index_level = 0;

    GO

    -- Buffer pool pages before any changes

    SELECT 

        dobd.[file_id],

        dobd.page_id,

        dobd.page_type,

        dobd.row_count,

        dobd.free_space_in_bytes,

        dobd.is_modified

    FROM sys.partitions AS p

    JOIN sys.allocation_units AS au 

        ON au.container_id = p.hobt_id

    JOIN sys.dm_os_buffer_descriptors AS dobd ON 

        dobd.allocation_unit_id = au.allocation_unit_id

    WHERE

        p.[object_id] = OBJECT_ID(N'dbo.Test', N'U')

    ORDER BY

        dobd.page_id;

    GO

    SET STATISTICS IO ON;

    -- Delete 1 in 10 rows

    DELETE dbo.Test

    WHERE ID % 10 = 0;

    SET STATISTICS IO OFF;

    GO

    SELECT

        [Page Splits] = COUNT_BIG(*)

    FROM sys.fn_dblog(NULL,NULL) AS fd 

    WHERE 

        fd.[Transaction Name] = N'SplitPage';

    GO

    -- Ensure ghosted records are processed so

    --  we see accurate per-page row counts

    DBCC FORCEGHOSTCLEANUP;

    GO

    -- Physical storage after the delete operation

    SELECT

        ddips.index_type_desc,

        ddips.alloc_unit_type_desc,

        ddips.page_count,

        ddips.record_count,

        ddips.max_record_size_in_bytes

    FROM sys.dm_db_index_physical_stats(

        DB_ID(), OBJECT_ID(N'dbo.Test', N'U'), NULL, NULL, 'DETAILED') AS ddips

    WHERE

        ddips.index_level = 0;

    GO

    -- Buffer pool pages after the delete operation

    SELECT 

        dobd.[file_id],

        dobd.page_id,

        dobd.page_type,

        dobd.row_count,

        dobd.free_space_in_bytes,

        dobd.is_modified

    FROM sys.partitions AS p

    JOIN sys.allocation_units AS au 

        ON au.container_id = p.hobt_id

    JOIN sys.dm_os_buffer_descriptors AS dobd ON 

        dobd.allocation_unit_id = au.allocation_unit_id

    WHERE

        p.[object_id] = OBJECT_ID(N'dbo.Test', N'U')

    ORDER BY

        dobd.page_id;

    GO

    --DBCC TRACEON (3604);

    --DBCC PAGE (tempdb, 1, 4720, 3);

The script performs the following actions:

Creates a clustered table with an ID and two data columns
Adds 100,000 rows each with a single ‘X’ character in the first column, and NULL in the second
Creates an AFTER DELETE trigger that does nothing at all except exist and be enabled
Displays physical storage and buffer pool information using DMVs
Deletes every tenth row in the table
Shows the number of leaf-level page splits that occurred
Displays the physical storage and buffer pool information again

Test One – Clustered Table

Typical output:

There are 235 data pages with a maximum physical record size of 17 bytes before and after the delete. Before the delete, each data page contains 426 rows with 2 bytes of free space. After the DELETE:

A total of 10,000 records have been deleted
The data page count remains at 235
The maximum record size is still 17 bytes
Each data page has lost 42 or 43 rows
The free space on each page has risen to 800 or 819 bytes
All data pages are marked as being modified in memory
A total of 237 logical reads are reported

No surprises there.

Test Two – Clustered Table

Now, run the script again with the only change being that Column01 is defined as nvarchar(22) instead of nvarchar(20). The before picture is the same as before, but the situation after the DELETE is very different:

There have been 234 page splits, increasing the data page count from 235 pages to 469 pages, and halving the number of rows on each data page. The number of reads reported has also blown out from 237 previously to 2342 logical reads in this run (a factor of ten worse).

Explanation

The cause of the page splitting is that the deleted records must be versioned. SQL Server 2005 and later uses the version store to build the inserted and deleted pseudo-tables used by AFTER triggers. Where the data has no pre-existing versioning data, adding the 14 bytes will result in a clustered index page split if the page contains insufficient free space to accommodate this expansion.

Temporarily turning off ghost record clean-up using global trace flag 661 and examining an affected data page using DBCC PAGE shows the following (remember to turn the trace flag off afterward if you try this):

Slots 8 and 10 on this page hold records that were unaffected by the DELETE; the physical row length is 17 bytes as displayed previously. The record that was in slot 9 has been deleted. It is a ghost record with versioning information added. The record size is 17 + 14 = 31 bytes, and this expansion with only 2 bytes of free space on the page caused it to split.

This explains why the nvarchar(22) DELETE test caused page splitting, but why didn’t the original nvarchar(20) script behave the same?

There is a performance optimization that can avoid adding row versioning information, but only if the table cannot generate ROW_OVERFLOW or LOB allocation units. This means that the definition of the table must not allow for LOBs or for the possibility of variable length columns moving off row. The actual size of the data stored is immaterial – it is the potential size that matters.

In our test, the nvarchar(22) column definition caused the maximum possible INROW size to just exceed the 8060 byte limit. (The exact INROW limit also depends on the table definition; marking one of the data columns SPARSE would reduce the limit to 8015-8019 bytes – whatever the right number is).

Heaps of Forwarded Ghosts

“Page splitting only occurs in index structures, are heap structured tables affected by this issue too?”

It is true that heap pages do not split, but when a heap row needs to expand, the engine will move the row to another page if insufficient free space exists on the current page. When the storage engine does this, it leaves a forward pointer behind to avoid updating all non-clustered indexes to reflect the new physical row locator.

For a heap table with an active AFTER trigger, and a LOB column (or the possibility of row-overflow) the row has to be versioned and ghosted. If the page contains insufficient free space to accommodate the versioning, the row moves to another page leaving a forwarding stub behind. This results in a forwarded ghost record. Ghost clean-up will normally remove this record pretty quickly, so we will need to disable that process temporarily. The following script creates the very special circumstances necessary to produce a forwarded ghost record this way (note this script is for test systems only should not be run in tempdb):

    USE Sandpit;

    GO

    IF  OBJECT_ID(N'dbo.Test', N'U') IS NOT NULL

        DROP TABLE dbo.Test;

    GO

    -- Heap test

    CREATE TABLE dbo.Test

    (

        ID          integer IDENTITY PRIMARY KEY NONCLUSTERED,

        Column01    nvarchar(16) NULL,

        Column02    nvarchar(4000) NULL

    );

    GO

    -- Add some all-NULL rows

    INSERT dbo.Test WITH (TABLOCKX)

        (Column01)

    SELECT TOP (100000)

        NULL

    FROM sys.columns AS c

    CROSS JOIN sys.columns AS c2

    CROSS JOIN sys.columns AS c3

    OPTION (MAXDOP 1);

    GO

    -- Ensure rows are tightly packed

    ALTER TABLE dbo.Test REBUILD;

    GO

    -- A trigger that does nothing

    CREATE TRIGGER trg

    ON dbo.Test

    AFTER DELETE

    AS RETURN;

    GO

    -- Write any dirty pages to disk

    CHECKPOINT;

    GO

    -- Physical storage before any changes

    SELECT

        ddips.index_type_desc,

        ddips.page_count,

        ddips.record_count,

        ddips.max_record_size_in_bytes,

        ddips.ghost_record_count,

        ddips.forwarded_record_count

    FROM sys.dm_db_index_physical_stats(

        DB_ID(), OBJECT_ID(N'dbo.Test', N'U'), NULL, NULL, 'DETAILED') AS ddips

    WHERE

        ddips.alloc_unit_type_desc = N'IN_ROW_DATA'

        AND ddips.index_level = 0;

    GO

    -- Buffer pool pages before any changes

    SELECT 

        dobd.[file_id],

        dobd.page_id,

        dobd.page_type,

        dobd.row_count,

        dobd.free_space_in_bytes,

        dobd.is_modified

    FROM sys.partitions AS p

    JOIN sys.allocation_units AS au 

        ON au.container_id = p.hobt_id

    JOIN sys.dm_os_buffer_descriptors AS dobd ON 

        dobd.allocation_unit_id = au.allocation_unit_id

    WHERE

        p.[object_id] = OBJECT_ID(N'dbo.Test', N'U')

        AND dobd.page_type = N'DATA_PAGE'

    ORDER BY

        dobd.page_id;

    GO

    -- Disable ghost clean-up

    DBCC TRACEON (661, -1);

    GO

    SET STATISTICS IO ON;

    -- Delete three records on the same page

    DELETE dbo.Test

    WHERE ID BETWEEN 1 AND 3;

    SET STATISTICS IO OFF;

    GO

    -- Physical storage after the delete operation

    SELECT

        ddips.index_type_desc,

        ddips.page_count,

        ddips.record_count,

        ddips.max_record_size_in_bytes,

        ddips.ghost_record_count,

        ddips.forwarded_record_count

    FROM sys.dm_db_index_physical_stats(

        DB_ID(), OBJECT_ID(N'dbo.Test', N'U'), NULL, NULL, 'DETAILED') AS ddips

    WHERE

        ddips.alloc_unit_type_desc = N'IN_ROW_DATA'

        AND ddips.index_level = 0;

    GO

    -- Buffer pool pages after the delete operation

    SELECT 

        dobd.[file_id],

        dobd.page_id,

        dobd.page_type,

        dobd.row_count,

        dobd.free_space_in_bytes,

        dobd.is_modified

    FROM sys.partitions AS p

    JOIN sys.allocation_units AS au 

        ON au.container_id = p.hobt_id

    JOIN sys.dm_os_buffer_descriptors AS dobd ON 

        dobd.allocation_unit_id = au.allocation_unit_id

    WHERE

        p.[object_id] = OBJECT_ID(N'dbo.Test', N'U')

        AND dobd.page_type = N'DATA_PAGE'

        AND dobd.is_modified = 1

    ORDER BY

        dobd.page_id;

    GO

    -- View the appropriate page

    --DBCC TRACEON (3604);

    --DBCC PAGE (0, 1, 339408, 3);

    -- Enable ghost clean-up

    DBCC TRACEOFF (661, -1);

Example output, showing page 453648 receiving a versioned forwarded ghost record (click to enlarge in a new tab):

Partial DBCC PAGE output for the highlighted page:

Summary

If you ever wonder why your deletes are so slow, it is worth checking to see if you are suffering from page splitting due to an enabled trigger and a table definition that allows for LOB allocations or ROW_OVERFLOW. Any table with a LOB column (including the max data types) qualifies, as does one with even a surprisingly small number of variable-length columns, as shown in the examples in this post. This is a great reason to avoid using ‘max’ or old-style LOB data types unnecessarily, and to be careful about the maximum length of ‘normal’ variable-length data types too. Remember, it is the potential maximum row size that is important, not the actual row size.

On a related note, remember that deletes on a heap can only deallocate empty pages if a table lock is acquired? A table definition that allows for LOB or ROW_OVERFLOW prevents that optimization too. So, if your heaps are growing despite DELETE WITH (TABLOCKX), check the maximum possible row length! You could also convert them to clustered tables as well, of course, but that’s a quite different debate.

I would like to acknowledge and thank SQL Server MVP Dmitri V. Korotkevitch who first brought the basic issue to my attention with UPDATE queries. I would strongly encourage you to also read his blog entry showing how this behaviour also affects UPDATE queries, resulting in slow performance and excessive fragmentation.

Thanks for reading.

Temporary Table Caching Explained

Paul White — Thu, 16 Aug 2012 21:51:00 GMT

SQL Server 2005 onward caches temporary tables and table variables referenced in stored procedures for reuse, reducing contention on tempdb allocation structures and catalogue tables. A number of things can prevent this caching (none of which are allowed when working with table variables):

Named constraints (bad idea anyway, since concurrent executions can cause a name collision)
DDL after creation (though what is considered DDL is interesting)
Creation using dynamic SQL
Table created in a different scope
Procedure executed WITH RECOMPILE

Temporary objects are often created and destroyed at a high rate in production systems, so caching temporary objects can be an important optimization. The temporary object cache is just another SQL Server cache (using the general framework) though it’s entries are a bit more visible than most. The sys.dm_os_performance_counters DMV exposes a number of counters under the ‘Temporary Tables & Table Variables’ instance of the Plan Cache object. The cache is also visible through the usual cache DMVs, for example as CACHESTORE_TEMPTABLES in sys.dm_os_memory_cache_counters.

Cached Object Names

The cached objects themselves are visible in tempdb.sys.tables, named with a single # character followed by the 8-character hexadecimal representation of the object id. This is different from the names of ordinary temporary tables, which have the user-supplied name followed by a bunch of underscores and an id.

The following procedure shows a total of nine cache objects created using CREATE TABLE #xyz syntax, table variables, and SELECT…INTO:

     CREATE PROCEDURE dbo.Demo

    AS

    BEGIN

        CREATE TABLE #T1 (dummy int NULL);

        CREATE TABLE #T2 (dummy int NULL);

        CREATE TABLE #T3 (dummy int NULL);

        DECLARE @T1 AS TABLE (dummy int NULL);

        DECLARE @T2 AS TABLE (dummy int NULL);

        DECLARE @T3 AS TABLE (dummy int NULL);

        SELECT * INTO #T4 FROM #T1;

        SELECT * INTO #T5 FROM @T2;

        SELECT * INTO #T6 FROM #T3;

        WAITFOR DELAY '00:00:01'

    END;

    GO

    DBCC FREEPROCCACHE;

    EXECUTE dbo.Demo;

    GO

    SELECT

        t.* 

    FROM tempdb.sys.tables AS t 

    WHERE

        t.name LIKE N'#[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]';

The results show nine separate cached objects:

Notice the relationship between object id and the name e.g. –1383692523 = hex AD868715.

Caching is per object not per procedure

If any of the temporary objects in a procedure are not cacheable for any reason, the others may still be cached. So, for example, if we modify the test above to create an index on table #T5, that particular table will not be cached, but the other temporary objects will be:

    CREATE PROCEDURE dbo.Demo

    AS

    BEGIN

        CREATE TABLE #T1 (dummy int NULL);

        CREATE TABLE #T2 (dummy int NULL);

        CREATE TABLE #T3 (dummy int NULL);

        DECLARE @T1 AS TABLE (dummy int NULL);

        DECLARE @T2 AS TABLE (dummy int NULL);

        DECLARE @T3 AS TABLE (dummy int NULL);

        SELECT * INTO #T4 FROM #T1;

        SELECT * INTO #T5 FROM @T2;

        SELECT * INTO #T6 FROM #T3;

        -- Prevents caching of #T5

        CREATE INDEX nc1 ON #T5 (dummy);

        WAITFOR DELAY '00:00:01'

    END;

    GO

    DBCC FREEPROCCACHE;

    WAITFOR DELAY '00:00:05';

    GO

    EXECUTE dbo.Demo;

There are now only eight cached objects:

Apparently, DROP TABLE is not DDL

Dropping a temporary table in a procedure does not count as DDL, and neither does TRUNCATE TABLE, nor UPDATE STATISTICS. None of these things prevent temporary table caching (so it does not matter whether you explicitly drop a temporary table at the end of a procedure or not).

    CREATE PROCEDURE dbo.Demo

    AS

    BEGIN

        CREATE TABLE #T1 (dummy int NULL);

        CREATE TABLE #T2 (dummy int NULL);

        CREATE TABLE #T3 (dummy int NULL);

        DECLARE @T1 AS TABLE (dummy int NULL);

        DECLARE @T2 AS TABLE (dummy int NULL);

        DECLARE @T3 AS TABLE (dummy int NULL);

        SELECT * INTO #T4 FROM #T1;

        SELECT * INTO #T5 FROM @T2;

        SELECT * INTO #T6 FROM #T3;

        -- Does not prevent caching

        DROP TABLE #T1, #T4, #T6;

        TRUNCATE TABLE #T2;

        TRUNCATE TABLE #T5;

        UPDATE STATISTICS #T3;

        WAITFOR DELAY '00:00:01'

    END;

    GO

    DBCC FREEPROCCACHE;

    WAITFOR DELAY '00:00:05';

    GO

    EXECUTE dbo.Demo;

There are nine cached objects again:

Concurrent executions

If a stored procedure is executed concurrently, multiple separate cached objects may be created in tempdb. There is one cached plan for the procedure but one cached temporary object per execution context derived from that cached plan. Recall that execution contexts are relatively lightweight instances of a cached plan, populated with execution-specific data such as temporary object ids and parameter values (image reproduced from the plan caching white paper):

The runtime contents of a temporary object (table or variable) are obviously specific to a particular execution, so it makes sense for the cached object to be associated with execution contexts rather than the parent plan. There may also be more than one cached plan for a procedure in cache (for example due to compilations with different SET options) and each parent plan will have its own collection of execution contexts, so there can be one cached tempdb object per execution context per plan.

There does not appear to be a fixed limit on the number of these cached objects; I was able to quickly create 2,000 of them using the test procedures above and Adam Machanic’s SQL Query Stress tool running 200 threads. This is the reason for the 1 second delay in the procedure – to make sure the procedure runs for a little while so new execution contexts are generated for each execution rather than reused. The contents of tempdb after that test were as follows:

Statistics on cached temporary objects

Any auto-stats created are linked to the cached temporary table:

    CREATE PROCEDURE dbo.Demo

    AS

    BEGIN

        CREATE TABLE #T1 (dummy int NULL);

        DECLARE @dummy int;

        -- Trigger auto-stats

        SELECT @dummy = dummy 

        FROM #T1

        WHERE dummy > 0;

        WAITFOR DELAY '00:00:01'

    END;

    GO

    DBCC FREEPROCCACHE;

    WAITFOR DELAY '00:00:05';

    GO

    EXECUTE dbo.Demo;

    GO

    SELECT

        t.name,

        t.[object_id],

        s.name,

        s.auto_created

    FROM tempdb.sys.tables AS t

    JOIN tempdb.sys.stats AS s ON

        s.[object_id] = t.[object_id];

In the case of multiple execution contexts, you might be wondering if each of the tempdb objects can have auto-created statistics associated with them. The answer is no: auto-stats are used to compile the parent plan, and execution contexts are derived from that same plan as needed. The metadata looks a little odd though; the statistics are explicitly linked to the object id of the cached temporary object that caused the auto-stats to be created. Other cached tables for the same plan have different ids, and so do not link to the sys.stats entry.

Statistics created using an explicit CREATE STATISTICS statement are not linked to a cached temporary object, for the simple reason that CREATE STATISTICS is considered DDL, and prevents caching from occurring in the first place.

Drop and Create in Detail

The first time a procedure containing a cacheable temporary object is executed, the temporary object is created as normal, then renamed to the hexadecimal internal form described previously when the object is dropped (explicitly or implicitly at the end of the procedure). On subsequent executions, the cached object is renamed to the normal user-visible name when ‘created’ in the procedure, and renamed back to the internal form when it is ‘dropped’. The following script demonstrates the creation and renaming of cached temporary objects:

    USE tempdb;

    GO

    CREATE PROCEDURE dbo.Demo

    AS

    BEGIN

        CREATE TABLE #Demo (i int);

        SELECT 

            t.name,

            t.object_id,

            t.type_desc,

            t.create_date

        FROM sys.tables AS t

        WHERE

            t.name LIKE N'#Demo%';

        DROP TABLE #Demo;

        SELECT

            t.name,

            t.object_id,

            t.type_desc,

            t.create_date

        FROM sys.tables AS t 

        WHERE

            t.name LIKE N'#________';

    END;

    GO

    DBCC FREEPROCCACHE;

    WAITFOR DELAY '00:00:05';

    GO

    CHECKPOINT;

    EXECUTE dbo.Demo;

    GO

    SELECT

        fd.[Current LSN],

        fd.Operation,

        fd.AllocUnitName,

        fd.[Transaction Name],

        fd.[Transaction ID],

        CONVERT(sysname, SUBSTRING(fd.[RowLog Contents 0], 3, 256)),

        CONVERT(sysname, SUBSTRING(fd.[RowLog Contents 1], 3, 256))

    FROM sys.fn_dblog(NULL, NULL) AS fd;

The first time it is run the first part of the output is:

Notice that the object ids are the same, and the object has familiar external name while in scope, but is renamed after the DROP TABLE statement. The transaction log entries displayed are (click to enlarge):

The highlighted section shows the table being renamed in the internal catalogue tables from the user-visible name to the internal name. On the second run, there is an extra renaming log entry in the CREATE TABLE system transaction, as the object is renamed from the internal form to the user-visible name:

The demonstration shows that CREATE TABLE and DROP TABLE for a cached temporary object are replaced by renaming operations.

Cached Object Scope

The cached object is scoped to the query plan that references it. If the plan is evicted from cache for any reason (perhaps by ALTER or DROP PROCEDURE or an explicit DBCC FREEPROCCACHE command) a background thread removes the tempdb object. This is not synchronous to the command that causes the eviction; the delay seems to be 5 seconds or less on current SQL Server versions, and is performed by a system process id. The following code shows the link between the cached temporary table and the cached plans for the stored procedure:

    USE tempdb;

    GO

    IF  OBJECT_ID(N'dbo.Demo', N'P') IS NOT NULL

        DROP PROCEDURE dbo.Demo;

    GO

    CREATE PROCEDURE dbo.Demo

    AS

    BEGIN

        CREATE TABLE #Demo (i int);

    END;

    GO

    DBCC FREEPROCCACHE;

    WAITFOR DELAY '00:00:05';

    GO

    EXECUTE dbo.Demo;

    GO

    SELECT

        t.name,

        t.[object_id],

        t.type_desc,

        t.create_date

    FROM tempdb.sys.tables AS t

    WHERE

        t.name LIKE N'#________';

    GO

    SELECT

        decp.cacheobjtype,

        decp.objtype,

        decp.plan_handle,

        dest.[text]

    FROM sys.dm_exec_cached_plans AS decp

    CROSS APPLY sys.dm_exec_plan_attributes(decp.plan_handle) AS depa

    CROSS APPLY sys.dm_exec_sql_text(decp.plan_handle) AS dest

    WHERE

        decp.cacheobjtype = N'Compiled Plan'

        AND decp.objtype = N'Proc'

        AND depa.attribute = N'objectid'

        AND CONVERT(integer, depa.value) = OBJECT_ID(N'dbo.Demo', N'P');

Example output:

Aside from checking for suitably-named objects in tempdb, there are a number of ways to see how many cached temporary objects (tables and variables) exist, and how many are in use by executing code. One way is to query the sys.dm_os_memory_cache_counters DMV:

    SELECT

        domcc.name,

        domcc.[type],

        domcc.entries_count,

        domcc.entries_in_use_count

    FROM sys.dm_os_memory_cache_counters AS domcc

    WHERE domcc.[type] = N'CACHESTORE_TEMPTABLES';

Another way is to check the performance counters (also accessible via DMV):

    SELECT

        dopc.[object_name], 

        dopc.counter_name, 

        dopc.cntr_value

    FROM sys.dm_os_performance_counters AS dopc

    WHERE

        dopc.[object_name] LIKE N'MSSQL%Plan Cache%'

        AND dopc.instance_name = N'Temporary Tables & Table Variables'

        AND dopc.counter_name IN (N'Cache Object Counts', N'Cache Objects in use');

This second example shows 200 cached objects on a different run:

On SQL Server 2008 and later, we can evict a particular plan handle from cache to show that this removes the cached temporary table:

    DBCC FREEPROCCACHE(0x05000200CC7BDE0940E16D8C000000000000000000000000);

As mentioned, there can be a delay of up to 5 seconds before the cached object is removed after the DBCC statement completes (though the DMVs reflect the cache changes immediately). The more comprehensive test below shows all these things combined:

    -- Cache a temporary object

    EXECUTE dbo.Demo;

    GO

    -- Show the cached table

    SELECT

        t.name,

        t.[object_id],

        t.type_desc,

        t.create_date

    FROM tempdb.sys.tables AS t

    WHERE

        t.name LIKE N'#________';

    DECLARE @plan_handle varbinary(64);

    -- Find the plan handle

    SELECT

        @plan_handle = decp.plan_handle

    FROM sys.dm_exec_cached_plans AS decp

    CROSS APPLY sys.dm_exec_plan_attributes(decp.plan_handle) AS depa

    CROSS APPLY sys.dm_exec_sql_text(decp.plan_handle) AS dest

    WHERE

        decp.cacheobjtype = N'Compiled Plan'

        AND decp.objtype = N'Proc'

        AND depa.attribute = N'objectid'

        AND CONVERT(integer, depa.value) = OBJECT_ID(N'dbo.Demo', N'P');

    -- Truncate the log

    CHECKPOINT;

    -- Evict the plan

    DBCC FREEPROCCACHE(@plan_handle);

    -- Show log entries

    SELECT

        fd.[Current LSN],

        fd.SPID,

        fd.Operation,

        fd.Context,

        fd.AllocUnitName,

        fd.[Transaction Name],

        fd.[Transaction ID],

        fd.[Begin Time],

        fd.[End Time]

    FROM sys.fn_dblog(NULL,NULL) AS fd;

    -- Cached object not dropped yet

    SELECT

        t.name,

        t.[object_id],

        t.type_desc,

        t.create_date

    FROM tempdb.sys.tables AS t

    WHERE

        t.name LIKE N'#________';

    WAITFOR DELAY '00:00:05';

    -- Show cleanup

    SELECT

        fd.[Current LSN],

        fd.SPID,

        fd.Operation,

        fd.Context,

        fd.AllocUnitName,

        fd.[Transaction Name],

        fd.[Transaction ID],

        fd.[Begin Time],

        fd.[End Time]

    FROM sys.fn_dblog(NULL,NULL) AS fd;

    -- Gone!

    SELECT

        t.name,

        t.[object_id],

        t.type_desc,

        t.create_date

    FROM tempdb.sys.tables AS t

    WHERE

        t.name LIKE N'#________';

The first result set shows the cached temporary object:

The transaction log entries immediately after evicting the plan from cache show no activity aside from the CHECKPOINT we issued to truncate the log:

Then we see that the cached object still exists at this point (though the DMVs now show zero cached temporary objects):

After an up-to-five-second delay, the transaction log contains:

Notice the system transaction named ‘droptemp’ is performed by system SPID 14, and instead of the renaming we saw earlier, all references to the cached object are deleted from the system tables.

More about Table Variables

You might recognise the internal hexadecimal name for cached temporary objects; the same is used for table variables outside a stored procedure:

    DECLARE @T AS TABLE (dummy int NULL);

    SELECT

        t.name,

        t.[object_id],

        t.type_desc,

        t.create_date

    FROM tempdb.sys.tables AS t

    WHERE

        t.name LIKE N'#________';

    GO 5

The batch runs five times and produces output like this:

Notice that the object id is different each time (and so, therefore, is the name). As already mentioned, table variables in a stored procedure can be cached just like temporary tables:

    CREATE PROCEDURE dbo.Demo

    AS

    BEGIN

        DECLARE @T AS TABLE (dummy int NULL);

        SELECT

            t.name,

            t.[object_id],

            t.type_desc,

            t.create_date

        FROM tempdb.sys.tables AS t

        WHERE

            t.name LIKE N'#________';

    END

    GO

    EXECUTE dbo.Demo;

    GO 5

Now, though, we see the same object id and create date each time:

Once a table variable is cached, the transaction log records for a simple procedure are quite interesting:

    DBCC FREEPROCCACHE;

    WAITFOR DELAY '00:00:05';

    GO

    CREATE PROCEDURE dbo.Demo

    AS

    BEGIN

        DECLARE @T AS TABLE (dummy int NULL);

        INSERT @T VALUES (1);

    END

    GO

    -- Cache the table variable

    EXECUTE dbo.Demo;

    GO

    SELECT

        t.name,

        t.[object_id],

        t.type_desc,

        t.create_date

    FROM tempdb.sys.tables AS t

    WHERE

        t.name LIKE N'#________';

    GO

    CHECKPOINT;

    GO

    EXECUTE dbo.Demo;

    GO

    SELECT

        fd.[Current LSN],

        fd.Operation,

        fd.AllocUnitName,

        fd.[Transaction Name],

        fd.[Transaction ID]

    FROM sys.fn_dblog(NULL, NULL) AS fd;

Notice the reference to the internal name #628FA481 and the clean up activity. The same procedure with a temporary table instead of a table variable generates a bit more work for the server:

Many of the entries are similar to the table variable case, with extra steps to rename the cached object when CREATE TABLE and the implicit DROP TABLE at the end of the procedure are executed. Clearly, some efforts have been made to make table variables more efficient than temporary tables, while sharing many features in common at quite a low level.

Another interesting thing, as I mentioned right at the start of this post, is that table variables disallow just about all of the actions that prevent caching of a temporary table. Table variables do not allow named constraints or DDL that affects caching (e.g. CREATE INDEX, CREATE STATISTICS). Table variables are also scoped more tightly than temporary tables. While we can create a temporary table in one procedure, and refer to it in another, the same thing cannot be done with table variables. For the same scoping reasons, table variables cannot be defined using dynamic SQL and referenced outside that context. One oddity is TRUNCATE TABLE; disallowed by table variables, but which does not affect caching.

Anyway, the restrictions mean that table variables can always be cached, and don’t allow some of the crazy things that are possible with temporary tables (particularly as regards scoping, but also the cached statistics issue I described in my last post). They also have the potential to perform better (no hidden renaming) at least in some high-volume circumstances. If only we were able to create statistics (with intuitive behaviour!) and indexes after creation, table variables might well make the old Sybase ‘non-shareable temporary tables’ finally redundant. Until then, we are left having to choose one or the other as best we can.

Temporary Tables in Stored Procedures

Paul White — Tue, 14 Aug 2012 15:22:00 GMT

Ask anyone what the primary advantage of temporary tables over table variables is, and the chances are they will say that temporary tables support statistics and table variables do not. This is true, of course; even the indexes that enforce PRIMARY KEY and UNIQUE constraints on table variables do not have populated statistics associated with them, and it is not possible to manually create statistics or non-constraint indexes on table variables. Intuitively, then, any query that has alternative execution plans to choose from ought to benefit from using a temporary table rather than a table variable. This is also true, up to a point.

The most common use of temporary tables is in stored procedures, where they can be very useful as a way of simplifying a large query into smaller parts, giving the optimizer a better chance of finding good execution plans, providing statistical information about an intermediate result set, and probably making future maintenance of the procedure easier as well. In case it is not obvious, breaking a complex query into smaller steps using temporary tables makes life easier for the optimizer in several ways. Smaller queries tend to have a smaller number of possible execution plans, reducing the chances that the optimizer will miss a good one. Complex queries are also less likely to have good cardinality (row count) estimates and statistical information, since small errors tend to grow quickly as more and more operators appear in the plan.

This is a very important point that is not widely appreciated. The SQL Server query optimizer is only as good as the information it has to work with. If cardinality or statistical information is badly wrong at any point in the plan, the result will most likely be a poor execution plan selection from that point forward. It is not just a matter of creating and maintaining appropriate statistics on the base tables, either. The optimizer does use these as a starting point, but it also derives new statistics at every plan operator, and things can quickly conspire to make these (invisible) derived statistics hopelessly wrong. The only real sign that something is wrong (aside from poor performance, naturally) is that actual row counts vary widely from the optimizer’s estimate. Sadly, SQL Server does not make it easy today to routinely collect and analyse differences between cardinality estimates and runtime row counts, though some small (but welcome) steps forward have been made in SQL Server 2012 with new row count information in the sys.dm_exec_query_stats view.

The benefits of using simplifying temporary tables where necessary are potentially better execution plans, now and in the future as data distribution changes and new execution plans are compiled. On the cost side of the ledger we have the extra effort needed to populate the temporary table, and maintain the statistics. In addition, we expect a higher number of recompilations for optimality reasons due to changes in statistics. In short, we have a trade-off between potential execution plan quality and maintenance/recompilation cost.

The problem, though, is that temporary tables do not work quite how (almost) everyone expects them to…

A World Without Temporary Objects

Imagine if temporary tables and table variables did not exist, and we had a complex query with cardinality-estimation difficulties that would be best addressed by breaking the query into parts. The example presented below is necessarily simplified, and uses the AdventureWorks sample database to make it accessible. It is not a query with insurmountable optimization problems by any means, but bear with me.

     IF  OBJECT_ID(N'dbo.Demo', N'P') IS NOT NULL

        DROP PROCEDURE dbo.Demo;

    GO

    CREATE PROCEDURE dbo.Demo

        @StartsWith nvarchar(50)

    AS

    BEGIN

        SET NOCOUNT ON;

        SELECT

            p.Name,

            OrderCount = COUNT_BIG(DISTINCT th.ReferenceOrderID)

        FROM Production.Product AS p

        JOIN Production.TransactionHistory AS th ON

            th.ProductID = p.ProductID

        WHERE

            p.Name LIKE @StartsWith + N'%'

        GROUP BY

            p.Name;

    END;

This procedure returns a count of orders containing a part whose name starts with the specification passed in as a parameter. For example:

    DBCC FREEPROCCACHE;

    EXECUTE dbo.Demo @StartsWith = N'E';

A Short Digression about Parameter Sniffing

The only real optimization issue in this simplified example is parameter-sniffing. The number of rows that match the LIKE predicate varies widely depending on the value of the parameter, which can impact execution plan selection. When the SELECT query is compiled or recompiled, SQL Server uses the actual value of the parameter at the time to estimate the number of rows qualified from the Product table. If the SELECT statement happens to compile or recompile with a parameter that matches very few rows, we get an execution plan like this (click to enlarge the graphic):

    DBCC FREEPROCCACHE;

    EXECUTE dbo.Demo @StartsWith = N'[0-9]';

This plan is cached and reused next time the procedure is called, perhaps with a parameter value that matches more rows than before, but not enough to cause a recompilation:

    EXECUTE dbo.Demo @StartsWith = N'M';

This results in a large number of Key Lookups and a Sort that spills to tempdb physical disk (the warning triangle is new in SQL Server 2012). The memory grant for the sort was sized for the expected 370 rows, not the 22,527 that actually turned up. (If you are curious about the Constant Scan and Compute Scalar in these plans, see my previous post on dynamic seeks for details).

One way (certainly not the only way) to address this parameter-sniffing problem is to ask SQL Server to compile a fresh query plan for the SELECT statement on every execution, using the OPTION (RECOMPILE) query hint:

    ALTER PROCEDURE dbo.Demo

        @StartsWith nvarchar(50)

    AS

    BEGIN

        SET NOCOUNT ON;

        SELECT

            p.Name,

            OrderCount = COUNT_BIG(DISTINCT th.ReferenceOrderID)

        FROM Production.Product AS p

        JOIN Production.TransactionHistory AS th ON

            th.ProductID = p.ProductID

        WHERE

            p.Name LIKE @StartsWith + N'%'

        GROUP BY

            p.Name

        OPTION (RECOMPILE);

    END;

Now we get plans optimized for the particular parameter value at runtime, and (in SQL Server 2008 SP1 CU5 or later) the added bonus that the runtime value of the parameter is embedded into the query so the dynamic seek is not required:

    EXECUTE dbo.Demo @StartsWith = N'[0-9]';

    EXECUTE dbo.Demo @StartsWith = N'M';

Back to the Main Example

However, we are imagining that the example query is much more complex than shown, and we decide to break it into two parts. The first part will fetch qualified items from the Products table, and the second will join the results (with statistics) to the History table. Remember that temporary objects do not exist for this part of the discussion, so we have to use a permanent table:

    ALTER PROCEDURE dbo.Demo

        @StartsWith nvarchar(50)

    AS

    BEGIN

        SET NOCOUNT ON;

        -- Real table to hold intermediate result

        CREATE TABLE dbo.Temp

        (

            ProductID   integer NOT NULL, 

            Name        nvarchar(50) COLLATE DATABASE_DEFAULT NOT NULL

        );

        -- First part of the 'complex' query

        INSERT INTO dbo.Temp

            (ProductID, Name)

        SELECT

            p.ProductID,

            p.Name

        FROM Production.Product AS p

        WHERE

            p.Name LIKE @StartsWith + N'%';

        -- Second part referencing the 'temp' table

        SELECT

            t.Name,

            OrderCount = COUNT_BIG(DISTINCT th.ReferenceOrderID)

        FROM dbo.Temp AS t

        JOIN Production.TransactionHistory AS th ON

            th.ProductID = t.ProductID

        GROUP BY

            t.Name;

        -- Show the statistics for the Name column

        DBCC SHOW_STATISTICS (Temp, Name) WITH STAT_HEADER, HISTOGRAM;

        DROP TABLE dbo.Temp;

    END;

This procedure is not very practical as it stands, because the CREATE TABLE and DROP TABLE statements would make it impossible for more than one user to execute it at the same time. Nevertheless, it does show how most people expect things to work regarding statistics, temporary table lifetimes, and compilation:

    DBCC FREEPROCCACHE;

    EXECUTE dbo.Demo @StartsWith = N'A';

There are three matching Product records, shown below together with the SHOW_STATISTICS output:

Nothing too surprising in the execution plans: the table INSERT is a trivial plan (no choices for the optimizer to make), and the SELECT query has cardinality estimates that are very close to the actual numbers encountered. The warning triangle on the SELECT (again, new for SQL Server 2012) is just suggesting an index for the History table, which we won’t be adding on this occasion.

While the procedure was executing, a Profiler trace captured the following compilation and statistics activity:

The table is created, and since this is the first time the procedure has been run, the INSERT and SELECT statements both incur a deferred compilation. As part of the SELECT compilation, new statistics are created on the Name and ProductID columns of the new table, the DBCC SHOW_STATISTICS command executes, and finally the table is dropped. Now we execute the procedure again but for products that start with ‘E’ rather than ‘A’ as above:

    EXECUTE dbo.Demo @StartsWith = N'E';

This time there are nine matching records, though the statistics-gathering algorithms compress the information into the five histogram steps shown. The execution plan is below (trivial INSERT plan not repeated):

Again, the cardinality estimates are extremely good, and the optimizer selected a nested loops plus key-lookup plan based on costs computed according with the smaller number of expected rows. The trace captured the following:

The only change is that this time recompilation is triggered because the cached INSERT and SELECT plans reference a table that no longer exists, leading to a ‘schema changed’ recompilation. The crucial observations here are that the table is recreated and new statistics are gathered on every execution. This is the way most people expect tables, statistics, and compilations to behave inside stored procedures, so don’t worry if there’s nothing too surprising so far.

Using a Temporary Table

The previous example is not terribly practical. It is possible to conjure up schemes where ordinary tables can serve the purpose effectively, but as it stands, the procedure would likely cause runtime errors if more than one user or process attempted to execute it concurrently. In addition, ordinary tables do not benefit from engine optimizations that only apply to genuine temporary tables, so they tend to be less efficient, even if created in tempdb. We now return to the real world (where temporary tables do exist) and modify the procedure to use a temporary table instead of a permanent table:

    ALTER PROCEDURE dbo.Demo

        @StartsWith nvarchar(50)

    AS

    BEGIN

        SET NOCOUNT ON;

        CREATE TABLE #Temp

        (

            ProductID   integer NOT NULL,

            Name        nvarchar(50) COLLATE DATABASE_DEFAULT NOT NULL

        );

        INSERT INTO #Temp

            (ProductID, Name)

        SELECT

            p.ProductID,

            p.Name

        FROM Production.Product AS p

        WHERE

            p.Name LIKE @StartsWith + N'%';

        SELECT

            t.Name,

            OrderCount = COUNT_BIG(DISTINCT th.ReferenceOrderID)

        FROM #Temp AS t

        JOIN Production.TransactionHistory AS th ON

            th.ProductID = t.ProductID

        GROUP BY

            t.Name;

        DBCC SHOW_STATISTICS (N'tempdb..#Temp', Name) WITH STAT_HEADER, HISTOGRAM;

        DROP TABLE #Temp;

    END;

Executing this procedure with an ‘E’ parameter produces exactly the same output as when the permanent table was used. Same execution plan, same statistics, same Profiler output, everything:

    DBCC FREEPROCCACHE;

    EXECUTE dbo.Demo @StartsWith = N'E';

Now we will execute the procedure with a parameter value of ‘T’, which has 65 matching records in the Product table. This is the output (only the first nine of the 65 matching names are shown in the first result set):

The results are as expected (products that begin with ‘T’) but the SHOW_STATISTICS output displays ‘E’ statistics from the previous execution!

The execution plan has serious cardinality estimation errors. It has the same nested loops and key-lookup shape and estimated row counts as the ‘E’ execution, instead of being optimized for the ‘T’ data. This causes slow performance and a sort that spills data to physical tempdb disk.

The Profiler output explains why: no recompilations occurred, and no statistics were created. In fact, with the AdventureWorks database, there is no way to persist a different execution plan or update the statistics for this procedure without changing it (more on that later). Even executing with [A-Z] as the parameter reuses the plan optimized for the ‘E’ value:

    EXECUTE dbo.Demo @StartsWith = N'[A-Z]';

The key lookup is now executed 113,443 times, and the sort has to perform a multi-pass spill to tempdb (previously only a single pass spill was required). Executing the procedure with the WITH RECOMPILE option will produce better plans, at the cost of recompiling the whole procedure, and the resulting plans will not be cached for reuse. In general, recompiling the whole procedure every time could be bad since many procedures have many more statements to recompile than just a single INSERT and SELECT. Although we have not yet identified a cause for the behaviour we are seeing, perhaps the answer lies in adding a RECOMPILE query hint to the SELECT statement as we did earlier for the parameter-sniffing example?

OPTION (RECOMPILE) to the Rescue?

Thinking that the cause might be a new form of the parameter-sniffing problem, we now modify the procedure to add the RECOMPILE query hint to just the SELECT statement. This avoids recompiling the whole procedure on each call as EXECUTE … WITH RECOMPILE would do, and will hopefully solve our optimization problems:

    ALTER PROCEDURE dbo.Demo

        @StartsWith nvarchar(50)

    AS

    BEGIN

        SET NOCOUNT ON;

        CREATE TABLE #Temp

        (

            ProductID   integer NOT NULL,

            Name        nvarchar(50) COLLATE DATABASE_DEFAULT NOT NULL

        );

        INSERT INTO #Temp

            (ProductID, Name)

        SELECT

            p.ProductID,

            p.Name

        FROM Production.Product AS p

        WHERE

            p.Name LIKE @StartsWith + N'%';

        SELECT

            t.Name,

            OrderCount = COUNT_BIG(DISTINCT th.ReferenceOrderID)

        FROM #Temp AS t

        JOIN Production.TransactionHistory AS th ON

            th.ProductID = t.ProductID

        GROUP BY

            t.Name

        OPTION (RECOMPILE);

        DBCC SHOW_STATISTICS (N'tempdb..#Temp', Name) WITH STAT_HEADER, HISTOGRAM;

        DROP TABLE #Temp;

    END;

Unsurprisingly, clearing the plan cache and executing with a parameter value of ‘E’ produces the exact same nested loops and key lookup plan as previously shown (and the same statistics and Profiler events too).

    DBCC FREEPROCCACHE;

    EXECUTE dbo.Demo @StartsWith = N'E';

This is fine because it is the optimal plan for this value. The test for OPTION (RECOMPILE) comes when we try a second execution with the 65-row ‘T’ value:

    EXECUTE dbo.Demo @StartsWith = N'T';

The execution plan has a different shape now, with the optimizer correctly preferring a hash join over the nested loops plus key lookup. The estimated cardinality is correct for the temporary table (65 rows versus 9 previously seen for ‘E’), but it is badly wrong for the hash join (811 rows expected, 12,273 actual) and the distinct sort, which has to perform a single-pass spill to tempdb disk. The query output shows the reason for the inaccuracy:

The results are correct of course (65 products starting with ‘T’) but the statistics are again still reflecting the parameter value ‘E’. The RECOMPILE query hint allows the optimizer to see the true cardinality of the temporary table (65 rows) but the 100% wrong statistics on the ProductID column used to estimate the cardinality of the join to the History table result in a mess of a plan from that point forward. (Note that statistics on the Name column are also considered interesting by the optimizer for this query due to the GROUP BY clause. The SHOW_STATISTICS output above shows the Name statistics because it more immediately shows that ‘E’ values are stored; the ProductID statistics are integers, and much harder for the reader to correlate with the parameter).

The Profiler output above confirms the recompilation due to the query hint, and that no statistics were created or updated. An interesting thing occurs if we execute the procedure four more times with the same ‘T’ parameter (a total of five times with ‘T’):

    EXECUTE dbo.Demo @StartsWith = N'T';

    EXECUTE dbo.Demo @StartsWith = N'T';

    EXECUTE dbo.Demo @StartsWith = N'T';

    EXECUTE dbo.Demo @StartsWith = N'T';

The first three of those executions are exactly as before, but the fourth one suddenly produces this different execution plan:

The estimates are now well within the boundaries of expected accuracy, and the sort now receives enough workspace memory to avoid spilling rows to tempdb.

The statistics have been updated, and now show 65 rows that start with ‘T’ sampled (compressed into 49 histogram steps). This is confirmed by the trace output:

Notice the StatMan and AutoStats entries showing the ProductID and Name statistics being updated. Unfortunately, executing the procedure again with a new parameter value takes us back to inaccurate cardinality estimates again. The execution plans for this procedure aren’t always a disaster, but this is pure luck – poor estimates are poor estimates, whether the query plan happens to perform acceptably or not. We really need to get to the root cause here. Perhaps OPTION (RECOMPILE) was not the way to go, and we should try a manual statistics update instead of relying on automatic statistics updates…?

Manual Statistics Update to the Rescue?

We know we want to add an UPDATE STATISTICS command to our stored procedure instead of the OPTION (RECOMPILE) … but where to put the new statement exactly? The statistics we want to update are created during compilation or recompilation of the SELECT statement, suggesting the UPDATE STATISTICS should come after the SELECT; but then how could it possibly affect the preceding SELECT plan? It seems the only sensible place to put it is before the SELECT, however counter-intuitive it might seem.

    ALTER PROCEDURE dbo.Demo

        @StartsWith nvarchar(50)

    AS

    BEGIN

        SET NOCOUNT ON;

        CREATE TABLE #Temp

        (

            ProductID   integer NOT NULL,

            Name        nvarchar(50) COLLATE DATABASE_DEFAULT NOT NULL

        );

        INSERT INTO #Temp

            (ProductID, Name)

        SELECT

            p.ProductID,

            p.Name

        FROM Production.Product AS p

        WHERE

            p.Name LIKE @StartsWith + N'%';

        UPDATE STATISTICS #Temp;

        SELECT

            t.Name,

            OrderCount = COUNT_BIG(DISTINCT th.ReferenceOrderID)

        FROM #Temp AS t

        JOIN Production.TransactionHistory AS th ON

            th.ProductID = t.ProductID

        GROUP BY

            t.Name;

        DBCC SHOW_STATISTICS (N'tempdb..#Temp', Name) WITH STAT_HEADER, HISTOGRAM;

        DROP TABLE #Temp;

    END;

Following the same pattern as before, we clear the plan cache (though this isn’t strictly necessary since the ALTER PROCEDURE evicts plans from the cache anyway) then execute with ‘E’ and ‘T’ parameters as before.

    DBCC FREEPROCCACHE;

    EXECUTE dbo.Demo @StartsWith = N'E';

    EXECUTE dbo.Demo @StartsWith = N'T';

The results for the ‘E’ execution are the same as always, so here are just the results for the ‘T’ execution:

The above output looks very promising: correct results and the statistics have been updated to reflect the ‘T’ parameter.

The trace output shows the statistics updates too…but no recompilation.

The execution plan is a disaster. The estimated number of rows in the temporary table is 9 (the number of rows the ‘E’ execution produced not the 65 actually present), and everything is wrong from that point forward, including the sort spilling to tempdb again. The UPDATE STATISTICS command did its job, but the cached query plan did not recompile – though we might expect that it should, right?

As with the first temporary table example (no RECOMPILE or UPDATE STATISTICS) this plan is stuck in cache, given the AdventureWorks database. No parameter value will cause a recompilation, and every subsequent execution will use the ‘E’ plan. This is very reminiscent of the parameter-sniffing problem we encountered earlier, though the SELECT query in question has no direct parameter value to be sniffed! In a final effort to produce reliable plans, our last attempt will be to combine both RECOMPILE and UPDATE STATISTICS…

RECOMPILE and UPDATE STATISTICS to the Rescue?

Our stored procedure now includes an UPDATE STATISTICS before the SELECT, and an OPTION (RECOMPILE) query hint on the SELECT itself:

    ALTER PROCEDURE dbo.Demo

        @StartsWith nvarchar(50)

    AS

    BEGIN

        SET NOCOUNT ON;

        CREATE TABLE #Temp

        (

            ProductID   integer NOT NULL,

            Name        nvarchar(50) COLLATE DATABASE_DEFAULT NOT NULL

        );

        INSERT INTO #Temp

            (ProductID, Name)

        SELECT

            p.ProductID,

            p.Name

        FROM Production.Product AS p

        WHERE

            p.Name LIKE @StartsWith + N'%';

        UPDATE STATISTICS #Temp;

        SELECT

            t.Name,

            OrderCount = COUNT_BIG(DISTINCT th.ReferenceOrderID)

        FROM #Temp AS t

        JOIN Production.TransactionHistory AS th ON

            th.ProductID = t.ProductID

        GROUP BY

            t.Name

        OPTION (RECOMPILE);

        DBCC SHOW_STATISTICS (N'tempdb..#Temp', Name) WITH STAT_HEADER, HISTOGRAM;

        DROP TABLE #Temp;

    END;

Our usual test executions:

    DBCC FREEPROCCACHE;

    EXECUTE dbo.Demo @StartsWith = N'E';

    EXECUTE dbo.Demo @StartsWith = N'T';

The first ‘E’ execution performs as it always has: correct statistics and an optimal query plan. The results for ‘T’ are:

The output is correct, and so are the statistics: 65 rows sampled, stored in 49 histogram steps.

Success! All estimates are very good, the sort is performed in memory, and the query executes quickly. Further experimentation with other parameter values shows that new statistics are always generated, and the SELECT query plan always recompiles to use those statistics. If you are concerned by the small discrepancy after the hash join (estimate 10,449 rows; actual 12,273) don’t be. Cardinality estimation is a tough problem – try using the statistics histograms yourself to predict how the ProductID values in the temporary table (65 rows in 49 steps, remember) will join to the histogram on the same column for the much larger History table. You’ll find the data there even more compressed, so the task of matching values to values using RANGE_ROWS, EQ_ROWS and so on is really not an easy one at all.

Enter the Table Variable…

The final option we are going to look at is using a table variable instead of a temporary table:

    ALTER PROCEDURE dbo.Demo

        @StartsWith nvarchar(50)

    AS

    BEGIN

        SET NOCOUNT ON;

        DECLARE @Temp AS TABLE

        (

            ProductID   integer NOT NULL,

            Name        nvarchar(50) NOT NULL

        );

        INSERT INTO @Temp

            (ProductID, Name)

        SELECT

            p.ProductID,

            p.Name

        FROM Production.Product AS p

        WHERE

            p.Name LIKE @StartsWith + N'%';

        SELECT

            t.Name,

            OrderCount = COUNT_BIG(DISTINCT th.ReferenceOrderID)

        FROM @Temp AS t

        JOIN Production.TransactionHistory AS th ON

            th.ProductID = t.ProductID

        GROUP BY

            t.Name

        OPTION (RECOMPILE);

    END;

There are a couple of small changes to the procedure here. The COLLATE clause is not necessary in the definition of the Name column, since the default for table variables is the collation of the host database anyway (the default for temporary tables is the collation of tempdb). There is no need (or option) to drop the table at the end of the procedure; table variables simply go out of scope. There is no SHOW_STATISTICS statement either, since table variables do not support statistics (even on constraint-supporting indexes). The first execution with a parameter value of ‘E’ produces this execution plan and trace output:

The OPTION (RECOMPILE) on the SELECT statement ensures that the cardinality estimate for the table variable is exactly right, but the lack of statistics means the optimizer resorts to guesses after that point. The guessed estimates turn out to be higher than the actual number of rows, so no performance problems result, although the sort is allocated more memory than it needs. The trace output is a bit smaller than before, since no statistics are created.

The second test is with a parameter value of ‘T’:

Again, the number of rows in the table variable is exactly right due to the RECOMPILE, and the later guesswork also turns out to work quite well. As you can see, the overall shape of the plan is quite different for this parameter value (hash joins versus nested loops for example). There is one cardinality estimation problem at the middle hash operator, but whether it causes performance problems or not depends on your version of SQL Server. To make the issue clearer, we will perform one final test, a parameter value of ‘[A-Z]’, qualifying all 504 products:

Once more, the table variable cardinality is exactly right (504 rows). Both inputs to the hash join look exactly right, and the guessed output from that join is also very close to the actual. The lack of statistical information makes itself felt at the middle hash operator though; the optimizer has no idea how many distinct values there might be of the combination (Name, OrderID), so it guesses at 2,825. This is very much smaller than the 113,338 actual, and the hash table spills out to tempdb physical disk as a result.

The table variable approach happens to produce reasonable plans in some cases, based on the sniffed table cardinality provided by OPTION (RECOMPILE) but the lack of statistics leads to wild guesses and potential performance issues deeper in the tree. It’s interesting that one of the main perceived benefits of table variables – fewer recompilations – has to be abandoned in order to produce semi-reasonable plans. This follows hard on the heels of our seeing the main benefit of temporary tables – statistics – being 100% wrong earlier!

The last thing I want to mention about table variables is that for all their limitations, they do something else temporary tables cannot: a join from a table variable is estimated for the average case summed over all rows. This is similar to hinting OPTIMIZE FOR UNKNOWN for a temporary table query with a parameter, but the average-case estimation occurs for all joined rows, not just one predicate, and of course there is no parameter variable in a join for OPTIMIZE FOR UNKNOWN to work on anyway.

Question Time

At this point, you should have some questions. Why does the temporary table behave so differently from the permanent table? Do you really have to UPDATE STATISTICS before they are created, and add OPTION (RECOMPILE) when you use temporary tables this way? Why does the RECOMPILE query hint only produce the desired effect with temporary tables every so often? Part of the answer to these questions lies with the caching of temporary tables first introduced to SQL Server in the 2005 version.

CREATE and DROP, Don’t

I will talk about this in much more detail in my next post, but the key point is that CREATE TABLE and DROP TABLE do not create and drop temporary tables in a stored procedure, if the temporary object can be cached. The temporary object is renamed to an internal form when DROP TABLE is executed, and renamed back to the same user-visible name when CREATE TABLE is encountered on the next execution. In addition, any statistics that were auto-created on the temporary table are also cached. This means that statistics from a previous execution remain when the procedure is next called. The following code demonstrates the object id of a temporary table remaining the same between executions (there will be a more comprehensive demonstration in my next post):

    ALTER PROCEDURE dbo.Demo

    AS

    BEGIN

        CREATE TABLE #Temp (col1 int NULL);

        SELECT ObjectID = OBJECT_ID(N'tempdb..#Temp');

        DROP TABLE #Temp;

    END;

    GO

    EXECUTE dbo.Demo;

    EXECUTE dbo.Demo;

    EXECUTE dbo.Demo;

This is very different from the case where we used a permanent table. With a permanent table, CREATE and DROP definitely do create and drop a table on each execution of the procedure. The table is new each time, new statistics are created, and new plans are compiled on each execution. The permanent table behaviour is probably more intuitive than the apparently strange behaviour of cached temporary tables, but it does allow temporary tables an opportunity to cache plans and temporary objects for reuse, which is not possible when using a permanent table in the way we did.

Recompilation Thresholds

Most of you will be familiar with the concept of recompilation thresholds, as described in the Plan Caching in SQL Server White Paper. Briefly though, cached query plans include a Recompilation Threshold (RT) for statistics considered interesting by the optimizer while compiling the plan. The query plan also records the cardinality of tables and indexed views referenced by the plan, at the time the plan is compiled. (I demonstrated how to determine which statistics are considered ‘interesting’ by the optimizer during compilation in a previous post).

Generally, if the column modification counter (colmodctr) for interesting statistics change by RT or more, the query recompiles. Similarly, if the table cardinality has changed by RT or more compared with the value stored at the time the cached plan was created, the query plan also recompiles. The value of RT depends on the type of table (permanent or temporary) and the number of rows (n) in the table or indexed view at the time of compilation. The following summary of RT values is taken from the White Paper:

There is another condition not listed above. If the table is empty at compilation time, RT is set to 1.

I say “generally” above because although queries referencing permanent tables recompile when interesting statistics modification counters change by RT or more, this is not the case for cached temporary tables in stored procedures, which only recompile when table cardinality changes by RT or more, unless OPTION (RECOMPILE) is used, when statistics counters come back into play. If this sounds confusing, that’s because it is. It may be a bug, but on the other hand, it does seem reasonable that a cached temporary table should not cause a recompilation simply because the procedure is called a number of times with the same parameter, with the number of modifications accumulating on each call to eventually pass RT. In that specific case, we would probably prefer no recompilations. I will probably file a Connect item to get the situation with statistics modification counters and temporary tables clarified. Update: the Connect item can be found here.

In our experiments, this explains why the vanilla temporary table procedure (with no RECOMPILE or UPDATE STATISTICS) stuck with the same plan, whereas adding RECOMPILE meant the plan would occasionally recompile (when accumulated changes passed RT). The vanilla procedure was initially called with a parameter value of ‘E’, which compiled a SELECT execution plan when 9 rows were in the temporary table. Following the rules above for n=9, this means RT was set to 500, so the plan would recompile when n reached 9 + 500 = 509. The AdventureWorks Product table only contains 504 rows, so that target could not be reached, and the plan never recompiled.

When OPTION (RECOMPILE) was added, the modification counters did accumulate to eventually pass RT. The first execution was the same, with the ‘E’ parameter value resulting in 9 rows in the temporary table at compilation time, with RT = 509 as before. We then ran the procedure a total of five times with a parameter value of ‘T’. There happen to be 65 product names that start with ‘T’, so five executions resulted in 5 * 65 = 325 changes. This does not reach the target of 509, but there is a second factor in play here. Although the temporary table is not dropped at the end of the procedure (just renamed), it is implicitly truncated (whether an explicit DROP TABLE is included in the procedure or not). This implicit truncation removes 65 rows on each execution, and this action adds to the modification counters.

On each ‘T’ execution then, 65 modifications are counted when the rows are added to the temporary table, and 65 more when the table is silently cleared at the end of the procedure. In total, the first four ‘T’ executions result in 65 * 2 * 4 = 520 modifications, which is enough to pass the 509 target. That in itself is not enough to cause a recompilation though, because the RT test is performed as each query is retrieved from the plan cache for execution, and the final 65-row truncation happens at the end of the procedure, after the SELECT has already completed. On the next execution, whatever parameter is passed in, a recompilation will occur at the SELECT query. The OPTION (RECOMPILE) version of the procedure is reproduced below:

    ALTER PROCEDURE dbo.Demo

        @StartsWith nvarchar(50)

    AS

    BEGIN

        SET NOCOUNT ON;

        CREATE TABLE #Temp

        (

            ProductID   integer NOT NULL,

            Name        nvarchar(50) COLLATE DATABASE_DEFAULT NOT NULL

        );

        INSERT INTO #Temp

            (ProductID, Name)

        SELECT

            p.ProductID,

            p.Name

        FROM Production.Product AS p

        WHERE

            p.Name LIKE @StartsWith + N'%';

        SELECT

            t.Name,

            OrderCount = COUNT_BIG(DISTINCT th.ReferenceOrderID)

        FROM #Temp AS t

        JOIN Production.TransactionHistory AS th ON

            th.ProductID = t.ProductID

        GROUP BY

            t.Name

        OPTION (RECOMPILE);

        DBCC SHOW_STATISTICS (N'tempdb..#Temp', Name) WITH STAT_HEADER, HISTOGRAM;

        DROP TABLE #Temp;

    END;

Now run the tests as described above:

    -- 9 rows, RT = 509

    EXECUTE dbo.Demo @StartsWith = N'E';

    -- 65 rows, 4 times = 260

    -- Plus truncation modifications = 520

    EXECUTE dbo.Demo @StartsWith = N'T';

    EXECUTE dbo.Demo @StartsWith = N'T';

    EXECUTE dbo.Demo @StartsWith = N'T';

    EXECUTE dbo.Demo @StartsWith = N'T';

    -- No rows, but plan still recompiled

    EXECUTE dbo.Demo @StartsWith = N'5';

There are no products that start with ‘5’, but the 520 modifications already performed cause a recompilation anyway:

No results, and NULL statistics created! Luckily, the new RT value after this compilation is 1, so just one row is needed to produce a new plan. This is demonstrated by calling the same procedure again with a ‘K’ parameter value (just one product name starts with ‘K’):

    EXECUTE dbo.Demo @StartsWith = N'K';

After this compilation, the new RT is 1 + 6 = 7, which can be confirmed by executing the procedure with a parameter value of ‘P’ (there are exactly seven Product rows where the name starts with ‘P’). And so on.

I should mention though, that it is just the carry-over of accumulated modifications that requires OPTION (RECOMPILE). Without this query hint, modifications are still accumulated within a single execution of the procedure (and may result in recompilation local to that single execution) but any accumulation is not carried over to the next procedure execution.

Statistics Updates

So far we have explained how the vanilla and OPTION (RECOMPILE) procedures produce the observed behaviour. The next configuration to examine is where OPTION (RECOMPILE) is not specified, but an UPDATE STATISTICS statement appears before the problematic SELECT query. It should now be apparent that the placing of the UPDATE STATISTICS statement works because auto-created statistics from a previous execution are cached, and available for update by the next execution. The one remaining question is why the updated statistics do not cause a recompilation in our example – remember we saw correct statistics, but the execution plan was not rebuilt to reflect the new information. This is either a bug, or another example of different behaviour for cached temporary tables. In any case, the observed behaviour does not match that described in the White Paper (the same diagram appears in the SQL Server Internals books from Microsoft Press):

Whether this is a bug or undocumented designed behaviour (and it is the same on all versions of SQL Server from 2005 to 2012 inclusive) the effect is clear: UPDATE STATISTICS on a cached temporary table in a stored procedure is not enough on its own to force recompilation of a query plan. A recompilation may still occur for other reasons, for example if the cardinality of the table has changed by RT or more compared with the cardinality value stored with the cached plan. This cannot happen with our UPDATE-STATISTICS-only test procedure as shown earlier, since the first execution with the ‘E’ parameter value adds 9 rows to the temporary table, setting RT to 509, and the AdventureWorks Product table only has 504 rows in total as mentioned earlier.

For the moment, at least, we may need to specify OPTION (RECOMPILE) as well as UPDATE STATISTICS if we want to be sure of a plan specific to the contents of a cached temporary table on each execution.

Summary and Final Thoughts

Temporary tables in stored procedures have a number of characteristics that may seem unexpected:

Temporary objects may be cached across executions, despite explicit CREATE and DROP statements
Statistics associated with a cached temporary object are also cached
Statistics may be 100% wrong compared with the current contents of a temporary table
An implicit TRUNCATE TABLE at the end of the procedure doubles the expected impact on column modification counters
It is possible to update cached statistics before the statement that caused them to be created
OPTION (RECOMPILE) changes the way column modifications are carried over between procedure calls
Manual UPDATE STATISTICS is not enough to force a recompilation

It is possible that one or more of these behaviours is unintentional, but they have been this way for a very long time, and so are very unlikely to be changed. Temporary tables behave quite similarly (aside from the UPDATE STATISTICS behaviour) to an in-procedure reference to a permanent table that was created outside the procedure. It may be that some of the features of temporary tables shown in this post have their roots in a design that sought to mimic permanent table behaviours using non-sharable local temporary tables. On the other hand, it might be simply that the current arrangement provides the best chances for caching and reuse, and we are expected to take action where we suspect reusing the cached plan, temporary object, and/or statistics may not be optimal. Who knows.

How likely you are to be affected by the issues illustrated in this post depends on usage. A temporary table that contains wildly differing numbers of rows on every execution is unlikely to be affected. If the recompilation threshold is passed, chances are you will get good statistics and any cached plan with recompile without intervention. For a plan cached when the temporary table contained 10,000 rows the default threshold is 500 + 0.2 * 10,000 = 2,500 rows. This means the next execution with more than 12,500 rows or fewer than 7,500 rows will pass the threshold test. The formula to compute RT values when trace flag 2371 is enabled is unknown to me.

In principle, in later versions of SQL Server, we can look in the plan cache to check the cardinality of a temporary table and deduce the RT from there, but this is not convenient to do routinely. In practice, RT moves around a fair bit, so it can be hard to know how often a procedure might use stale cached statistics or a sub-optimal cached plan. Avoiding temporary table caching removes the risk of stale statistics, but a cached plan may still be used unless the RECOMPILE query hint is used. Avoiding temporary table caching will also tend to increase contention on tempdb, and can be difficult to enforce in practice.

Procedures that routinely store relatively small result sets and use cached temporary tables are probably most at risk. This is quite a common scenario: temporary tables are often used for smaller sets (writing away large temporary tables is more difficult to justify). One scenario that springs to mind is where a delimited string is passed as a parameter, split to a cached temporary table, which is then used to drive a more complex query. The plan for the complex query may be very sensitive to the cardinality and statistical distribution of values in the temporary table, so 100% wrong cached statistics and/or inappropriate plan reuse may be a problem. I’m sure there are many other scenarios.

It is quite ironic that the poor temporary table execution plans shown in this post are caused by the thing that is perceived to be their greatest strength: the availability of distribution statistics. Some care is needed when choosing between table variables, temporary tables or another technique; the right choice in any particular circumstance will depend on many factors, only a few of which have been discussed today. Whichever option you choose, be sure to understand the choice you have made and the trade-offs that result.

There are also times where the best-performing solution will be to carefully craft one huge query, perhaps using hints and/or specific syntax tricks. This approach is perfectly valid but requires careful thought as future maintenance may be harder, and data changes over time may mean the carefully-designed manual execution plan gradually (or suddenly) becomes sub-optimal. My general preference is still for simpler relational queries and, where necessary, for temporary tables over table variables as a starting point, but the details do indeed depend on the details. If you happen to be attending the PASS Summit 2012, I will be speaking more about these sorts of things in my half day and regular sessions.

I hope you enjoyed this post, the next one will cover details of temporary table caching that I did not have space for today. I would like to thank Dave Ballantyne (blog | twitter) for his help with today’s post.

Query Optimizer Deep Dive - Part 4

Paul White — Mon, 30 Apr 2012 13:36:00 GMT

This is the final part in a series of posts based on the content of the Query Optimizer Deep Dive presentations I have given over the last month or so at the Auckland SQL Users’ Group and the SQL Saturday events in Wellington, New Zealand and Adelaide, Australia.

Links to other parts of this series: Part 1 Part 2 Part 3

Beating the Optimizer

Our test query produces an optimized physical execution plan that is quite different from the logical form of the query. The estimated cost of the execution plan shown below is 0.0295 units.

Since we know the database schema very well, we might wonder why the optimizer did not choose to use the unique nonclustered index on names in the product table to filter rows based on the LIKE predicate. We could use an index hint to force the name index to be used:

That’s great, and no doubt the index seek is cheaper than the scan we had previously, but the optimizer has still chosen to use a merge join, and that means having both inputs sorted on Product ID. The result of the index seek is ordered by name (the index key) rather than Product ID, so a sort is required. It looks like the new sort adds a little more cost than the seek saves over the scan, because the estimated cost of the query plan with the index hint is 0.0316 units.

Naturally, these numbers are rather small since AdventureWorks is not a large database, but these differences can be important in real systems. Anyway, let’s persist with the index seek idea; why is the optimizer so keen on a merge join, even though it involves an extra sort, and we don’t have an ORDER BY Product ID clause on our query? Without a top-level ORDER BY, we are giving the optimizer the freedom to return results in any order that is convenient – perhaps we can do better by forcing the index seek and a hash join instead of a merge join?

Well the sort has gone, so the plan looks visually a little simpler, but the estimated cost has increased again, to 0.0348 units. Hash join has quite a high start-up cost (and it requires a memory workspace grant). We could try other things, but it certainly seems that the optimizer had it right to begin with in this case.

The manual exploration above shows that the optimizer does generally find a good plan quickly (and sometimes it may even find the best possible plan). The terms ‘good’ and ‘best’ here are measured in terms of the optimizer’s own cost model. Whether one particular plan shape actually executes faster on a given system is another question. I might find, for example, that the first merge join plan runs fastest for me, whereas you might find the seek and sort runs fastest for you. We might both find that which is faster depends on whether the indexes and data needed are in memory or need to be retrieved from persistent storage. All these things aside, the important thing is that we are both likely to find that the optimizer’s plans are pretty good most of the time.

Models and Limitations

There are three principal models used by the optimizer to provide a basis for its reasoning: cardinality estimation, logical relational equivalences, and physical operator costing. Good cardinality estimation (row count expectations at each node of the logical tree) is vital; if these numbers are wrong, all later decisions are suspect. Fortunately, it is relatively easy to check cardinality estimation by comparing actual and estimated row counts in query plans. There are some subtleties to be aware of – for example when interpreting the inner side of a nested loops join, at least in SSMS. If you use the free SQL Sentry Plan Explorer tool, many of these common misinterpretations are handled for you.

The model used in cardinality estimation is complex, and contains all sorts of hairy-looking formulas and calculations. Nevertheless, it is still a model, and as such will deviate from reality at least to some extent. I’ll have more to say later on about what we can do to help ensure good cardinality estimates, but for now we will just note that the model has its roots in relational theory and statistical analysis.

Relational equivalences (such as A inner join B = B inner join A) are the basis for exploration rules in the cost-based optimizer. Not all possible relational transformations are included in the product (remember the goal of the optimizer is to find a good plan quickly, not to perform an exhaustive search of all possible plans). As a consequence, the SQL syntax you use will often affect the plan produced by the optimizer, even where different SQL syntaxes express the same logical requirement. Also, the skilled query tuner will often be able to do better than the optimizer, given enough time and perhaps a better insight to the data. The downside of such manual tuning is that it will usually require manual intervention again in the future as data volumes and distributions change.

Physical operator costing is very much the simplest of the three models, using formulas that have been shown to produce good physical plan selections for a wide range of queries on a wide range of hardware. The numbers used probably do not closely model your hardware or mine, but luckily that turns out not to be too important in most cases. No doubt the model will have to be updated over time as new hardware trends continue to emerge, and there is some evidence in SQL Server 2012 show plan output that things are heading in that direction.

Assumptions

All models make simplifying assumptions, and the cardinality estimation and costing models are no different. Some things are just too hard to model, and other things just haven’t been incorporated into the model yet. Still other things could be modelled, but turn out not to add much value in practice and cost too much in terms of complexity or resource consumption. Some of the major simplifying assumptions that can affect real plan quality are:

All queries start executing with a cold cache
This isn’t as crazy as it sounds. Fetching data from disk tends to dominate the overall cost of a query, modelling the amount of data that can be expected to be in cache already is hard, and this assumption does at least affect everything equally. The optimizer does contain some logic to account for pages that might be in cache after the first access.
Statistical information is independent
Correlations do frequently exist between columns in real databases, so this assumption can be problematic. Multi-column statistics, filtered indexes, and indexed views can sometimes help with this.
Distribution is uniform
This is assumed where the system has no information to the contrary. One example: costing assumes that seeks (lookups) into an index are randomly distributed throughout the full range of the index.

Helping the Optimizer

There are three approaches to working with the optimizer:

Ignore it. It works well out of the box with default settings and automatic statistics.
Override it using syntax tricks, hints, and plan guides.
Provide it with the best information you can, and override it for just a small number of problematic queries.

All three are valid approaches in different circumstances, though the third option is probably the one to recommend as the best starting point. There is much more to helping the optimizer than just making sure statistics are up-to-date, however:

Use a relational design

This is probably the biggest single item. The various models all assume that your database has a reasonably relational design, not necessarily 3NF or higher, but the closer your structures are to relational principles, the better. Cardinality estimation works best with simpler relational operations like joins, projects, selects, unions and group by. Avoid complex expressions and non-relational query features that force cardinality estimation to guess. Also remember that the cost-based optimizer’s exploration rules are based on relational equivalences, so having a relational design and writing relational queries gives you the best chance of leveraging the hard work that has gone into those rules. Some features added in 2005 (e.g. ranking functions) operate on sequences rather than multi-sets (hence the Sequence Project physical operator); the original rules all work with multi-sets, and the seams between the two approaches often show though.

Use constraints

Use check constraints, foreign keys, unique constraints to provide the optimizer with information about your data. Simplification and exploration rules match patterns in the logical tree, and may also require certain properties to be set on the matched nodes. Constraints and keys provide some of the most powerful and fundamental logical properties – omitting these can prevent many of the optimizer’s rules from successfully transforming to an efficient physical plan. If an integer column should only contain certain values, add a check constraint for it. If a foreign key relationship exists, enforce it. If a key exists, declare it. It is not always possible to predict the benefits of providing this type of optimizer information, but my own experience is that it is much greater than most people would ever expect.

Statistics, indexes and computed columns

Provide more than just default-sampled automatically-created statistics where appropriate (for example where distribution is unusual or correlations exist). Create indexes that will provide potentially useful access paths for a wide range of queries. If you have expressions on columns in your WHERE clause, consider adding a computed column that matches the expression exactly. The computed column does not have to be persisted or indexed to be useful; the system can auto-create statistics on the computed column, avoiding cardinality guessing.

Deep Trees

Large, complex queries produce large, complex logical trees. Any errors tend to multiply (perhaps exponentially) as the size of the tree increases, the search space of possible plans expands greatly, and things just become much more difficult in general. Breaking a complex query into smaller, simpler, more relational, steps will generally get greater value out of the optimizer. A side benefit is that small intermediate results stored in a temporary table can have statistics created, which will also help in many cases. There will always be cases where a large complex query is required for ultimate performance, but very often the performance difference is relatively small and may not be worth the future maintenance costs as hand-tuned monolithic queries tend to be fragile.

Opaque operators and new features

User-defined functions (other than the in-line variety) may seem convenient, but they are almost completely opaque to the optimizer – it has to guess at the cardinality and distribution of rows produced. Newer features also tend to have much shallower support in the engine than longer-established features that have been around for multiple versions of the product. By all means use all the shiny new features, just be aware that combining them may produce plans of variable quality.

Trace Flags

To summarize the flags used in this series (all assume 3604 is also active):

7352 : Final query tree
8605 : Converted tree
8606 : Input, simplified, join-collapsed, and normalized trees
8607 : Output tree
8608 : Initial memo
8615 : Final memo
8675 : Optimization stages and times

The above were used in the presentation because they all work from 2005 to 2012. There are a large number of other optimizer-related flags (some of which only work on 2012). Some are listed below for people that like this sort of thing:

2373 : Memory before and after deriving properties and rules (verbose)
7357 : Unique hash optimization used
8609 : Task and operation type counts
8619 : Apply rule with description
8620 : Add memo arguments to 8619
8621 : Rule with resulting tree

As usual, these are undocumented, and unsupported (including by me!) and purely for educational purposes. Use with care at your own risk.

Final Thoughts

I hope you have gained some insight and intuition for the workings of the query optimizer: logical trees, simplification, cardinality estimation, logical exploration and physical implementation. The geeky internals stuff is fun, of course, but I rather hope people came away from these sessions with a better understanding of how query text is transformed to an executable plan, and how relational designs and simpler queries can help the optimizer work well for you. Taking advantage of the optimizer frees up time for more productive things – new projects, tuning the odd interesting query, whatever it is you would rather be doing than fighting the same query-tuning battles over and over again.

There are some great resources out there to learn more about SQL Server. Make full use of them to continue to improve your technical skills and just as importantly, experiment with things to build your experience level. Take a deeper look at query plans and the properties they contain; there is a wealth of information there that sometimes requires a bit of thinking and research to understand, but the insights can be invaluable.

The original slides and demo code is again attached as a zip file below. Thanks for reading, all comments and feedback are very welcome.

Finally, I would like to thank Adam Machanic (blog | twitter) for introducing me to the QUERYTRACEON syntax all that time ago, and Fabiano Amorim (blog | twitter) for his email last year that kick-started the process of developing this presentation and blog series.

Links to other parts of this series: Part 1 Part 2 Part 3

Query Optimizer Deep Dive – Part 3

Paul White — Sun, 29 Apr 2012 07:30:00 GMT

This is the third part in a series of posts based on the content of the Query Optimizer Deep Dive presentations I have given over the last month or so at the Auckland SQL Users’ Group and the SQL Saturday events in Wellington, New Zealand and Adelaide, Australia.

Links to other parts of this series: Part 1 Part 2 Part 4

Storage of Alternative Plans

We saw in part 2 how optimizer rules are used to explore logical alternatives for parts of the query tree, and how implementation rules are used to find physical operations to perform each logical steps. To keep track of all these options, the cost-based part of the SQL Server query optimizer uses a structure called the Memo. This structure is part of the Cascades general optimization framework developed by Goetz Graefe. The Memo provides an efficient way to store many plan alternatives via the use of groups.

Each group in the Memo initially contains just one entry – a node from the input logical tree. As exploration and implementation phases progress, new groups may be added, and new physical and logical alternatives may be added to existing groups (all alternatives in a group share the same logical properties, but will often have quite different physical properties). Groups are also shared between plan alternatives where possible, allowing Cascades to search more plans in the same time and space compared with other optimization frameworks.

Continuing with our example query, the input tree to cost-based optimization is first copied into the Memo structure. We can see this structure using trace flag 8608:

     USE AdventureWorks2008R2;

    GO

    SET NOCOUNT ON;

    DBCC FREEPROCCACHE;

    DBCC TRACEON(3604);

    GO

    -- Initial memo contents

    SELECT

        p.Name,

        Total = SUM(inv.Quantity)

    FROM Production.Product AS p

    JOIN Production.ProductInventory AS inv ON

        inv.ProductID = p.ProductID

    WHERE

        p.Name LIKE N'[A-G]%'

    GROUP BY

        p.Name

    OPTION (QUERYTRACEON 8608);

As a reminder, this is the logical input tree to cost-based optimization shown in part 2:

This is copied to the Memo, one group per logical node, illustrated below:

The group numbers and linked structure shown are obtained directly from the trace flag output:

Each group has an entry number (all zero above since there is only one logical entry per group at this stage), with a logical operation (e.g. LogOp_Join), and the group numbers of any child groups (e.g. the logical join in group 13 references its two inputs, groups 8 and 9, and a logical comparison defined by the sub-tree starting at group 12).

Optimization Phases

One the initial Memo has been populated from the input tree, the optimizer runs up to four phases of search. There is a documented DMV, sys.dm_exec_query_optimizer_info, that contains a number of counters specific to query optimization. Four of these counters are ‘trivial plan’, search 0’, ‘search 1’, and ‘search 2’. The value for each counter keeps track of the number of times a search phase was entered. By recording the values before and after a specific optimization, we can see which phases were entered. The current counter values on one of my test SQL Server instances is shown below, as an example:

We look at each of the four phases in a bit more detail next:

Search 0 – Transaction Processing

This phase is primarily concerned with finding good plans for OLTP-type queries, which usually join a number of tables using a navigational strategy (looking up a relatively small number of rows using an index). This phase primarily considers nested-loops joins, though hash match may be used when a loops join implementation is not possible. Many of the more advanced (and costly to explore) optimizer rules are not enabled during this search phase – for example search 0 never considers indexed view matching or parallel plans.

Search 1 – Quick Plan (also known as Complex Query I)

This search phase can use most or all of the available rules, can perform limited join reordering, and may be run a second time (to consider parallel plans only) if the first run produces a plan with a high enough cost. Most queries find a final plan during one of the Search 1 runs.

Search 2 – Full Optimization

This phase uses the most comprehensive search configuration, and may result in significant compilation times in some cases. The search is either for a serial or parallel plan, depending on which type was cheaper after search 1.

The scripts accompanying this series show another way to see which phases were run, using trace flag 8675. The output provides some extra insight into how things work (for example it shows the number of optimization moves (tasks) made in each stage). The only documented and supported way to see the search phases is via the DMV, however.

Entry and Termination Conditions

Each phase has entry conditions, a set of enabled rules, and termination conditions. Entry conditions mean that a phase may be skipped altogether; for example, search 0 requires at least three joined tables in the input tree. Termination conditions help to ensure the optimizer does not spend more time optimizing than it saves – if the current lowest plan cost drops below a configured value, the search will terminate early with a ‘Good Enough Plan Found’ result.

The optimizer also sets a budget at the start of a phase for the number of optimization ‘moves’ it considers sufficient to find a pretty good plan (remember the optimizer’s goal is to find a good enough plan quickly). If the process of exploring and implementing alternatives exceeds this ‘budget’ during a phase, the phase terminates with a ‘Time Out’ message. Early termination (for whatever reason) is part of the optimizer’s design, completely normal, and not generally a cause for concern.

From time to time, we might wish that the optimizer had different goals – perhaps that we could ask it to continue searching for longer – but this is not how it works. It is all too easy to over-spend on optimization (finding transformations is not hard – finding ones that are robustly useful in a wide range of circumstances is), and full cost-based exploration is a memory and processor-intensive operation. The optimizer contains many heuristics, checks and limits to avoid exploring unpromising alternatives, to prune the search space as it goes, and ultimately produce a pretty good plan pretty quickly, most of the time, on most hardware, in most databases.

Costing

First a quick summary: The optimizer runs up to four phases, each of which performs exploration using rules (finding new logical alternatives to some part of the tree), then a round of implementation rules (finding physical implementations for a logical part of the tree). New logical or physical alternatives are added to the Memo structure – either as an alternative within an existing group, or as a completely new group. Note that the Memo allows the optimizer to consider very many alternatives at once in a compact and quick-to-search structure; the optimizer does not just work on one overall plan, performing incremental improvements (this is a common misconception).

Having found all these alternatives, the optimizer needs a way to choose between them. Costing runs after each round of implementation rules, producing a cost value for each physical alternative in each group in the memo (only physical operations can be costed, naturally). Costing considers factors like cardinality, average row size, expected sequential and random I/O operations, processor time, buffer pool memory requirements, and the effect of parallel execution.

Like many areas of optimization, the costing calculations are based on a complex mathematical model. This model generally provides a good basis on which to compare alternatives internally, regardless of the workload or particular hardware configuration. The costing numbers do not mean very much by themselves, so it is generally unwise to compare them between statements or across different queries. The numbers are perhaps best thought of as a unit-less quantity, useful only when comparing alternative plans for the same statement.

The model is just that of course: a model, albeit one that happens to produce very good results for most people most of the time. The slide deck that accompanies this series contains details of some of the simplifying assumptions made in the model.

Final Memo Contents

At the end of each search phase, the Memo may have expanded to include new logical and physical alternatives for each group, perhaps some completely new groups. We can see the contents after each phase using trace flag 8615:

    -- Final memo

    SELECT

        p.Name,

        Total = SUM(inv.Quantity)

    FROM Production.Product AS p

    JOIN Production.ProductInventory AS inv ON

        inv.ProductID = p.ProductID

    WHERE

        p.Name LIKE N'[A-G]%'

    GROUP BY

        p.Name

    OPTION (RECOMPILE, QUERYTRACEON 8615);

The final Memo (after each phase, remember) can be quite large, despite the techniques employed to constrain the search space. Our simple test query only requires a single run through search 1, and terminates early after 509 moves (tasks) with a ‘Good Enough Plan Found’ message. Despite that, the Memo contains 38 groups (up from 18) with many groups containing several alternatives. The extract below highlights just the groups that relate directly to the join implementation:

Looking at the green shaded areas, group 13 item 0 was the original (joining groups 8 and 9 and applying the condition described by the sub-tree starting with group 12). It has gained an logical alternative (via the Join Commute rule, reversing the join input groups), and two surviving physical implementations: a one-to-many merge join as item 7, with group 8 option 2 as the first input, and group 9 option 2 as the second; and a physical inner Apply driven by group 8 option 6, on group 30 option 2. Group 20 is completely new – another one-to-many merge join option, but this time with inputs from groups 19.4 and 8.2 with 12 familiar as the join condition. Again, the scripts accompanying this series can be used to explore the details further, if you wish.

The final selected plan consists of physical implementations chosen by starting with the lowest-cost physical option in the root group (18, shaded pink above). The sub-tree from that point has a total estimated cost of 0.0295655 (this is the same cost shown in the final graphical execution plan). The plan is produced by following the links in the Memo, from group 18 option 4, to group 20 option 6, and so on to the leaves:

End of Part 3

The original slides and demo code are attached below as a zip file.

Links to other parts of this series: Part 1 Part 2 Part 4

Query Optimizer Deep Dive – Part 2

Paul White — Sat, 28 Apr 2012 04:56:00 GMT

This is the second part in a series of posts based on the content of the Query Optimizer Deep Dive presentations I have given over the last month or so at the Auckland SQL Users’ Group and the SQL Saturday events in Wellington, New Zealand and Adelaide, Australia.

Links to other parts of this series: Part 1 Part 3 Part 4

Cost-Based Optimization Overview

The input to cost-based optimization is a tree of logical operations produced by the previous optimization stages discussed in part one. Cost-based optimization takes this logical tree, explores logical alternatives (different logical tree shapes that produce the same results), generates physical implementations, assigns an estimated cost to each, and finally chooses the cheapest physical option overall.

The goal of cost-based optimization is not to find the best possible physical execution plan by exploring every possible alternative; rather, the goal is to find a good plan quickly. This approach gives us an optimizer that works pretty well for most workloads, most of the time. If you think about it, that’s quite an achievement – after all, my database is likely very different from yours, and we probably run on quite different hardware as well. The point about finding a good plan quickly is also important – generally, we would not want the optimizer to spend hours optimizing a query that runs for only a few seconds.

This design has a number of important consequences. First, a skilled query tuner will often be able to come up with a better plan than the optimizer does. In some cases, this will because the human can reason about the query in a way the optimizer cannot. Other times, it is simply a question of time – we might be happy spending half a day finding a great execution plan for a crucial query, whereas the optimizer places strict limits on itself to avoid spending more time on optimization than it saves on a single execution.

Perhaps a future version of SQL Server will allow us to configure the optimizer to spend extra time on a particular query – today, we have to use query hints and ‘manual optimizations’ to encourage a particular execution plan shape. The down side to circumventing the optimizer’s natural behaviour in this way is that we then have to take responsibility for ensuring that the execution plan remains good in the future, as data volumes and distributions change. In most systems, it is best to limit the number of manually-tuned queries to a minimum, and thoroughly document any tricks you use to obtain a particular plan.

Input Tree to Cost-Based Optimization

Back to the task at hand. We have a sample query (reproduced below) that has been through all the previous optimization stages, did not qualify for a trivial plan, and so needs to go through the cost-based optimization process.

     SELECT

        p.Name,

        Total = SUM(inv.Quantity)

    FROM 

        Production.Product AS p,

        Production.ProductInventory AS inv

    WHERE

        inv.ProductID = p.ProductID

        AND p.Name LIKE N'[A-G]%'

    GROUP BY

        p.Name;

The tree of logical operations passed to the optimizer looks like this:

This looks very similar to the original logical tree seen in part one, though cardinality estimates have been added to each primary node, and the tree layout has been expanded a little into a form that is easier for the system to work with. In addition to simple cardinality estimates, remember that each node also has statistics objects (histograms and frequency information) derived from the familiar statistics associated with the tables in the query.

The tree above was built from information obtained using trace flag 3604 and 8606 (see part one for more details). Trace flag 8606 shows the tree at various stages, the diagram above is built from the view after project normalization:

Properties

There are also a number of other ‘properties’ associated with each node, that have been added by previous optimization stages. These properties include logical attributes, such as:

Output columns and expressions
Uniqueness (key) information
Type information and nullability
Functional dependencies
Domain ranges for each column or expression

There are also some physical properties that may be present on each node, for example:

Sort order at each node
Partitioning information
Halloween protection

The Halloween protection information is worth explaining in a bit more detail. A query generally executes as a pipeline, with rows being requested one at a time from the top of the tree – so rows are in effect pulled up the tree one at a time. This pipeline arrangement has a number of important advantages, but a problem can arise where the query modifies data: changes made by the query can affect rows being read by the same query – the classic example is a query that adds 10% to the salaries of every employee. When processed as a pipeline, we can get stuck in an infinite loop as rows that have had 10% added re-qualify for reading. This problem happened to be first discovered on 31 October 1976 and became known as the Halloween Problem.

One solution is to separate operations that read data from those that update data by reading all rows into temporary storage before performing any updates. In SQL Server, this simple solution typically manifests as an Eager Table Spool in the query plan – all rows are written eagerly to temporary storage before any updates are performed. This is a bit of a sledgehammer solution though, so the optimizer keeps track of which columns need protection from the Halloween problem (and how much protection they need) at each node by setting properties. Some logical operations (like sorting) naturally mean that all input rows have to be read before the first output row can be produced. These operations provide Halloween protection naturally, so an explicit Eager Table Spool would not be necessary. There are a number of logical operations that can provide some degree of Halloween protection, and properties are used to ensure that just enough protection is provided, at minimum cost.

Rules

The optimizer contains rules to transform trees. There are four classes of rule:

Simplification
Exploration
Implementation
Physical property enforcement

Simplification rules transform some part of the logical tree to a simpler logical form, and are responsible for the simplification transforms we saw in part one. Exploration rules run only during cost-based optimization, generating new logical equivalents for some part of the existing logical tree. Implementation rules produce a physical operation (like a hash or merge join) for a logical operation (a logical join). Property enforcement rules introduce new elements to the logical tree to enforce some desired physical property at that point, for example to enforce a particular sorted order of rows (as might be required by a merge join or stream aggregate).

There are 395 rules in SQL Serer 2012, most of which perform quite simple operations; it is the fact that many rules can be run in various orders that accounts for the apparent complexity of optimizer behaviour. The way that simple rules can combine to produce complex behaviours reminds me of Conway’s Game of Life – a cellular automation program with only four rules that nevertheless can produce extraordinarily complex and beautiful patterns as the rules are applied over and over.

Exploration Rule Examples

One example of a simple exploration rule is SELonJN, a rule that merges a suitable relational SELECT (row filter) into a logical join operation:

Another common exploration rule that generates a new logical alternative is JoinCommute:

As the name suggests, JoinCommute explores a different logical join order, exploiting the fact that A JOIN B is equivalent to B JOIN A for inner joins. Though logically equivalent, the different join orders may have different performance characteristics once the logical alternatives are translated to a physical implementation by a later implementation rule. A third exploration rule that is relevant to our test query is GbAggBeforeJoin, a rule that explores the possibility of pushing an aggregation operation under a join:

Implementation Rule Examples

As mentioned previously, implementation rules transform part of a logical tree into a physical alternative:

The diagram shows three join implementation rules, JNtoNL (nested loops), JNtoHS (hash join), JNtoSM (sort-merge join); two implementations for Group-By Aggregate, GbAggToStrm (Stream Aggregate) and GbAggToHS (Hash Aggregate); SelectToFilter, GetToScan, and GetIdxToRng.

Which Rules Were Used?

If we want to see which rules were used when optimizing a query, one option is to use an undocumented view which shows the number of times a rule has been asked to estimate how valuable it might be in the current context (its ‘promise’ value), the number of times the rule was used to generate an alternative section of the tree (‘built’), and the number of times the output of the rule was successfully incorporated into the search space (‘succeeded’). A sample of the contents of the sys.dm_exec_query_transformation_stats DMV is shown below:

By taking a snapshot view of this information before and after optimizing a particular query, we can see which rules were run. The DMV is instance-wide however, so you would need to run these tests on a system to which you have exclusive access. The scripts that accompany this series of posts contain a complete test rig to show the rules used by each query.

End of Part 2

Part three in this series covers the Memo structure and optimization phases in detail. The original presentation slides and demo code are contained in the zip file shown below.

Links to other parts of this series: Part 1 Part 3 Part 4

Query Optimizer Deep Dive - Part 1

Paul White — Fri, 27 Apr 2012 14:38:00 GMT

This is the first in a series of posts based on the content of the Query Optimizer Deep Dive presentations I have given over the last month or so at the Auckland SQL Users’ Group and the SQL Saturday events in Wellington, New Zealand and Adelaide, Australia.

Links to other parts of this series: Part 2 Part 3 Part 4

Introduction

The motivation behind writing these sessions is that I have found that relatively few people have a good intuition for the way the optimizer works, partly because the official documentation is rather sparse, and partly because what information is available is dispersed across many books and blog posts. The content presented here is very much geared to my preferred way of learning – it shows the concepts in what seems to me to be a reasonably logical sequence, and provides tools to enable the interested reader to explore further, if desired.

When we write a query, we are not writing a computer program that can be directly executed. SQL is a declarative language used to logically describe the results we want to see. SQL Server goes through a process of compilation and optimization to create a physically executable implementation of the stated logical requirement. To put it another way, a SQL query is the specification for an executable program that SQL Server writes for us. The SQL Server component responsible for finding an efficient physical execution plan for a given logical query requirement is the Query Optimizer.

The SQL Server Core Engine

The diagram below shows conceptually where the Query Optimizer sits in the core SQL Server engine:

Language Processing is concerned with things like parsing the text of the query to make sure it is syntactically valid, binding table references to real database objects, deriving types for expressions, semantic analysis (for example checking that the query is not trying to execute a table), and binding GROUP BY references to the appropriate logical scope. The Query Optimizer aims to find a good physical execution plan that matches the logical semantic of the query, and the Query Executor is responsible for running that plan to completion. Below that, the Storage Engine provides access to physical storage, together with locking and transaction services. Finally, SQL-OS is the layer that provides threading, memory management, and scheduling services.

Using the same colours for the components shown above, a very high-level overview of query processing looks like this:

This series of blog posts is mostly concerned with the “Optimize” step above. It takes as its input a tree of logical operations produced by the previous stages.

Optimization Pipeline

The diagram below shows the principal stages within query optimization, starting with the bound tree produced by the parser and algebrizer. The coloured steps are the ones we will explore in depth – the right hand side of the diagram lists a bit more detail that I talk through when presenting this material live:

Input Tree

We start by looking at the bound logical tree (input tree). To make the discussion a little less abstract, we will use a test query issued against the AdventureWorks sample database. This simple query shows products and the quantity in stock, limited to products with names that start with a letter between A and G:

     -- Test query

    SELECT

        p.Name,

        Total = SUM(inv.Quantity)

    FROM 

        Production.Product AS p,

        Production.ProductInventory AS inv

    WHERE

        inv.ProductID = p.ProductID

        AND p.Name LIKE N'[A-G]%'

    GROUP BY

        p.Name;

The input tree generated by this query is shown below, slightly simplified:

The operations in this tree are all purely logical, and have their roots in Relational Theory. The GET operation logically reads an entire table, though you should not yet be thinking in terms of physical operations such as a scan or a seek. The JOIN is a cartesian product, logically joining every row in one table with every row in the other. The SELECT is not a SQL statement, it is a relational operation: filtering rows based on some condition (known as a predicate). Here, we are applying two SELECT operations to filter on matching product IDs and rows where the product name starts with a letter between A and G. The next logical operation is a Group-By Aggregate, an extension to the basic relational algebra that logically groups rows by some common attribute, and optionally computes an aggregate expression for each group. Finally, we have a relational Project operation, which filters columns – here we only need the Name and Total columns, and those are the only two returned in the logical result set.

To see this tree directly, we can use undocumented trace flag 8605. This flag also requires the common trace flag 3604 to produce output to the SSMS messages window. We can use another undocumented syntax, the QUERYTRACEON hint, to set the trace flag just for this query:

    -- Input tree (ISO-92)

    SELECT

        p.Name,

        Total = SUM(inv.Quantity)

    FROM Production.Product AS p

    JOIN Production.ProductInventory AS inv ON

        inv.ProductID = p.ProductID

    WHERE

        p.Name LIKE N'[A-G]%'

    GROUP BY

        p.Name

    OPTION (RECOMPILE, QUERYTRACEON 8605);

Now, in the SSMS messages tab, we see a textual representation of the tree of logical operators I drew with coloured boxes before:

There are a few minor differences between this and the previous diagram. In particular, the expression computed by the aggregate is added by a separate projection (omitted for clarity before), and the SQL-92 join syntax means the join predicate is more tightly bound to the logical join. Rewriting the query using SQL-89 syntax highlights the second difference, producing a tree closer to the cartesian product followed by a relational SELECT:

    -- Input tree (ISO-89)

    SELECT

        p.Name,

        Total = SUM(inv.Quantity)

    FROM 

        Production.Product AS p,

        Production.ProductInventory AS inv

    WHERE

        inv.ProductID = p.ProductID

        AND p.Name LIKE N'[A-G]%'

    GROUP BY

        p.Name

    OPTION (RECOMPILE, QUERYTRACEON 8605);

Simplification

The first step of the optimization pipeline we will look at is simplification, where the optimizer looks to rewrite parts of the logical tree to remove redundancies and move logical operations around a bit to help later stages. Major activities that occur around the time simplification occurs (I have taken a little artistic licence here to group a few separate stages together) include:

Constant folding
Domain simplification
Predicate push-down
Join simplification
Contradiction detection

Constant folding is the process of evaluating an expression during optimization, rather than repeatedly at execution time. In the following example, the complex expression in the WHERE clause can safely be evaluated early, resulting in “WHERE p.Name LIKE ‘D%’:

    SELECT p.Name

    FROM Production.Product AS p

    WHERE p.Name LIKE SUBSTRING(LEFT(CHAR(ASCII(CHAR(68))), 1) + '%', 1, 2);

Domain simplification enables the optimizer to reason about the range of valid values a column or expression can take. In the next query, the only value for Product ID that logically matches all the predicates in the extended WHERE clause is the single value ‘400’. The query plan shows that simplification has reduced the three predicates to a single equality predicate, “WHERE p.ProductID = 400”:

    SELECT TOP (10) * 

    FROM Production.Product AS p

    WHERE p.ProductID BETWEEN 300 AND 400

    AND p.ProductID BETWEEN 200 AND 500

    AND p.ProductID BETWEEN 400 AND 600;

Predicate push-down involves pushing relational SELECTs (logically filtering rows based on a predicate) down the logical tree toward the leaves. The heuristic here is that this is always a good thing to do (at least as far as expressions that reference a column are concerned) because it eliminates rows early, reducing the number for later logical operations. Moving SELECTs closer to the logical GETs (reading tables) also helps index and computed-column matching.

Join simplification allows the optimizer to remove unnecessary joins, convert logical outer joins to simpler inner joins where the NULLs introduces by the outer join are later rejected by another feature in the query, and remove provably empty subexpressions. This is an incredibly powerful optimizer facility, with its roots again in relational theory. Rob Farley has written (SQL Server MVP Deep Dives) and presented (http://bit.ly/SimpleRob) about ways to use this feature effectively. In particular, he talks about how to write views to benefit from compile-time simplification, and avoid the views-on-views-on-views problem. The following queries illustrate some of the join simplifications:

    -- Remove unnecessary joins

    SELECT

        th.ProductID,

        SUM(th.ActualCost)

    FROM Production.TransactionHistory AS th

    JOIN Production.Product AS p ON

        p.ProductID = th.ProductID

    GROUP BY

        th.ProductID;

    GO

    -- Outer join to join (null rejection)

    SELECT * 

    FROM Production.Product AS p

    LEFT JOIN Production.TransactionHistory AS th ON

        th.ProductID = p.ProductID

    WHERE th.ProductID < 10;

    GO

    -- Complex example combining multiple simplifications

    WITH Complex AS

    (

        SELECT

            pc.ProductCategoryID, pc.Name AS CatName,

            ps.ProductSubcategoryID, ps.Name AS SubCatName,

            p.ProductID, p.Name AS ProductName,

            p.Color, p.ListPrice, p.ReorderPoint,

            pm.Name AS ModelName, pm.ModifiedDate

        FROM Production.ProductCategory AS pc

        FULL JOIN Production.ProductSubcategory AS ps ON

            ps.ProductCategoryID = pc.ProductCategoryID

        FULL JOIN Production.Product AS p ON

            p.ProductSubcategoryID = ps.ProductSubcategoryID

        FULL JOIN Production.ProductModel AS pm ON

            pm.ProductModelID = p.ProductModelID

    )

    SELECT c.ProductID, c.ProductName

    FROM Complex AS c

    WHERE c.ProductName LIKE N'G%';

That last example, with three full outer joins in a CTE (in-line view), simplifies down to a simple index seek on one table.

Cardinality Estimation

The optimizer only has direct information about table cardinality (total number of rows) for base tables. Statistics can provide additional histograms and frequency statistics, but again these are only maintained for base tables. To help the optimizer choose between competing strategies later on, it is essential to know how many rows are expected at each node in the logical tree, not just at the GET leaf nodes. In addition, cardinality estimates above the leaves can be used to choose an initial join order (assuming the query contains several joins).

Cardinality estimation computes expected cardinality and distribution statistics for each node, working up from the leaves one node at a time. The logic used to create these derived estimates and statistics uses a model that makes certain assumptions about your data. For example, where the distribution of values is unknown, it is assumed to be uniform across the whole range of potential values.

You will generally get more accurate cardinality estimates if your queries fit the model used, and, as with many things in the wider optimizer, simple and relational is best. Complex expressions, unusual or novel techniques, and using non-relational features often means cardinality estimation has to resort to guessing.

Most of the choices made by the optimizer are driven by cardinality estimation, so if these are wrong, any good execution plans you might see are highly likely to be down to pure luck.

Trivial Plan

The next stage of the optimizer pipeline is Trivial Plan, which is a fast path to avoid the time and effort involved in full cost-based optimization, and only applies to logical query trees that have a clear and obvious ‘best’ execution plan. The details of which types of query can benefit from Trivial Plan change frequently, but things like joins, subqueries, and inequality predicates generally prevent this optimization. The queries below show some examples where Trivial Plan can, and cannot be applied:

    -- Trivial plan

    SELECT p.ProductID

    FROM Production.Product AS p

    WHERE p.Name = N'Blade';

    GO

    -- Still trivial

    SELECT

        p.Name,

        RowNumber =

            ROW_NUMBER() OVER (

                ORDER BY p.Name)

    FROM Production.Product AS p

    WHERE p.Name LIKE N'[A-G]%';

    GO

    -- 'Subquery' prevents a trivial plan

    SELECT (SELECT p.ProductID)

    FROM Production.Product AS p

    WHERE p.Name = N'Blade';

    GO

    -- Inequality

    SELECT p.ProductID

    FROM Production.Product AS p

    WHERE p.Name <> N'Blade';

One interesting case where a Trivial Plan is not applied is where the estimated cost of the Trivial Plan query exceeds the configured ‘cost threshold for parallelism’. The reasoning here is that any trivial plan that would qualify for a parallel plan suddenly presents a choice, and a choice means the query is no longer ‘trivial’, and we have to go through full cost-based optimization. Taking this to the extreme, a SQL Server instance with the parallelism cost threshold set to zero will never produce a trivial plan (since all queries have a cost greater than zero). At the risk of stating the slightly obvious, note that a plan produced at this stage will always be serial. For experimentation only, the trivial plan stage can also be disabled using trace flag 8757.

You can check whether a query used a trivial plan or not by inspecting the Properties window in SSMS, and clicking on the root node of the graphical query plan. The ‘optimization level’ property will show ‘Trivial’ or ‘Full’ – the latter shows that a trip through full cost-based optimization was required. If a query results in a trivial plan, a physical execution plan is produced and the optimization process ends here.

End of Part 1

The original slides and demo code are contained in the zip file attached below. Links to other parts of this series: Part 2 Part 3 Part 4

How to Find the Statistics Used to Compile an Execution Plan

Paul White — Tue, 20 Sep 2011 15:22:15 GMT

In this post, I show you how to determine exactly which statistics objects were used by the query optimizer to produce an execution plan.

Trace Flags

We will need three undocumented trace flags. The first one (3604) is well-known – it redirects trace output to the client so it appears in the SSMS messages tab.

The second trace flag is 9292. With this enabled, we get a report of statistics objects which are considered ‘interesting’ by the query optimizer when compiling, or recompiling the query in question. For potentially useful statistics, just the header is loaded.

The third trace flag is 9204. With this enabled, we see the ‘interesting’ statistics which end up being fully loaded and used to produce cardinality and distribution estimates for some plan alternative or other. Again, this only happens when a plan is compiled or recompiled – not when a plan is retrieved from cache.

You can enable and disable these flags with the usual DBCC TRACEON and TRACEOFF commands, but it is also possible to enable them just for a particular statement using the undocumented QUERYTRACEON query hint (demonstrated below).

Sample Query

     DBCC FREEPROCCACHE

    SELECT 

        p.Name,

        total_quantity = SUM(th.Quantity)

    FROM AdventureWorks.Production.Product AS p

    JOIN AdventureWorks.Production.TransactionHistory AS th ON

        th.ProductID = p.ProductID

    WHERE

        th.ActualCost >= $5.00

        AND p.Color = N'Red'

    GROUP BY

        p.Name

    ORDER BY

        p.Name

    OPTION

    (

        QUERYTRACEON 3604,

        QUERYTRACEON 9292,

        QUERYTRACEON 9204

    )

The DBCC FREEPROCCACHE is just there to empty the plan cache so we get a compilation. You can also evict the current plan from cache if you know its handle (SQL Server 2008) or use a RECOMPILE query hint. Using RECOMPILE is often convenient, but you may get a different plan compared to that obtained without the hint. Note that compiling the query is enough – we do not need to execute the query; simply requesting an ‘estimated plan’ will do. It doesn’t hurt to run it either though, just to be clear.

Sample Output

    Stats header loaded: 

        DbName: AdventureWorks, 

        ObjName: AdventureWorks.Production.Product, 

        IndexId: 1, 

        ColumnName: ProductID, 

        EmptyTable: FALSE

    Stats loaded: 

        DbName: AdventureWorks, 

        ObjName: AdventureWorks.Production.Product, 

        IndexId: 1, 

        ColumnName: ProductID, 

        EmptyTable: FALSE

    Stats header loaded: 

        DbName: AdventureWorks, 

        ObjName: AdventureWorks.Production.Product, 

        IndexId: 3, 

        ColumnName: Name, 

        EmptyTable: FALSE

    Stats loaded: 

        DbName: AdventureWorks, 

        ObjName: AdventureWorks.Production.Product, 

        IndexId: 3, 

        ColumnName: Name, 

        EmptyTable: FALSE

    Stats header loaded: 

        DbName: AdventureWorks, 

        ObjName: AdventureWorks.Production.Product, 

        IndexId: 11, 

        ColumnName: Color, 

        EmptyTable: FALSE

    Stats loaded: 

        DbName: AdventureWorks, 

        ObjName: AdventureWorks.Production.Product, 

        IndexId: 11, 

        ColumnName: Color, 

        EmptyTable: FALSE

    Stats header loaded: 

        DbName: AdventureWorks, 

        ObjName: AdventureWorks.Production.TransactionHistory, 

        IndexId: 2, 

        ColumnName: ProductID, 

        EmptyTable: FALSE

    Stats loaded: 

        DbName: AdventureWorks, 

        ObjName: AdventureWorks.Production.TransactionHistory, 

        IndexId: 2, 

        ColumnName: ProductID, 

        EmptyTable: FALSE

    Stats header loaded: 

        DbName: AdventureWorks, 

        ObjName: AdventureWorks.Production.TransactionHistory, 

        IndexId: 5, 

        ColumnName: ActualCost, 

        EmptyTable: FALSE

    Stats loaded: 

        DbName: AdventureWorks, 

        ObjName: AdventureWorks.Production.TransactionHistory, 

        IndexId: 5, 

        ColumnName: ActualCost, 

        EmptyTable: FALSE

There’s no sign of an official way to get this very useful information in Denali, despite it being requested many times over the years. Trace flag 9204 works at least as far back as SQL Server 2005. Both 92xx flags work in 2008, R2, and Denali CTP 3.

Enjoy!

SQLkiwi@gmail.com
@SQL_Kiwi

Search results matching tag 'Undocumented'

Execution Plan Analysis: The Mystery Work Table

The Execution Plan

High-Cost Operators

Execution Warnings

I/O Information

Execution Outline

Reproducing the problem

Table Creation

Test Query

Warm cache results

Cold cache results

Explanation

Nested Loops Prefetching

Manufactured LOBs

The Outer Join

Memory Allocation

Workaround

Warm cache results

Cold cache results

Final Thoughts

Incorrect Results with Indexed Views

Steps to Reproduce

Analysis using DBCC CHECKTABLE

Cause

Summary

Deletes that Split Pages and Forwarded Ghosts

Isolation Levels

Triggers

Avoiding Row Versioning with Triggers

Test One – Clustered Table

Test Two – Clustered Table

Explanation

Heaps of Forwarded Ghosts

Summary

Temporary Table Caching Explained

Cached Object Names

Caching is per object not per procedure

Apparently, DROP TABLE is not DDL

Concurrent executions

Statistics on cached temporary objects

Drop and Create in Detail

Cached Object Scope

More about Table Variables

Temporary Tables in Stored Procedures

A World Without Temporary Objects

A Short Digression about Parameter Sniffing

Back to the Main Example

Using a Temporary Table

OPTION (RECOMPILE) to the Rescue?

Manual Statistics Update to the Rescue?

RECOMPILE and UPDATE STATISTICS to the Rescue?

Enter the Table Variable…

Question Time

CREATE and DROP, Don’t

Recompilation Thresholds

Statistics Updates

Summary and Final Thoughts

Further Reading

Query Optimizer Deep Dive - Part 4

Beating the Optimizer

Models and Limitations

Assumptions

Helping the Optimizer

Use a relational design

Use constraints

Statistics, indexes and computed columns

Deep Trees

Opaque operators and new features

Trace Flags

Final Thoughts

Query Optimizer Deep Dive – Part 3

Storage of Alternative Plans

Optimization Phases

Search 0 – Transaction Processing

Search 1 – Quick Plan (also known as Complex Query I)

Search 2 – Full Optimization

Entry and Termination Conditions

Costing

Final Memo Contents