SQL Server EXEC和sp_executesql的区别

SQL Server EXEC和sp_executesql的区别
1,EXEC的使用
2，sp_executesql的使用
MSSQL为我们提供了两种动态执行SQL语句的命令，分别是EXEC和sp_executesql;通常,sp_executesql则更具有优势，它提供了输入输出接口，而EXEC没有。还有一个最大的好处就是利用sp_executesql，能够重用执行计划，这就大大提供了执行性能(对于这个我在后面的例子中会详加说明)，还可以编写更安全的代码。EXEC在某些情况下会更灵活。除非您有令人信服的理由使用EXEC，否侧尽量使用sp_executesql.
1,EXEC的使用
EXEC命令有两种用法，一种是执行一个存储过程，另一种是执行一个动态的批处理。以下所讲的都是第二种用法。
下面先使用EXEC演示一个例子,
代码1
DECLARE @TableName VARCHAR(50),@Sql NVARCHAR(MAX),@OrderID INT
SET @TableName = 'Orders'
SET @OrderID = 10251
SET @sql = 'SELECT * FROM '+QUOTENAME(@TableName) +'WHERE OrderID = '+CAST(@OrderID AS VARCHAR(10))+' ORDER BY ORDERID DESC'
EXEC(@sql)
注：这里的EXEC括号中只允许包含一个字符串变量，但是可以串联多个变量，如果我们这样写EXEC：
EXEC('SELECT TOP('+ CAST(@TopCount AS VARCHAR(10)) +')* FROM '+QUOTENAME(@TableName) +' ORDER BY ORDERID DESC');
SQL编译器就会报错，编译不通过，而如果我们这样：
EXEC(@sql+@sql2+@sql3) 编译器就会通过；

所以最佳的做法是把代码构造到一个变量中，然后再把该变量作为EXEC命令的输入参数，这样就不会受限制了；

EXEC不提供接口
这里的接口是指，它不能执行一个包含一个带变量符的批处理，这里乍一听好像不明白，不要紧，我在下面有一个实例，您一看就知道什么意思.
DECLARE @TableName VARCHAR(50),@Sql NVARCHAR(MAX),@OrderID INT; SET @TableName = 'Orders'; SET @OrderID = 10251; SET @sql = 'SELECT * FROM '+QUOTENAME(@TableName) +'WHERE OrderID = @OrderID ORDER BY ORDERID DESC' EXEC(@sql); 关键就在SET @sql这一句话中，如果我们运行这个批处理，编译器就会产生一下错误
Msg 137, Level 15, State 2, Line 1
必须声明标量变量 "@OrderID"。
使用EXEC时，如果您想访问变量，必须把变量内容串联到动态构建的代码字符串中，如：SET @sql = 'SELECT * FROM '+QUOTENAME(@TableName) +'WHERE OrderID = '+CAST(@OrderID AS VARCHAR(10))+' ORDER BY ORDERID DESC'
串联变量的内容也存在性能方面的弊端。SQL Server为每一个的查询字符串创建新的执行计划，即使查询模式相同也是这样。为演示这一点，先清空缓存中的执行计划
DBCC FREEPROCCACHE (这个不是本文所涉及的内容，您可以查看MS的MSDN)
http://msdn.microsoft.com/zh-cn/library/ms174283.aspx
将代码1运行3次，分别对@OrderID 赋予下面3个值，10251，10252，10253。然后使用下面的代码查询
SELECT cacheobjtype,objtype,usecounts,sql FROM sys.syscacheobjects WHERE sql NOT LIKE '%cach%' AND sql NOT LIKE '%sys.%' 点击F5运行，就会出现下面如图所示的查询结果：

