INSERT and EXEC: relational brothers in arms, helping you get your data and then put it somewhere. But like all brothers, their relationship has its ups and downs and sometimes you need to look just below the surface to see the real issues. In this post I will cover hidden penalties that a decision--seemingly purely aesthetic--can bring to the fore.

To illustrate the first of these examples I will be using the following table:

USE tempdb
GO

CREATE TABLE dbo.MyTable
(
 [SalesOrderID] [int] NOT NULL,
 [SalesOrderDetailID] [int] NOT NULL,
 [CarrierTrackingNumber] [nvarchar](25) NULL,
 [OrderQty] [smallint] NOT NULL,
 [ProductID] [int] NOT NULL,
 [SpecialOfferID] [int] NOT NULL,
 [UnitPrice] [money] NOT NULL,
 [UnitPriceDiscount] [money] NOT NULL,
 [LineTotal] [money] NOT NULL,
 [rowguid] [uniqueidentifier] NOT NULL,
 [ModifiedDate] [datetime] NOT NULL
)
GO

Consider the following queries, disregarding the fact that this isn't a good dynamic SQL example (I'm trying to keep it simple), and take a moment to think about the differences between them from a behavioral point of view:

EXEC
('
 INSERT dbo.MyTable
 SELECT *
 FROM AdventureWorks.Sales.SalesOrderDetail
')
GO
INSERT dbo.MyTable
EXEC 
('
 SELECT *
 FROM AdventureWorks.Sales.SalesOrderDetail
')
GO

It's quite common to insert some data into a table from dynamic SQL, and for as long as I can remember, I've believed the choice between these two forms of the query to be primarily an issue of style. My preference has been for the latter style, as I feel that it's a bit more readable. It also has the benefit of better supporting ownership chains, but that's something that, in most cases, we don't have to worry about any longer in SQL Server 2005 or 2008. But let's move beyond style and potential security issues and get to the substance. What actually happens when we run these two queries?

In the first case--insert done inside of the EXEC--the first step is that the outer statement--the EXEC itself--is parsed and validated. Now we jump down one level of context, into the string that was passed to EXEC, and that string is parsed and validated. The referenced objects are resolved, and the plan cache is checked. If there is no plan, the query is compiled. And then it's executed. Data is streamed from SalesOrderDetail into MyTable and when the query inside of the EXEC is done control returns to the calling context--EXEC--and assuming there were no errors, the EXEC is now completed.

In the second case, something quite a bit different occurs. The insert is parsed and validated, and an INSERT EXEC plan is generated. This plan does not involve SalesOrderDetail, as the query optimizer doesn't know at this point in the process where the data will be inserted from, since that step is dynamic. So the plan references something called the "Parameter Table" (plan truncated for simplicity):

|--Table Insert(OBJECT:([tempdb].[dbo].[MyTable]))
 |--Top(ROWCOUNT est 0)
 |--Parameter Table Scan

Once this plan has been generated, we again jump down one level of context, and the inner string is parsed and validated, the referenced object resolved, the cache checked, and the compiled plan executed. But what is this Parameter Table thing?

Here's where things start really diverging. Data is not, at this point, streamed from SalesOrderDetail directly into MyTable. Rather, it is streamed from SalesOrderDetail into the Parameter Table. And the Parameter Table, as it turns out, is in actuality a hidden temporary table. And not until all of the data has streamed into that hidden temporary table is control resumed by the EXEC context, and only then does the data start moving into its final home.

The natural question you might be asking yourself at this point is, just how much overhead does this Parameter Table introduce into the equation? The answer might just send you racing to check your stored procedures: the additional cost for the Parameter Table is well over 100% as compared with doing the insert inside of the EXEC. The fact that all of the data must be spooled to the Parameter Table before the insert can even begin tells us that this must be true, and it can be verified using a simple check against the sys.dm_exec_requests DMV, as in the following example:

EXEC
('
 INSERT dbo.MyTable
 SELECT *
 FROM AdventureWorks.Sales.SalesOrderDetail
')
SELECT
 r.writes AS [INSERT inside EXEC writes]
FROM sys.dm_exec_requests r
WHERE 
 r.session_id = @@SPID
GO
INSERT dbo.MyTable
EXEC
('
 SELECT *
 FROM AdventureWorks.Sales.SalesOrderDetail
')
SELECT
 r.writes AS [INSERT EXEC writes]
FROM sys.dm_exec_requests r
WHERE 
 r.session_id = @@SPID
GO

So that's that. We should avoid INSERT EXEC and try to do our inserts in the same context in which the SELECT is running--right?

Well, yes and no. There is another element at play here which I haven't yet mentioned. What if we were only inserting a few rows, and the table we were inserting into looked something like the following:

CREATE TABLE #MyTable
(
 [SalesOrderID] [int] NOT NULL,
 [SalesOrderDetailID] [int] NOT NULL,
 [CarrierTrackingNumber] [nvarchar](25) NULL,
 [OrderQty] [smallint] NOT NULL,
 [ProductID] [int] NOT NULL,
 [SpecialOfferID] [int] NOT NULL,
 [UnitPrice] [money] NOT NULL,
 [UnitPriceDiscount] [money] NOT NULL,
 [LineTotal] [money] NOT NULL,
 [rowguid] [uniqueidentifier] NOT NULL,
 [ModifiedDate] [datetime] NOT NULL
)
GO

The only difference between this table and the previous one is that this is a temporary table and the other is not. But temporary tables have their own interesting little twists, especially when it comes down to one of the key enemies in a highly-transactional system: recompilation. As it turns out, doing the insert inside the EXEC will cause the internal statement to recompile every time a new temp table is encountered. This means that if you have a stored procedure that creates a temp table, puts together a bit of dynamic SQL, and does an insert inside of that dynamic SQL, you'll now have yourself a recompilation problem.

To see this illustrated, try the following script. Here only a single row is inserted as a result of the dynamic query, but it's complex enough that the compile time more than overshadows the overhead of the Parameter Table:

USE tempdb
GO
DBCC FREEPROCCACHE
GO
CREATE TABLE #AvgTimes
(
 CPU_time DECIMAL(19,4) NOT NULL,
 insert_type VARCHAR(25) NOT NULL
)
GO
CREATE TABLE #MyTable
(
 [SalesOrderID] [int] NOT NULL,
 [SalesOrderDetailID] [int] NOT NULL,
 [CarrierTrackingNumber] [nvarchar](25) NULL,
 [OrderQty] [smallint] NOT NULL,
 [ProductID] [int] NOT NULL,
 [SpecialOfferID] [int] NOT NULL,
 [UnitPrice] [money] NOT NULL,
 [UnitPriceDiscount] [money] NOT NULL,
 [LineTotal] [money] NOT NULL,
 [rowguid] [uniqueidentifier] NOT NULL,
 [ModifiedDate] [datetime] NOT NULL
)
EXEC
('
 INSERT #MyTable
 SELECT TOP(1)
 sod.*
 FROM AdventureWorks.Sales.SalesOrderDetail sod
 WHERE 
 sod.UnitPrice > 10
 AND sod.LineTotal > 100
 AND EXISTS
 (
 SELECT *
 FROM AdventureWorks.Sales.SalesOrderHeader soh
 JOIN AdventureWorks.Person.Contact c ON 
 c.ContactID = soh.CustomerID
 WHERE
 soh.SalesOrderID = sod.SalesOrderID
 AND c.LastName LIKE ''Ab%''
 )
 AND EXISTS
 (
 SELECT *
 FROM AdventureWorks.Production.Product p
 WHERE
 p.ProductID = sod.ProductID
 AND p.Color IS NULL
 )
 AND NOT EXISTS
 (
 SELECT *
 FROM AdventureWorks.Sales.SalesOrderHeader soh
 JOIN AdventureWorks.Sales.SalesPerson sp ON
 soh.SalesPersonID = sp.SalesPersonID
 WHERE
 soh.SalesOrderID = sod.SalesOrderID
 AND sp.CommissionPct > 50
 )
')
INSERT #AvgTimes
SELECT
 r.cpu_time,
 'INSERT inside EXEC'
FROM sys.dm_exec_requests r
WHERE 
 r.session_id = @@SPID
DROP TABLE #MyTable
GO 5
CREATE TABLE #MyTable
(
 [SalesOrderID] [int] NOT NULL,
 [SalesOrderDetailID] [int] NOT NULL,
 [CarrierTrackingNumber] [nvarchar](25) NULL,
 [OrderQty] [smallint] NOT NULL,
 [ProductID] [int] NOT NULL,
 [SpecialOfferID] [int] NOT NULL,
 [UnitPrice] [money] NOT NULL,
 [UnitPriceDiscount] [money] NOT NULL,
 [LineTotal] [money] NOT NULL,
 [rowguid] [uniqueidentifier] NOT NULL,
 [ModifiedDate] [datetime] NOT NULL
)
INSERT #MyTable
EXEC
('
 SELECT TOP(1)
 sod.*
 FROM AdventureWorks.Sales.SalesOrderDetail sod
 WHERE 
 sod.UnitPrice > 10
 AND sod.LineTotal > 100
 AND EXISTS
 (
 SELECT *
 FROM AdventureWorks.Sales.SalesOrderHeader soh
 JOIN AdventureWorks.Person.Contact c ON 
 c.ContactID = soh.CustomerID
 WHERE
 soh.SalesOrderID = sod.SalesOrderID
 AND c.LastName LIKE ''Ab%''
 )
 AND EXISTS
 (
 SELECT *
 FROM AdventureWorks.Production.Product p
 WHERE
 p.ProductID = sod.ProductID
 AND p.Color IS NULL
 )
 AND NOT EXISTS
 (
 SELECT *
 FROM AdventureWorks.Sales.SalesOrderHeader soh
 JOIN AdventureWorks.Sales.SalesPerson sp ON
 soh.SalesPersonID = sp.SalesPersonID
 WHERE
 soh.SalesOrderID = sod.SalesOrderID
 AND sp.CommissionPct > 50
 )
')
INSERT #AvgTimes
SELECT
 r.cpu_time,
 'INSERT EXEC'
FROM sys.dm_exec_requests r
WHERE 
 r.session_id = @@SPID
DROP TABLE #MyTable
GO 5
SELECT 
 AVG
 (
 CASE a.insert_type 
 WHEN 'INSERT inside EXEC' THEN a.CPU_time
 ELSE NULL
 END
 ) AS [CPU time - INSERT inside EXEC],
 AVG
 (
 CASE a.insert_type 
 WHEN 'INSERT EXEC' THEN a.CPU_time
 ELSE NULL
 END
 ) AS [CPU time - INSERT EXEC]
FROM #AvgTimes a
GO
DROP TABLE #AvgTimes
GO

So what have we learned today? The choice between INSERT EXEC and INSERT inside of EXEC is not purely stylistic and has definite performance implications. Here are the rules I'll be following from now on:

• When working with permanent tables, always avoid INSERT EXEC if possible. There are some cases where it won't be possible to avoid. I only showed dynamic SQL in this post, but INSERT EXEC also applies to stored procedures. Can you safely rip apart all of the stored procedures in your system in order to avoid this issue? Maybe not quite as easily as you can rip apart the dynamic SQL within stored procedures.
• When working with temporary tables, evaluate the complexity of the operations, the amount of data to be inserted, and most importantly, test every solution! The more rows that are inserted as a result of the INSERT EXEC, the more the overhead you'll get from the Parameter Table. On the flip side, the more complex the dynamic statement, the more overhead you'll get from recompilations. Every scenario is bound to be different and you may just learn something about your processes by doing this extra bit of analysis.