我们可以看到，每执行一次都要产生一次的编译，执行计划没有得到充分重用。
EXEC除了不支持动态批处理中的输入参数外，他也不支持输出参数。默认情况下，EXEC把查询的输出返回给调用者。例如下面代码返回Orders表中所有的记录数
DECLARE @sql NVARCHAR(MAX) SET @sql = 'SELECT COUNT(ORDERID) FROM Orders'; EXEC(@sql); 然而，如果你要把输出返回给调用批处理中的变量，事情就没有那么简单了。为此，你必须使用INSERT EXEC语法把输出插入到一个目标表中，然后从这表中获取值后赋给该变量，就像这样：
DECLARE @sql NVARCHAR(MAX),@RecordCount INT SET @sql = 'SELECT COUNT(ORDERID) FROM Orders'; CREATE TABLE #T(TID INT); INSERT INTO #T EXEC(@sql); SET @RecordCount = (SELECT TID FROM #T) SELECT @RecordCount DROP TABLE #T 2,sp_executesql的使用
sp_executesql命令在SQL Server中引入的比EXEC命令晚一些，它主要为重用执行计划提供更好的支持。
为了和EXEC作一个鲜明的对比,我们看看如果用代码1的代码，把EXEC换成sp_executesql,看看是否得到我们所期望的结果
DECLARE @TableName VARCHAR(50),@sql NVARCHAR(MAX),@OrderID INT ,@sql2 NVARCHAR(MAX); SET @TableName = 'Orders '; SET @OrderID = 10251; SET @sql = 'SELECT * FROM '+QUOTENAME(@TableName) + ' WHERE OrderID = '+CAST(@OrderID AS VARCHAR(50)) + ' ORDER BY ORDERID DESC' EXEC sp_executesql @sql 注意最后一行；
事实证明可以运行；
sp_executesql提供接口
sp_executesql命令比EXEC命令更灵活，因为它提供一个接口，该接口及支持输入参数也支持输出参数。这功能使你可以创建带参数的查询字符串，这样就可以比EXEC更好的重用执行计划,sp_executesql的构成与存储过程非常相似，不同之处在于你是动态构建代码。它的构成包括：代码快，参数声明部分，参数赋值部分。说了这么多，还是看看它的语法吧
EXEC sp_executesql
@stmt = <statement>,--类似存储过程主体
@params = <params>, --类似存储过程参数部分
<params assignment> --类似存储过程调用
@stmt参数是输入的动态批处理，它可以引入输入参数或输出参数，和存储过程的主体语句一样，只不过它是动态的，而存储过程是静态的，不过你也可以在存储过程中使用sp_executesql;
@params参数与定义输入/输出参数的存储过程头类似，实际上和存储过程头的语法完全一样；
@<params assignment> 与调用存储过程的EXEC部分类似。
为了说明sp_executesql对执行计划的管理优于EXEC,我将使用前面讨论EXEC时用到的代码。
1: DECLARE @TableName VARCHAR(50),@sql NVARCHAR(MAX),@OrderID INT; 2: SET @TableName = 'Orders '; 3: SET @OrderID = 10251; 4: SET @sql = 'SELECT * FROM '+QUOTENAME(@TableName) + ' WHERE OrderID = @OID ORDER BY ORDERID DESC' 5: EXEC sp_executesql 6: @stmt = @sql, 7: @params = N'@OID AS INT ', 8: @OID = @OrderID 在调用该代码和检查它生成的执行计划前，先清空缓存中的执行计划；
DBCC FREEPROCCACHE
将上面的动态代码执行3次，每次执行都赋予@OrderID 不同的值，然后查询sys.syscacheobjects表，并注意它的输出，优化器只创建了一个备用计划，而且该计划被重用的3次
SELECT cacheobjtype,objtype,usecounts,sql FROM sys.syscacheobjects WHERE sql NOT LIKE '%cache%' AND sql NOT LIKE '%sys.%' AND sql NOT LIKE '%sp_executesql%' 点击F5运行，就会出现如下表所示的结果；
sq_executesql的另一个与其接口有关的强大功能是，你可以使用输出参数为调用批处理中的变量返回值。利用该功能可以避免用临时表返回数据，从而得到更高效的代码和更少的重新编译。定义和使用输出参数的语法与存储过程类似。也就是说，你需要在声明参数时指定OUTPUT子句。例如，下面的静态代码简单的演示了如何从动态批处理中利用输出参数@p把值返回到外部批处理中的变量@i.
DECLARE @sql AS NVARCHAR(12),@i AS INT;SET @sql = N' SET @p = 10'; EXEC sp_executesql @stmt = @sql, @params = N'@p AS INT OUTPUT', @p = @i OUTPUTSELECT @i该代码返回输出10

以上就是EXEC和sp_executesql的主要区别，如果各位看官觉得哪不对或者表达不清楚的，还请多多指出^_^

sp_executesql扩展存储过程与t-sql的execute功能相似，但有一点不同，通过sp_executesql执行的执行计划会被缓存起来，可重复使用。
测试：nz.perfectaction nzperfect@gmail.com
下面测试sp_executesql和exec的性能差别
Create DATABASE T_DB
GO
USE T_DB
GO
Create TABLE TB
(ID INT IDENTITY(1,1) PRIMARY KEY,NAME VARCHAR(20))
GO
Insert INTO TB Select 'A'
Insert INTO TB Select 'B'
Insert INTO TB Select 'C'
Insert INTO TB Select 'D'
Insert INTO TB Select 'E'
Insert INTO TB Select 'F'
GO
--清除缓存中所有元素
DBCC FREEPROCCACHE
--查看T_DB数据库使用的缓存
Select SQL AS EXEC_SQL,OBJTYPE AS EXEC_TYPE,* FROM MASTER..SYSCACHEOBJECTS Where DBID=DB_ID('T_DB')
AND SQL LIKE '%Select * FROM TB Where NAME%' AND SQL NOT LIKE '%SYSCACHEOBJECTS%'
ORDER BY SQL
结果为空，如图:

--测试使用EXEC，执行下面sql语块
DECLARE @SQL VARCHAR(2000)
DECLARE @NAME VARCHAR(20)
DECLARE @I INT
SET @I=1
WHILE @I<=6
BEGIN
IF @I=1 SET @NAME='A' IF @I=2 SET @NAME='B' IF @I=3 SET @NAME='C'
IF @I=4 SET @NAME='D' IF @I=5 SET @NAME='E' IF @I=6 SET @NAME='F'
SET @SQL = 'Select * FROM TB Where NAME = '''+@NAME+''''
EXEC(@SQL)
SET @I = @I + 1
END
--查看T_DB数据库使用的缓存
Select SQL AS EXEC_SQL,OBJTYPE AS EXEC_TYPE,* FROM MASTER..SYSCACHEOBJECTS Where DBID=DB_ID('T_DB')
AND SQL LIKE '%Select * FROM TB Where NAME%' AND SQL NOT LIKE '%SYSCACHEOBJECTS%'
ORDER BY SQL
结果有六条记录如图:

如下图,这说明sql server 对于exec执行的sql语句，即使where字段是同一个，但值不一样，每次都需要重新编译，而使用不同的缓存。
--测试使用SP_EXECUTESQL，执行下面sql语块
DECLARE @SQL NVARCHAR(2000)
DECLARE @NAME NVARCHAR(20)
DECLARE @I INT
SET @I=1
WHILE @I<=6
BEGIN
IF @I=1 SET @NAME='A' IF @I=2 SET @NAME='B' IF @I=3 SET @NAME='C'
IF @I=4 SET @NAME='D' IF @I=5 SET @NAME='E' IF @I=6 SET @NAME='F'
SET @SQL = 'Select * FROM TB Where NAME = @NAME'
EXEC SP_EXECUTESQL @SQL,N'@NAME NVARCHAR(20)',@NAME
SET @I = @I + 1
END
--查看缓存
Select SQL AS EXEC_SQL,OBJTYPE AS EXEC_TYPE,* FROM MASTER..SYSCACHEOBJECTS Where DBID=DB_ID('T_DB')
AND SQL LIKE '%Select * FROM TB Where NAME%' AND SQL NOT LIKE '%SYSCACHEOBJECTS%'
ORDER BY SQL
结果除了刚才的六条记录，又增加一条记录如图:

如上图，说明sql server 对于sp_executesql执行的sql语句，只要where字段是相同的，尽管值不同，都不再需要重新编译，而执行使用同一个缓存计划。
--测试完毕
Drop DATABASE T_DB
GO
Drop TABLE TB
GO
总结，sp_executesql执行计划会被缓存，而execute不可以，如果大量重复查询，sp_executesql比execute更能提高数据库性能。

The EXEC command (short for EXECUTE) has two uses: one is to execute a stored procedure, and the other is to execute a dynamic batch. The latter gets a character string within parentheses as an input and invokes the code within that character string.

1:使用sp_executesql
ALTER PROC dbo.usp_GetOrders
@OrderID AS INT = NULL,
@CustomerID AS NCHAR(5) = NULL,
@EmployeeID AS INT = NULL,
@OrderDate AS DATETIME = NULL
AS

DECLARE @sql AS NVARCHAR(4000);

SET @sql =
N'SELECT OrderID, CustomerID, EmployeeID, OrderDate, filler'
+ N' FROM dbo.Orders'
+ N' WHERE 1 = 1'
+ CASE WHEN @OrderID IS NOT NULL THEN
N' AND OrderID = @oid' ELSE N'' END
+ CASE WHEN @CustomerID IS NOT NULL THEN
N' AND CustomerID = @cid' ELSE N'' END
+ CASE WHEN @EmployeeID IS NOT NULL THEN
N' AND EmployeeID = @eid' ELSE N'' END
+ CASE WHEN @OrderDate IS NOT NULL THEN
N' AND OrderDate = @dt' ELSE N'' END;

EXEC sp_executesql
@sql,
N'@oid AS INT, @cid AS NCHAR(5), @eid AS INT, @dt AS DATETIME',
@oid = @OrderID,
@cid = @CustomerID,
@eid = @EmployeeID,
@dt = @OrderDate;
GO