SQLSERVER中的假脱机spool
SQLSERVER中的假脫機spool
我發現網上對于假脫機的解釋都非常零散，究竟假脫機是什么？
這幾天在家里研究了一下，收集了很多網上的資料
假脫機是中文的翻譯，而英文的名字叫做spool
在徐老師寫的《SQLSERVER企業級平臺管理實踐》里提到了一下假脫機
在SQLSERVER I/O問題的那一節
在性能監視器里，有一個計數器“worktables/sec” ：
每秒創建的工作表數。例如，工作表可用于存儲查詢假脫機（query spool），LOB變量，XML變量，表變量，游標的臨時結果
在《剖析SQLServer執行計劃》里也提到了假脫機
(13) 有時查詢優化器需要在tempdb數據庫中建立臨時工作表。如果是這樣的話
就意味著圖形執行計劃中有標識成Index Spool， Row Count Spool或者Table Spool的圖標。
任何時候，使用到工作表一般都會防礙到性能，因為需要額外的I/O開銷來維護這個工作表。
之前本人也寫過一篇文章：對于索引假脫機的一點理解
寫這篇文章的時候當時還是對假脫機一知半解
假脫機在MSDN中的執行計劃中的邏輯運算符和物理運算符中提到了幾個假脫機相關的運算符（詳見本文最后面）
Eager Spool
Lazy Spool
Index Spool (有時候也叫 Nonclustered Index Spool)
Row Count Spool
Spool
Table Spool
Window Spool
Spool, Table Spool, Index Spool, Window Spool 和 Row Count Spool是物理運算符
Eager Spool 和 Lazy Spool是邏輯運算符
這些運算符描述了假脫機是如何工作的，在這里你需要非常清楚邏輯運算符和物理運算符的區別
MSDN中的解釋：
邏輯運算符：邏輯運算符描述了用于處理語句的關系代數操作。 換言之，邏輯運算符從概念上描述了需要執行哪些操作。
物理運算符：物理運算符實施由邏輯運算符描述的操作。 每個物理運算符都是一個執行某項具體操作的對象或例程。
例如，某些物理運算符可訪問表、索引或視圖中的列或行。 其他物理運算符執行其他操作，如計算、聚合、數據完整性檢查或聯接。
物理運算符具有與其關聯的開銷。
注意：窗口假脫機是沒有Eager Spool和Lazy Spool之分的，因為他既是邏輯運算符也是物理運算符！！
簡單來講SQLSERVER做某項操作由物理運算符來做，而具體怎樣做就由邏輯運算符來決定
打個比方：小明在佛山，想去廣州，小明可以選擇開汽車去廣州，踩自行車去廣州，騎摩托車去廣州（相當于做某項操作）
小明可以根據當時的路況：
（1）踩自行車：如果道路比較擁堵，踩自行車不用怕，最多的車也能過，他可以選擇使勁的踩(Eager Spool)或者慢慢踩（Lazy Spool）
（2）開汽車：如果道路比較暢通，他可以選擇開快一點(Eager Spool)或者開慢一點（Lazy Spool）
（3）騎摩托車：如果道路比較擁堵，他可以選擇抄小路，然后開快一點(Eager Spool)或者開慢一點（Lazy Spool）
不知道這個比喻大家明白沒有，不過本人也找不到更好的比喻~
在圖形執行計劃中，你會發現Table Spool 有時候會帶有 Eager Spool ，有時候有會帶有 Lazy Spool
因為Table Spool是物理運算符，Eager Spool和Eager Spool 是邏輯運算符
Table Spool(表假脫機)
SQL腳本如下：
表假脫機 Eager Spool
1 ----表假脫機 Eager Spool 2 USE [Spool] 3 GO 4 CREATE TABLE Sales (EmpId INT, Yr INT, Sales MONEY) 5 INSERT Sales VALUES(1, 2005, 12000) 6 INSERT Sales VALUES(1, 2006, 18000) 7 INSERT Sales VALUES(1, 2007, 25000) 8 INSERT Sales VALUES(2, 2005, 15000) 9 INSERT Sales VALUES(2, 2006, 6000) 10 INSERT Sales VALUES(3, 2006, 20000) 11 INSERT Sales VALUES(3, 2007, 24000) 12 13 SELECT * FROM [dbo].[Sales] 14 15 16 SELECT EmpId, Yr, SUM(Sales) AS Sales 17 FROM Sales 18 GROUP BY EmpId, Yr WITH CUBE
View Code
例子出處：http://www.sqlskills.com/blogs/conor/grouping-sets-rollups-and-cubes-oh-my/
In this case, it writes the data to a temporary spool, sorts the output of that
and then re-reads that spool in the second branch.
表假脫機 Lazy Spool
1 --表假脫機 Lazy Spool 2 USE [AdventureWorks] 3 GO 4 SELECT *,COUNT(*) OVER() 5 from production.[Product] AS p 6 JOIN production.[ProductSubcategory] AS s 7 ON s.[ProductCategoryID]=p.[ProductSubcategoryID]
View Code
例子出處：http://sqlblog.com/blogs/rob_farley/archive/2013/06/11/spooling-in-sql-execution-plans.aspx
Row Count Spool(行計數假脫機)
SQL腳本如下：
1 --行計數假脫機 2 USE [Spool] 3 GO 4 --建表 5 CREATE TABLE tb1(ID int) 6 GO 7 CREATE TABLE tb2(ID int) 8 GO 9 10 --插入測試數據 11 DECLARE @i INT 12 SET @i= 500 13 WHILE @i > 0 14 begin 15 INSERT INTO dbo.tb1 16 VALUES ( @i 17 ) 18 SET @i = @i -1 19 end 20 GO 21 22 DECLARE @i INT 23 SET @i= 500 24 WHILE @i > 0 25 begin 26 INSERT INTO dbo.tb2 27 VALUES ( @i 28 ) 29 SET @i = @i -1 30 end 31 32 33 --行計數假脫機 34 SELECT * FROM tb1 WHERE id NOT IN(SELECT id FROM tb2)
View Code
例子出處：http://niutuku.com/tech/MsSql/238716.shtml
Index Spool (索引假脫機)
Lazy Spool
SQL腳本如下：
1 --索引假脫機（Index Spool） 2 USE [Spool] 3 GO 4 --建表 5 create table tb(aa int,bb char(1)) 6 GO 7 8 --插入測試數據 9 insert tb values(1,'A') 10 insert tb values(1,'B') 11 insert tb values(1,'C') 12 insert tb values(1,'D') 13 14 insert tb values(2,'E') 15 insert tb values(2,'F') 16 insert tb values(2,'G') 17 insert tb values(2,'H') 18 19 insert tb values(3,'I') 20 insert tb values(3,'J') 21 insert tb values(3,'K') 22 insert tb values(3,'L') 23 24 --查詢數據 25 SELECT * 26 FROM tb a 27 WHERE bb = ( SELECT TOP 1 28 bb 29 FROM tb 30 WHERE aa = a.aa 31 ORDER BY NEWID() 32 )
View Code
例子出處：http://www.cnblogs.com/lyhabc/archive/2013/04/19/3029840.html
Window Spool(窗口假脫機)
Window Spool 這個執行計劃和OVER() 開窗函數息息相關，因為只有OVER()函數才會使用到Window Spool 這個執行計劃
http://msdn.microsoft.com/zh-cn/library/ms189461.aspx
大家可以看一下MSDN中對OVER()開窗函數里ROWS選項和RANGE選項的解釋
ROWS | RANGE
通過指定分區中的起點和終點，進一步限制分區中的行數。 這是通過按照邏輯關聯或物理關聯對當前行指定某一范圍的行實現的。物理關聯通過使用 ROWS 子句實現。
ROWS 子句通過指定當前行之前或之后的固定數目的行，限制分區中的行數。
此外，RANGE 子句通過指定針對當前行中的值的某一范圍的值，從邏輯上限制分區中的行數。
基于 ORDER BY 子句中的順序對之前和之后的行進行定義。
窗口框架“RANGE … CURRENT ROW …”包括在 ORDER BY 表達式中與當前行具有相同值的所有行。
例如，ROWS BETWEEN 2 PRECEDING AND CURRENT ROW 意味著該函數對其操作的行的窗口在大小上是 3 行，以當前行之前（包括當前行）的 2 行開頭。
SQL腳本如下：
1 use master 2 GO 3 4 --range 5 select count(*) over (order by id RANGE between current row and unbounded following) 6 from sysobjects 7 order by id 8 9 --rows 10 select count(*) over (order by type ROWS current row ) 11 from sysobjects 12 order by id
View Code
例子出處：http://www.sqlteam.com/forums/topic.asp?TOPIC_ID=182542
對上面這些運算符的解釋：
假脫機運算符會取出表中的一部分的數據集，將他們存放在tempdb數據庫里的臨時結構里
這個臨時結構一般就是堆表或者非聚集索引，但是有一個物理運算符例外，臨時結構是不存放數據的，
他只存放假脫機里保存的數據的行數，而這個物理運算符就是Row Count spool
Index Spool:索引假脫機只有非聚集索引假脫機，沒有聚集索引假脫機，結合我以前寫的兩篇文章，解釋一下原因
SQLSERVER聚集索引與非聚集索引的再次研究（上）
SQLSERVER聚集索引與非聚集索引的再次研究（下）
SQLSERVER當遇到復雜的查詢的時候，需要把部分結果集放到tempdb數據庫里的非聚集索引頁里（說白了就是在tempdb數據庫里建立
表的非聚集索引）以加快查找的速度的時候就會用到索引假脫機
例如上面的例子，SQL語句用到了子查詢（tb表），SQLSERVER需要把子查詢里的結果集（tb表）進行排序然后將結果集放進去
非聚集索引里（對tb表建立非聚集索引），
然后用非聚集索引里的數據和主表（tb a）里的數據進行聯接，并輸出結果
為什麼不用聚集索引？
SQLSERVER聚集索引與非聚集索引的再次研究（上/下）里說到，非聚集索引和堆表是沒有連接在一起的，非聚集索引頁面只有指針
指向堆表的數據頁，而聚集索引的葉子節點就是數據頁，索引頁和數據頁連接在一起，如果建立聚集索引，就需要將表（tb表）中的數據
放入到tempdb數據庫里，這樣開銷就會很大
或者用下面兩張圖來描述可能會清楚一點，關鍵還是要讀懂 SQLSERVER聚集索引與非聚集索引的再次研究（上/下）
Table Spool:把表中的數據放進tempdb數據庫里
為什麼第一個查詢會用到Table Spool？因為CUBE這個數據匯總關鍵字會將表中的數據進行匯總，匯總的過程比較復雜
把表中的數據放進去tempdb數據庫里的工作表（worktable、臨時表、堆表）里進行復雜的匯總計算是比較好的
他避免了阻塞，以防止長期鎖住表中的數據
關于CUBE關鍵字可以看一下我這篇文章：SQLSERVER中的ALL、PERCENT、CUBE關鍵字、ROLLUP關鍵字和GROUPING函數
Row Count Spool:存放中間結果/表的數據的行數，上面的例子里用于計算表中的數據行數并保存在tempdb數據庫的
Row Count Spool里，為后面兩表聯接選用執行計劃提供選擇依據
Eager Spool邏輯運算符：一次性將所有數據放入到Spool里
Lazy Spool邏輯運算符：逐次逐次地將數據放入Spool里
在上面的例子里
Tabel Spool Eager Spool
SQLSERVER使用Eager Spool一次性將Sales 表中的數據存放到tempdb數據庫的工作表里面，方便快速統計
Row Count Spool
SQLSERVER使用計數器每次讀取到一行就加1，這樣一次一次地統計表中的行數（這里只是比喻，SQLSERVER內部可能并不是這樣統計！）
Window Spools：根據MSDN中的定義，OVER 子句定義查詢結果集內的窗口或用戶指定的行集。 然后，開窗函數將計算窗口中每一行的值
SQLSERVER將窗口中的結果集放入Spool里，以加快后續操作的速度
對于單獨一個窗口來講：單獨一個窗口屬于Eager Spool(一次性將結果集放進去窗口里)
對于表中的窗口來講：屬于Lazy Spool ，因為每個窗口把數據存放進去窗口里的速度/順序不是一致的，逐次逐次地將數據存放進去每個窗口
為什麼需要假脫機？
主要有兩個原因：
1：數據需要再次被調用
2：使假脫機數據與源數據保持隔離
第二個原因很容易理解，就像第一個例子中的Tabel Spool那樣，需要把表數據放進Tabel Spool里，以方便進行數據匯總，
而不影響原表數據
第一個原因可以再舉一個例子
公用表表達式（CTE）
1 USE [AdventureWorks] 2 GO 3 WITH managers AS( 4 SELECT [EmployeeID],[ManagerID] 5 from [HumanResources].[Employee] 6 WHERE [ManagerID] IS NULL 7 UNION ALL 8 SELECT e.[EmployeeID],e.[ManagerID] 9 from [managers] m 10 JOIN [HumanResources].[Employee] e 11 ON e.[ManagerID]=m.[EmployeeID] 12 ) 13 14 SELECT * FROM [managers]
索引假脫機運算符負責把數據一條一條地塞進去tempdb的非聚集索引里，并且是Lazy的，為什麼是Lazy的？
因為剛開始的時候只有一行記錄，后來慢慢一條一條數據地從最右邊的表假脫機里獲取數據
我們還是先分析一下整個執行計劃以方便理解，我們可以將整個執行計劃拆解為三部分
第一部分執行計劃的右上角
1 SELECT [EmployeeID],[ManagerID] 2 from [HumanResources].[Employee] 3 WHERE [ManagerID] IS NULL
這部分的執行計劃只查找到一條記錄
他把這條記錄放入索引假脫機里
第二部分 UNION ALL
將第一部分的結果和第三部分的結果合并在一起
第三部分執行計劃的右下角
1 SELECT e.[EmployeeID],e.[ManagerID] 2 from [managers] m 3 JOIN [HumanResources].[Employee] e 4 ON e.[ManagerID]=m.[EmployeeID]
最右邊的表假脫機運算符負責把表數據裝載入表假脫機里，這個裝載過程也是逐條數據裝載的
那么，執行計劃里的表假脫機和索引假脫機主要有什么用？？？
表假脫機主要用作公用表表達式里的遞歸調用
1 WITH managers AS( 2 SELECT [EmployeeID],[ManagerID] 3 from [HumanResources].[Employee] 4 WHERE [ManagerID] IS NULL 5 UNION ALL 6 SELECT e.[EmployeeID],e.[ManagerID] 7 from [managers] m 8 JOIN [HumanResources].[Employee] e 9 ON e.[ManagerID]=m.[EmployeeID] 10 )
SELECT e.[EmployeeID],e.[ManagerID]
from [managers] m
JOIN [HumanResources].[Employee] e
ON e.[ManagerID]=m.[EmployeeID]
上面的代碼是每次遞歸的時候都需要調用到的，所以SQLSERVER干脆把表數據放到假脫機里的，不用每次都去查找記錄了
而索引假脫機是方便外部代碼調用公用表表達式的時候不用每次都去計算公用表表達式的結果，直接把公用表表達式的結果
放進去索引假脫機，當SELECT * FROM managers的時候，直接到索引假脫機里取數據就可以了
1 SELECT * FROM [managers]
斷定運算符在這里的作用是判斷是否超過系統循環次數造成死循環，如果我們加上OPTION (MAXRECURSION 0)
斷定運算符就會消失
1 USE [AdventureWorks] 2 GO 3 WITH managers AS( 4 SELECT [EmployeeID],[ManagerID] 5 from [HumanResources].[Employee] 6 WHERE [ManagerID] IS NULL 7 UNION ALL 8 SELECT e.[EmployeeID],e.[ManagerID] 9 from [managers] m 10 JOIN [HumanResources].[Employee] e 11 ON e.[ManagerID]=m.[EmployeeID] 12 ) 13 14 SELECT * FROM [managers] OPTION (MAXRECURSION 0)
萬圣節問題
網上有兩篇文章介紹了這個問題
園子里的這篇文章介紹非常不深入，看了之后還是不明白
http://www.cnblogs.com/xwdreamer/archive/2012/05/28/2522404.html
simple-talk網站的文章就介紹得非常清晰
https://www.simple-talk.com/sql/learn-sql-server/operator-of-the-week---spools,-eager-spool/
在介紹之前先來做一個小實驗
下面SQL腳本建立一個非聚集索引表，并且非聚集索引的第一個字段是salary 并且按salary升序排序!!!
1 USE [Spool] 2 GO 3 4 CREATE TABLE nct(id INT IDENTITY(1,1),NAME VARCHAR(30), salary INT); 5 GO 6 --建立非聚集索引 切記：非聚集索引的第一個字段是salary 并且按salary升序排序!!! 7 CREATE INDEX ix_nct ON nct(salary ASC,[ID],[NAME]) 8 GO 9 10 --插入數據 11 INSERT INTO [dbo].[nct] ( [NAME],[salary] ) 12 SELECT '小明', 1 UNION ALL 13 SELECT '小華', 2 UNION ALL 14 SELECT '小芳', 3 15 GO 16 17 SELECT * FROM [dbo].[nct]
View Code
我們看一下非聚集索引頁
1 CREATE TABLE DBCCResult (
2 PageFID NVARCHAR(200),
3 PagePID NVARCHAR(200),
4 IAMFID NVARCHAR(200),
5 IAMPID NVARCHAR(200),
6 ObjectID NVARCHAR(200),
7 IndexID NVARCHAR(200),
8 PartitionNumber NVARCHAR(200),
9 PartitionID NVARCHAR(200),
10 iam_chain_type NVARCHAR(200),
11 PageType NVARCHAR(200),
12 IndexLevel NVARCHAR(200),
13 NextPageFID NVARCHAR(200),
14 NextPagePID NVARCHAR(200),
15 PrevPageFID NVARCHAR(200),
16 PrevPagePID NVARCHAR(200)
17 )
18
19 --TRUNCATE TABLE [dbo].[DBCCResult]
20
21 INSERT INTO DBCCResult EXEC ('DBCC IND(Spool,nct,-1) ')
22
23 SELECT * FROM [dbo].[DBCCResult] ORDER BY [PageType] DESC
24
25 DBCC TRACEON(3604,-1)
26 GO
27 DBCC PAGE(Spool,1,47,3)
28 GO
View Code
非聚集索引按照Salary字段升序排序
我們用SQL語句update一下小華的Salary
1 UPDATE nct SET Salary = 4 2 WHERE [NAME]='小華'
這里是按照非聚集索引的Range Scan讀取出結果的：SQLSERVER中的ALLOCATION SCAN和RANGE SCAN
再看一下非聚集索引頁面
我們看一下update前和update后非聚集索引頁面的變化
可以看到，update之后非聚集索引馬上根據非聚集索引鍵（Salary字段）重新進行升序排序
--------------------------------------------------------------------------------------------
使用下面SQL腳本建立測試環境
1 USE [Spool]
2 GO
3
4
5 --建表
6 CREATE TABLE Halloween
7 (
8 ID INT IDENTITY(1, 1)
9 PRIMARY KEY ,
10 Name VARCHAR(30) ,
11 Salary NUMERIC(18, 2),
12 Remark NVARCHAR(3000)
13 )
14 GO
15
16 --插入數據
17 INSERT INTO [dbo].[Halloween] ( [Name], [Salary], [Remark] )
18 SELECT '小明',1,replicate('a', 3000) UNION ALL
19 SELECT '小方',2,replicate('a', 3000)
20
21
22
23
24 --建立非聚集索引
25 CREATE NONCLUSTERED INDEX ix_Halloween ON Halloween(Salary ASC)
26 GO
27
28 --查詢
29 SELECT * FROM Halloween
30 GO
View Code
我們用下面SQL語句看一下聚集索引頁面和非聚集索引頁面
1 CREATE TABLE DBCCResult (
2 PageFID NVARCHAR(200),
3 PagePID NVARCHAR(200),
4 IAMFID NVARCHAR(200),
5 IAMPID NVARCHAR(200),
6 ObjectID NVARCHAR(200),
7 IndexID NVARCHAR(200),
8 PartitionNumber NVARCHAR(200),
9 PartitionID NVARCHAR(200),
10 iam_chain_type NVARCHAR(200),
11 PageType NVARCHAR(200),
12 IndexLevel NVARCHAR(200),
13 NextPageFID NVARCHAR(200),
14 NextPagePID NVARCHAR(200),
15 PrevPageFID NVARCHAR(200),
16 PrevPagePID NVARCHAR(200)
17 )
18
19 --TRUNCATE TABLE [dbo].[DBCCResult]
20 INSERT INTO DBCCResult EXEC ('DBCC IND(spool,Halloween,-1) ')
21
22 SELECT * FROM [dbo].[DBCCResult] ORDER BY [PageType] DESC
23
24
25 DBCC TRACEON(3604,-1)
26 GO
27 DBCC PAGE(spool,1,184,3)
28 GO
29 DBCC PAGE(spool,1,93,3)
30 GO
View Code
聚集索引頁面
非聚集索引頁面
我們update一下Salary等于1的那位員工的工資
1 UPDATE Halloween SET Salary = 2.5 2 FROM Halloween 3 WHERE Salary =1
再看一下聚集索引頁面和非聚集索引頁面
聚集索引頁面
非聚集索引頁面
非聚集索引馬上按照非聚集索引鍵（Salary字段）進行重新排序
這里似乎沒有什么問題，我們drop掉Halloween表，并重新建立測試環境
1 USE [Spool]
2 GO
3
4
5
6 --建表
7 CREATE TABLE Halloween
8 (
9 ID INT IDENTITY(1, 1)
10 PRIMARY KEY ,
11 Name VARCHAR(30) ,
12 Salary NUMERIC(18, 2),
13 Remark NVARCHAR(3000)
14 )
15 GO
16
17 --插入數據
18 INSERT INTO [dbo].[Halloween] ( [Name], [Salary], [Remark] )
19 SELECT '小明',1,replicate('a', 3000) UNION ALL
20 SELECT '小方',2,replicate('a', 3000)
21
22
23
24
25 --建立非聚集索引
26 CREATE NONCLUSTERED INDEX ix_Halloween ON Halloween(Salary ASC)
27 GO
28
29 --查詢
30 SELECT * FROM Halloween
31 GO
32
33
34
35
36
37 CREATE TABLE DBCCResult (
38 PageFID NVARCHAR(200),
39 PagePID NVARCHAR(200),
40 IAMFID NVARCHAR(200),
41 IAMPID NVARCHAR(200),
42 ObjectID NVARCHAR(200),
43 IndexID NVARCHAR(200),
44 PartitionNumber NVARCHAR(200),
45 PartitionID NVARCHAR(200),
46 iam_chain_type NVARCHAR(200),
47 PageType NVARCHAR(200),
48 IndexLevel NVARCHAR(200),
49 NextPageFID NVARCHAR(200),
50 NextPagePID NVARCHAR(200),
51 PrevPageFID NVARCHAR(200),
52 PrevPagePID NVARCHAR(200)
53 )
54
55 --TRUNCATE TABLE [dbo].[DBCCResult]
56 INSERT INTO DBCCResult EXEC ('DBCC IND(spool,Halloween,-1) ')
57
58 SELECT * FROM [dbo].[DBCCResult] ORDER BY [PageType] DESC
59
60
61 DBCC TRACEON(3604,-1)
62 GO
63 DBCC PAGE(spool,1,184,3)
64 GO
65 DBCC PAGE(spool,1,93,3)
66 GO
View Code
這次我們使用下面update語句，記住一定要加WITH(INDEX=ix_Halloween)
1 USE [Spool] 2 GO 3 UPDATE Halloween SET Salary = [Salary]*2.5 4 FROM Halloween WITH(INDEX=ix_Halloween) 5 WHERE Salary <7
如果我們加了WITH(INDEX=ix_Halloween)，SQLSERVER就會走非聚集索引查找
如果我們不加WITH(INDEX=ix_Halloween)，SQLSERVER就會走聚集索引掃描
這里不討論加不加WITH(INDEX=ix_Halloween)的問題
關鍵我們加WITH(INDEX=ix_Halloween)就是為了讓SQLSERVER走非聚集索引
update了之后正常的結果應該是這樣的
為什麼會這樣？
還記得剛才我們說到了非聚集索引更新了之后馬上進行排序嗎？
用下面的圖來表示應該會比較清楚
SQLSERVER使用Table Spool來解決萬圣節問題
先將非聚集索引的數據放進去Table Spool（臨時表）里，然后逐行逐行掃描臨時表，這樣就不會遇到非聚集索引更新后馬上進行排序的問題了
使用Table Spool后就能夠得到正確結果
為什麼不用Index Spool而用Table Spool？
之前我們說過Index Spool在tempdb數據庫里建立臨時的非聚集索引，把非聚集索引里的數據
放進去非聚集索引里，那不是會繼續遇到萬圣節問題？？？
下面這個SQL語句也是使用了Table Spool來避免萬圣節問題
1 USE [AdventureWorks] 2 GO 3 UPDATE s 4 SET [Name] = 'Z' + [Name] 5 FROM Production.ProductSubcategory AS s WITH ( INDEX ( [AK_ProductSubcategory_Name] ) ) 6 WHERE [Name] >= 'N'
萬圣節問題：
update數據的時候，如果update的是非聚集索引的第一個字段（即非聚集索引鍵）的時候并且走的是非聚集索引掃描/查找
都有可能引起萬圣節問題
SQLSERVER的解決方法是把非聚集索引里的數據全部移到Tabel Spool（Eager）里
防止由于更新非聚集索引的非聚集索引鍵而引起的非聚集索引重新排序，造成數據更新錯誤的問題
然后，其實Index Spool又好Table Spool又好，都是屬于臨時表的一種
類似案例
https://time.geekbang.org/column/article/80801
insert into t(c,d) (select c+1, d from t force index(c) order by c desc limit 1);
至于這個語句的執行為什么需要臨時表，原因是這類一邊遍歷數據，一邊更新數據的情況，如果讀出來的數據直接寫回原表，
就可能在遍歷過程中，讀到剛剛插入的記錄，新插入的記錄如果參與計算邏輯，就跟語義不符。
--建立非聚集索引 CREATE NONCLUSTERED INDEX ix_Halloween ON Halloween(Salary ASC) GO UPDATE Halloween SET Salary = [Salary]*2.5 FROM Halloween WITH(INDEX=ix_Halloween) WHERE Salary <7
這類場景，其實都可以歸納為一邊遍歷數據，一邊更新數據的情況，通用解決方案都是使用臨時表，先暫存現有的表數據，然后對臨時表的數據進行計算，計算完之后再更新回去原表
總結
實際上這些假脫機運算符的本質跟臨時表和表變量是一樣的，都是以空間換時間，以達到性能上的平衡！
文章最后面附上MSDN里的SQLSERVER所有的執行計劃(邏輯運算符和物理運算符)
參考文章：
http://www.scarydba.com/2009/09/09/spools-in-execution-plans/
https://www.simple-talk.com/sql/learn-sql-server/operator-of-the-week---spools,-eager-spool/
http://sqlblog.com/blogs/rob_farley/archive/2013/06/11/spooling-in-sql-execution-plans.aspx
如有不對的地方，歡迎大家拍磚o(∩_∩)o
Showplan 邏輯運算符和物理運算符參考
操作說明
本節介紹了各個邏輯運算符和物理運算符。
|
圖形執行計劃圖標 |
Showplan 運算符 |
說明 |
||
|---|---|---|---|---|
|
無 |
Aggregate |
Aggregate運算符計算包含 MIN、MAX、SUM、COUNT 或 AVG 的表達式。Aggregate既是一個邏輯運算符，也是一個物理運算符。 |
||
|
Arithmetic Expression |
Arithmetic Expression運算符根據行中的現有值計算新值。SQL Server 2012 中不使用Arithmetic Expression， |
|||
|
Assert |
Assert運算符用于驗證條件。例如，驗證引用完整性或確保標量子查詢返回一行。對于每個輸入行，Assert運算符都要計算執行計劃的Argument列中的表達式。如果此表達式的值為 NULL，則通過Assert運算符傳遞該行，并且查詢執行將繼續。如果此表達式的值非 Null，則將產生相應的錯誤。Assert運算符是一個物理運算符。 |
|||
|
Assign |
Assign運算符將表達式的值或常量分配給變量。Assign是一個語言元素。 |
|||
|
無 |
Asnyc Concat |
Asnyc Concat運算符僅用于遠程查詢（分布式查詢）。它有n個子節點和一個父節點。通常，某些子節點是參與分布式查詢的遠程計算機。Asnyc Concat同時向所有子節點發出open()調用，然后將位圖應用于每個子節點。對于為 1 的每個位，Async Concat按需向父節點發送輸出行。 |
||
|
Bitmap |
SQL Server 使用Bitmap運算符來實現并行查詢計劃中的位圖篩選。在將行傳遞給另一個運算符（如Parallelism運算符）之前，通過消除無法生成任何聯接記錄的鍵值的行，位圖篩選可提高查詢的執行速度。位圖篩選器使用運算符樹某部分的表中一組值的簡潔表示形式來篩選位于該樹另一部分的第二張表中的行。通過在查詢中預先刪除不必要的行，后續運算符將處理較少的行，從而提高查詢的整體性能。優化器將確定位圖的選擇性何時可滿足使用條件以及在哪些運算符上應用篩選器。Bitmap是一個物理運算符。 |
|||
|
Bitmap Create |
Bitmap Create運算符出現在創建位圖的顯示計劃輸出中。Bitmap Create是一個邏輯運算符。 |
|||
|
Bookmark Lookup |
Bookmark Lookup運算符使用書簽（行 ID 或聚集鍵）在表或聚集索引內查找相應的行。Argument列包含書簽標簽，用于在表或聚集索引內查找行。Argument列還包含要查找的行所在的表或聚集索引的名稱。如果Argument列中出現 WITH PREFETCH 子句，則表示查詢處理器已決定在表或聚集索引內查找書簽時將使用異步預提取（預讀）作為最佳選擇。 SQL Server 2012 中不使用Bookmark Lookup，而由Clustered Index Seek和RID Lookup提供書簽查找功能。Key Lookup運算符也提供此功能。 |
|||
|
無 |
Branch Repartition |
在并行查詢計劃中，有時存在迭代器的概念性區域。此類區域中的所有迭代器都可通過并行線程執行。這些區域本身必須串行執行。單個區域內的某些Parallelism迭代器稱為Branch Repartition。兩個這樣的區域邊界上的Parallelism迭代器稱為Segment Repartition。Branch Repartition和Segment Repartition是邏輯運算符。 |
||
|
無 |
Broadcast |
Broadcast有一個子節點和n個父節點。Broadcast根據使用者的請求將其輸入行發送給多個使用者。每個使用者都將獲得所有行。例如，如果所有使用者都是哈希聯接的生成端，則將生成n份哈希表。 |
||
|
Build Hash |
指示為 xVelocity 內存優化的列存儲索引生成批處理哈希表。 |
|||
|
無 |
Cache |
Cache是一個專門的Spool運算符。它僅存儲一行數據。Cache是一個邏輯運算符。SQL Server 2012 中不使用Cache。 |
||
|
Clustered Index Delete |
Clustered Index Delete運算符可刪除查詢執行計劃的 Argument 列指定的群集索引中的行。如果 Argument 列中存在 WHERE:() 謂詞，則僅刪除滿足該謂詞要求的行。Clustered Index Delete是一個物理運算符。 |
|||
|
Clustered Index Insert |
Clustered Index InsertShowplan 運算符可將其輸入中的行插入在 Argument 列指定的聚集索引中。Argument 列還包含一個 SET:() 謂詞，用于指示為每一列設置的值。如果Clustered Index Insert的插入值沒有子項，則插入的行來自Insert運算符本身。Clustered Index Insert是一個物理運算符。 |
|||
|
Clustered Index Merge |
Clustered Index Merge運算符可將合并數據流應用于聚集索引。該運算符可在其Argument列中所指定的聚集索引中刪除、更新或插入行。執行的實際操作取決于該運算符的Argument列中指定的ACTION列的運行時值。Clustered Index Merge是一個物理運算符。 |
|||
|
Clustered Index Scan |
Clustered Index Scan運算符會掃描查詢執行計劃的 Argument 列中指定的聚集索引。存在可選 WHERE:() 謂詞時，則只返回滿足該謂詞的那些行。如果 Argument 列包含 ORDERED 子句，則查詢處理器已請求按聚集索引排列行的順序返回行輸出。如果沒有 ORDERED 子句，存儲引擎將以最佳方式掃描索引，而無需對輸出進行排序。Clustered Index Scan既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Clustered Index Seek |
Clustered Index Seek運算符可以利用索引的查找功能從聚集索引中檢索行。Argument列包含所使用的聚集索引名稱和 SEEK:() 謂詞。存儲引擎僅使用索引來處理滿足此 SEEK:() 謂詞的行。它還包括 WHERE:() 謂詞，其中存儲引擎對滿足 SEEK:() 謂詞的所有行進行計算，但此操作是可選的，并且不使用索引來完成此過程。 如果Argument列包含 ORDERED 子句，則表示查詢處理器已決定必須按聚集索引排序行的順序返回行。如果沒有 ORDERED 子句，存儲引擎將以最佳方式搜索索引，而不對輸出進行必要的排序。若允許輸出保持順序，則效率可能比生成非排序輸出的效率低。出現關鍵字 LOOKUP 時，將執行書簽查找。在 SQL Server 2008 和更高版本中，Key Lookup運算符提供書簽查找功能。Clustered Index Seek既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Clustered Index Update |
Clustered Index Update運算符更新Argument列指定的聚集索引中的輸入行。如果存在 WHERE:() 謂詞，則只更新那些滿足此謂詞要求的行。如果存在 SET:() 謂詞，則將每個更新的列設置為該值。如果存在 DEFINE:() 謂詞，則列出此運算符定義的值。可以在 SET 子句中、該運算符內的其他位置和該查詢內的其他位置引用這些值。Clustered Index Update既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Collapse |
Collapse運算符用于優化更新處理。執行更新時，可以將該更新操作拆分（使用Split運算符）成為刪除和插入操作。Argument列包含一個指定鍵列列表的 GROUP BY:() 子句。如果查詢處理器遇到刪除和插入相同鍵值的相鄰行，則會用一個更有效的更新操作替換這些單獨的操作。Collapse既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Columnstore Index Scan |
Columnstore Index Scan運算符會掃描查詢執行計劃的Argument列中指定的列存儲索引。 |
|||
|
Compute Scalar |
Compute Scalar運算符通過對表達式求值來生成計算標量值。該值可以返回給用戶、在查詢中的其他位置引用或二者皆可。例如，在篩選謂詞或聯接謂詞中就會出現二者皆可的情況。Compute Scalar既是一個邏輯運算符，也是一個物理運算符。 在 SET STATISTICS XML 生成的顯示計劃中出現的Compute Scalar運算符可能不包含RunTimeInformation元素。在圖形顯示計劃中，當已在 SQL Server Management Studio 中選中“包括實際的執行計劃”選項時，“實際行”、“實際重新綁定次數”和“實際重繞次數”可能不會出現在“屬性”窗口中。當出現這種情況時，意味著雖然編譯過的查詢計劃中使用了這些運算符，但在運行時查詢計劃中，它們的作用是由其他運算符實現的。另外，請注意，SET STATISTICS PROFILE 生成的顯示計劃輸出中的執行數等于 SET STATISTICS XML 生成的顯示計劃中的重新綁定次數和重繞次數的總和。 |
|||
|
Concatenation |
Concatenation運算符掃描多個輸入，并返回每個掃描的行。Concatenation通常用于實現 Transact-SQL UNION ALL 結構。Concatenation物理運算符有兩個或多個輸入，有一個輸出。Concatenation 將行從第一個輸入流復制到輸出流，然后對其他輸入流重復進行此操作。Concatenation既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Constant Scan |
Constant Scan運算符可將一個或多個常量行引入到查詢中。Compute Scalar運算符通常在Constant Scan之后使用，以將列添加到Constant Scan運算符生成的行中。 |
|||
|
Convert |
Convert運算符將標量數據類型轉換為另一種類型。Convert是一個語言元素。 |
|||
|
無 |
Cross Join |
Cross Join運算符將第一個（頂端）輸入中的每一行與第二個（底端）輸入中的每一行聯接在一起。Cross Join是一個邏輯運算符。 |
||
|
catchall |
生成圖形顯示計劃的邏輯找不到迭代器的合適圖標時，將顯示通用圖標。通用圖標不一定指示存在錯誤。有三種通用圖標：藍色（用于迭代器）、橙色（用于游標）和綠色（用于 Transact-SQL 語言元素）。 |
|||
|
無 |
Cursor |
Cursor邏輯運算符和物理運算符用于描述涉及游標操作的查詢或更新的執行方式。其中物理運算符描述用于處理游標（如使用鍵集驅動游標）的物理實現算法。游標執行過程的每一步都涉及物理運算符。而邏輯運算符描述游標的屬性，如游標是只讀。 邏輯運算符包括 Asynchronous、Optimistic、Primary、Read Only、Scroll Locks、Secondary 和 Synchronous。 物理運算符包括 Dynamic、Fetch Query、Keyset、Population Query、Refresh Query 和 Snapshot。 |
||
|
Declare |
Declare運算符用于分配查詢計劃中的局部變量。Declare是一個語言元素。 |
|||
|
Delete |
Delete運算符將從對象中刪除滿足Argument列內的可選謂詞的行。 |
|||
|
Deleted Scan |
Deleted Scan運算符在觸發器中掃描刪除的表。 |
|||
|
無 |
Distinct |
Distinct運算符可以從行集或值集中刪除重復項。Distinct是一個邏輯運算符。 |
||
|
無 |
Distinct Sort |
Distinct Sort邏輯運算符將對輸入進行掃描，刪除重復項并按Argument列的 DISTINCT ORDER BY:() 謂詞中指定的列進行排序。Distinct Sort是一個邏輯運算符。 |
||
|
Distribute Streams |
Distribute Streams運算符僅用于并行查詢計劃。Distribute Streams運算符接收記錄的單個輸入流，并生成多個輸出流。記錄的內容和格式不會改變。輸入流中的每個記錄都將在某個輸出流中顯示。此運算符在輸出流中自動保留輸入記錄的相對順序。通常情況下，使用哈希操作確定特定輸入記錄所屬的輸出流。 如果將輸出分區，那么Argument列會包含 PARTITION COLUMNS:() 謂詞和分區列。Distribute Streams是一個邏輯運算符。 |
|||
|
Dynamic |
Dynamic運算符使用可以查看其他游標所做的任何更改的游標。 |
|||
|
Eager Spool |
Eager Spool運算符獲取整個輸入，并將每行存儲在tempdb數據庫中存儲的隱藏臨時對象中。如果重繞該運算符（例如通過Nested Loops運算符重繞），但不需要任何重新綁定，則將使用假脫機數據，而不用重新掃描輸入。如果需要重新綁定，將丟棄假脫機數據，并通過重新掃描（重新綁定的）輸入重新生成假脫機對象。Eager Spool運算符按“急切”方式生成自己的假脫機文件：當假脫機的父運算符請求第一行時，假脫機運算符將獲取所有來自其輸入運算符的行并將其存儲在假脫機中。Eager Spool是一個邏輯運算符。 |
|||
|
Fetch Query |
當對游標發出提取命令時，Fetch Query運算符將檢索行。 |
|||
|
Filter |
Filter運算符掃描輸入，僅返回那些符合Argument列中的篩選表達式（謂詞）的行。 |
|||
|
無 |
Flow Distinct |
Flow Distinct邏輯運算符用于通過掃描輸入來刪除重復項。雖然Distinct運算符在生成任何輸入前使用所有的輸入，但FlowDistinct運算符在從輸入獲得行時返回每行（除非該行是一個重復項，若是這樣則刪除該行）。 |
||
|
無 |
Full Outer Join |
Full Outer Join邏輯運算符從第一個（頂端）輸入中與第二個（底端）輸入相聯接的行中返回每個滿足聯接謂詞的行。它還可以從下列輸入返回行： 在第二個輸入中沒有匹配項的第一個輸入。 在第一個輸入中沒有匹配項的第二個輸入。 不包含匹配值的輸入將作為空值返回。Full Outer Join是一個邏輯運算符。 |
||
|
Gather Streams |
Gather Streams運算符僅用在并行查詢計劃中。Gather Streams運算符處理幾個輸入流并通過組合這幾個輸入流生成單個記錄輸出流。不更改記錄的內容和格式。如果此運算符保留順序，則所有的輸入流都必須有序。如果輸出已排序，則Argument列包含一個 ORDER BY:() 謂詞和正在排序的列名稱。Gather Streams是一個邏輯運算符。 |
|||
|
Hash Match |
Hash Match運算符通過計算其生成輸入中每行的哈希值生成哈希表。HASH:() 謂詞以及一個用于創建哈希值的列的列表出現在Argument列內。然后，該謂詞為每個探測行（如果適用）計算哈希值（使用相同的哈希函數）并在哈希表內查找匹配項。如果存在殘留謂詞（由Argument列中的 RESIDUAL:() 標識），則還須滿足此殘留謂詞，只有這樣行才能被視為是匹配項。行為取決于所執行的邏輯操作： 對于聯接，使用第一個（頂端）輸入生成哈希表，使用第二個（底端）輸入探測哈希表。按聯接類型規定的模式輸出匹配項（或不匹配項）。如果多個聯接使用相同的聯接列，這些操作將分組為一個哈希組。 對于非重復或聚合運算符，使用輸入生成哈希表（刪除重復項并計算聚合表達式）。生成哈希表時，掃描該表并輸出所有項。 對于 union 運算符，使用第一個輸入生成哈希表（刪除重復項）。使用第二個輸入（它必須沒有重復項）探測哈希表，返回所有沒有匹配項的行，然后掃描該哈希表并返回所有項。 Hash Match是一個物理運算符。 |
|||
|
If |
If運算符執行基于表達式的有條件處理。If是一個語言元素。 |
|||
|
無 |
Inner Join |
Inner Join邏輯運算符返回滿足第一個（頂端）輸入與第二個（底端）輸入所組成的聯接的每一行。 |
||
|
Insert |
Insert邏輯運算符將每行從其輸入插入Argument列內指定的對象中。相應的物理運算符為Table Insert、Index Insert或Clustered Index Insert運算符。 |
|||
|
Inserted Scan |
Inserted Scan運算符掃描插入的表。Inserted Scan既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Intrinsic |
Intrinsic運算符調用內部 Transact-SQL 函數。Intrinsic是一個語言元素。 |
|||
|
Iterator |
生成圖形顯示計劃的邏輯找不到Iterator的合適圖標時，將顯示通用圖標。通用圖標不一定指示存在錯誤。有三種通用圖標：藍色（用于迭代器）、橙色（用于游標）和綠色（用于 Transact-SQL 語言構造）。 |
|||
|
Key Lookup |
Key Lookup運算符是在具有聚集索引的表上進行的書簽查找。Argument列包含聚集索引的名稱和用來在聚集索引中查找行的聚集鍵。Key Lookup通常帶有Nested Loops運算符。如果Argument列中出現 WITH PREFETCH 子句，則表示查詢處理器已決定在聚集索引內查找書簽時將使用異步預提取（預讀）作為最佳選擇。 在查詢計劃中使用Key Lookup運算符表明該查詢可能會從性能優化中獲益。例如，添加涵蓋索引可能會提高查詢性能。 |
|||
|
Keyset |
Keyset運算符使用的游標可用于查看其他用戶所做的更新，而不能查看其他用戶所做的插入。 |
|||
|
Language Element |
生成圖形顯示計劃的邏輯找不到Language Element的合適圖標時，將顯示通用圖標。通用圖標不一定指示存在錯誤。有三種通用圖標：藍色（用于迭代器）、橙色（用于游標）和綠色（用于 Transact-SQL 語言構造）。 |
|||
|
Lazy Spool |
Lazy Spool邏輯運算符將其輸入中的每一行存儲到tempdb數據庫內存儲的隱藏臨時對象中。如果重繞該運算符（例如通過Nested Loops運算符重繞），但不需要任何重新綁定，則將使用假脫機數據，而不用重新掃描輸入。如果需要重新綁定，則將放棄假脫機數據，并通過重新掃描（重新綁定的）輸入重新生成假脫機對象。Lazy Spool運算符以“遲緩”方式生成其假脫機文件，即每當假脫機父運算符請求一行時，假脫機運算符便從其輸入運算符獲取一行，然后將該行存儲在假脫機中，而不是一次處理所有行。Lazy Spool 是一個邏輯運算符。 |
|||
|
無 |
Left Anti Semi Join |
當第二個（底端）輸入中沒有匹配行時，Left Anti Semi Join運算符返回第一個（頂端）輸入中的每一行。如果Argument列內不存在任何聯接謂詞，則每行都是一個匹配行。Left Anti Semi Join是一個邏輯運算符。 |
||
|
無 |
Left Outer Join |
Left Outer Join運算符返回滿足第一個（頂端）輸入與第二個（底端）輸入聯接的每一行。它還返回任何在第二個輸入中沒有匹配行的第一個輸入中的行。第二個輸入中的非匹配行作為空值返回。如果Argument列內不存在任何聯接謂詞，則每行都是一個匹配行。Left Outer Join是一個邏輯運算符。 |
||
|
無 |
Left Semi Join |
當第二個（底端）輸入中有匹配行時，Left Semi Join運算符返回第一個（頂端）輸入中的每行。如果Argument列內不存在任何聯接謂詞，則每行都是一個匹配行。Left Semi Join是一個邏輯運算符。 |
||
|
Log Row Scan |
Log Row Scan運算符用于掃描事務日志。Log Row Scan既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Merge Interval |
Merge Interval運算符可合并多個（可能重疊的）間隔以得出最小的不重疊間隔，然后將其用于查找索引項。此運算符通常出現在Constant Scan運算符中的一個或多個Compute Scalar運算符上方，后者運算符構造了此運算符所合并的間隔（表示為一行中的多個列）。Merge Interval既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Merge Join |
Merge Join運算符執行內部聯接、左外部聯接、左半部聯接、左反半部聯接、右外部聯接、右半部聯接、右反半部聯接和聯合邏輯運算。 在Argument列中，如果操作執行一對多聯接，則Merge Join運算符將包含 MERGE:() 謂詞；如果操作執行多對多聯接，則該運算符將包含 MANY-TO-MANY MERGE:() 謂詞。Argument列還包含一個用于執行操作的列的列表，該列表以逗號分隔。Merge Join運算符要求在各自的列上對兩個輸入進行排序，這可以通過在查詢計劃中插入顯式排序操作來實現。如果不需要顯式排序（例如，如果數據庫內有合適的 B 樹索引或可以對多個操作（如合并聯接和對匯總分組）使用排序順序），則合并聯接尤其有效。Merge Join是一個物理運算符。 |
|||
|
Nested Loops |
Nested Loops運算符執行內部聯接、左外部聯接、左半部聯接和左反半部聯接邏輯運算。Nested Loops 聯接通常使用索引在內部表中搜索外部表的每一行。根據預計的開銷，查詢處理器決定是否對外部輸入進行排序來改變內部輸入索引的搜索位置。將基于所執行的邏輯操作返回所有滿足Argument列內的（可選）謂詞的行。Nested Loops是一個物理運算符。 |
|||
|
Nonclustered Index Delete |
Nonclustered Index Delete運算符通過Argument列中指定的非聚集索引刪除輸入行。Nonclustered Index Delete是一個物理運算符。 |
|||
|
Index Insert |
Index Insert運算符用于將行從其輸入插入到Argument列中指定的非聚集索引中。Argument列還包含一個 SET:() 謂詞，用于指示為每一列設置的值。Index Insert是一個物理運算符。 |
|||
|
Index Scan |
Index Scan運算符從Argument列中指定的非聚集索引中檢索所有行。如果可選的 WHERE:() 謂詞出現在Argument列中，則僅返回滿足此謂詞的那些行。Index Scan既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Index Seek |
Index Seek運算符利用索引的查找功能從非聚集索引中檢索行。Argument列包含所使用的非聚集索引的名稱。它還包括 SEEK:() 謂詞。存儲引擎僅使用索引來處理滿足 SEEK:() 謂詞的行。它可能還包含一個 WHERE:() 謂詞，其中存儲引擎對滿足 SEEK:() 謂詞的所有行進行計算（不使用索引來完成）。如果Argument列包含 ORDERED 子句，則表示查詢處理器已決定必須按非聚集索引排序行的順序返回行。如果沒有 ORDERED 子句，則存儲引擎將以最佳方式（不保證對輸出排序）搜索索引。如果讓輸出保持其順序，則效率可能低于生成非排序輸出。Index Seek既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Index Spool |
Index Spool物理運算符在Argument列中包含 SEEK:() 謂詞。Index Spool運算符掃描其輸入行，將每行的副本放置在隱藏的假脫機文件（存儲在tempdb數據庫中且只在查詢的生存期內存在）中，并為這些行創建非聚集索引。這樣可以使用索引的查找功能來僅輸出那些滿足 SEEK:() 謂詞的行。如果重繞該運算符（例如通過Nested Loops運算符重繞），但不需要任何重新綁定，則將使用假脫機數據，而不用重新掃描輸入。 |
|||
|
Nonclustered Index Update |
Nonclustered Index Update物理運算符用于更新Argument列內指定的非聚集索引中的輸入行。如果存在 SET:() 謂詞，則將每個更新的列設置為該值。Nonclustered Index Update是一個物理運算符。 |
|||
|
Online Index Insert |
Online Index Insert物理運算符指示索引創建、更改或刪除操作是在線執行的。也就是說，基礎表數據在索引操作期間仍然對用戶可用。 |
|||
|
無 |
Parallelism |
Parallelism運算符執行分發流、收集流和對流重新分區邏輯操作。Argument列可以包含一個 PARTITION COLUMNS:() 謂詞和一個以逗號分隔的分區列的列表。Argument列還可以包含一個 ORDER BY:() 謂詞，以列出分區過程中要保留排序順序的列。Parallelism是物理運算符。
|
||
|
Parameter Table Scan |
Parameter Table Scan運算符掃描在當前查詢中用作參數的表。該運算符一般用于存儲過程內的 INSERT 查詢。Parameter Table Scan既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
無 |
Partial Aggregate |
Partial Aggregate用于并行計劃中。它將聚合功能應用到盡可能多的輸入行中，以便不必執行向磁盤寫入數據的操作（稱為“溢出”）。Hash Match是實現分區聚合的唯一一個物理運算符（迭代器）。Partial Aggregate是一個邏輯運算符。 |
||
|
Population Query |
Population Query運算符在打開游標時填充游標的工作表。 |
|||
|
Refresh Query |
Refresh Query運算符為提取緩沖區中的行提取當前數據。 |
|||
|
Remote Delete |
Remote Delete運算符用于從遠程對象中刪除輸入行。Remote Delete既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Remote Index Scan |
Remote Index Scan運算符可以掃描在 Argument 列中指定的遠程索引。Remote Index Scan既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Remote Index Seek |
Remote Index Seek運算符利用遠程索引對象的查找功能來檢索行。Argument列包含所使用的遠程索引名稱和 SEEK:() 謂詞。Remote Index Seek是一個邏輯物理運算符。 |
|||
|
Remote Insert |
Remote Insert運算符將輸入行插入到遠程對象。Remote Insert既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Remote Query |
Remote Query運算符將查詢提交給遠程源。發送給遠程服務器的查詢文本顯示在Argument列中。Remote Query既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Remote Scan |
Remote Scan運算符掃描遠程對象。遠程對象的名稱顯示在Argument列中。Remote Scan既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Remote Update |
Remote Update運算符將更新遠程對象中的輸入行。Remote Update既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Repartition Streams |
Repartition Streams運算符使用多個流并生成多個記錄流。記錄的內容和格式不會改變。如果查詢優化器使用位圖篩選器，則輸出流中行的數量將減少。輸入流中的每個記錄都放入一個輸出流中。如果該運算符保留次序，則必須對所有輸入流排序并將它們合并到幾個有序的輸出流中。如果將輸出分區，那么Argument列會包含 PARTITION COLUMNS:() 謂詞和分區列。如果輸出已經排序，則Argument列包含一個 ORDER BY:() 謂詞和已經排序的列。Repartition Streams是一個邏輯運算符。該運算符只用于并行查詢計劃中。 |
|||
|
Result |
Result運算符是查詢計劃結束時返回的數據。它通常是顯示計劃的根元素。Result是一個語言元素。 |
|||
|
RID Lookup |
RID Lookup是使用提供的行標識符 (RID) 在堆上進行的書簽查找。Argument列包含用于查找表中的行的書簽標簽和從中查找行的表的名稱。RID Lookup通常帶有 NESTED LOOP JOIN。RID Lookup是一個物理運算符。有關書簽查找的詳細信息，請參閱 MSDN SQL Server 博客中的Bookmark Lookup（書簽查找）。 |
|||
|
無 |
Right Anti Semi Join |
Right Anti Semi Join運算符輸出第二個（底端）輸入中與第一個（頂端）輸入中的任何行都不匹配的每一行。匹配行的定義是滿足Argument列內的謂詞的行（如果不存在謂詞，則每行都是一個匹配行）。Right Anti Semi Join是一個邏輯運算符。 |
||
|
無 |
Right Outer Join |
Right Outer Join運算符返回滿足第二個（底端）輸入與第一個（頂端）輸入的每個匹配行的聯接的每行。此外，它還返回第二個輸入中在第一個輸入中沒有匹配行的任何行，即與 NULL 聯接。如果Argument列內不存在任何聯接謂詞，則每行都是一個匹配行。Right Outer Join是一個邏輯運算符。 |
||
|
無 |
Right Semi Join |
第一個（頂端）輸入有匹配行時，Right Semi Join運算符返回第二個（底端）輸入中的每一行。如果Argument列內不存在任何聯接謂詞，則每行都是一個匹配行。Right Semi Join是一個邏輯運算符。 |
||
|
Row Count Spool |
Row Count Spool運算符掃描輸入，計算現有的行數并返回相同數目的不包含任何數據的行。必須檢查現有行數（而非行中包含的數據）時，使用此運算符。例如，如果Nested Loops運算符執行左半聯接操作且聯接謂詞應用于內部輸入，則可以在Nested Loops運算符內部輸入的頂部放置行計數假脫機。這樣，Nested Loops運算符就可以確定行計數假脫機輸出的行數（因為不需要內側的實際數據）以決定是否返回外部行。Row Count Spool是一個物理運算符。 |
|||
|
Segment |
Segment既是一個物理運算符，也是一個邏輯運算符。它基于一個或多個列的值將輸入集劃分成多個段。這些列顯示為Segment運算符中的參數。然后此運算符每次輸出一個段。 |
|||
|
無 |
Segment Repartition |
在并行查詢計劃中，有時存在迭代器的概念性區域。此類區域中的所有迭代器都可通過并行線程執行。這些區域本身必須串行執行。單個區域內的某些Parallelism迭代器稱為Branch Repartition。兩個這樣的區域邊界上的Parallelism迭代器稱為Segment Repartition。Branch Repartition和Segment Repartition是邏輯運算符。 |
||
|
Sequence |
Sequence運算符驅動大范圍的更新計劃。就其功能而言，該運算符按順序（從上到下）執行每個輸入。每個輸入通常是不同對象的更新。該運算符只返回其上一個（底端）輸入中的行。Sequence既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Sequence Project |
Sequence Project運算符將添加列以便計算有序集。它基于一個或多個列的值將輸入集劃分成多個段。然后此運算符每次輸出一個段。這些列在Sequence Project運算符中作為參數顯示。Sequence Project既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Snapshot |
Snapshot運算符創建一個看不到其他人所做更改的游標。 |
|||
|
Sort |
Sort運算符可對所有傳入的行進行排序。Argument列包含 DISTINCT ORDER BY:() 謂詞（如果此操作刪除了重復項），或 ORDER BY:() 謂詞（如果對逗號分隔的列列表進行排序）。如果按升序對列排序，則使用值 ASC 作為列的前綴；如果按降序對列排序，則使用值 DESC 作為列的前綴。Sort既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Split |
Split運算符用于優化更新處理。它將每個更新操作拆分成刪除和插入操作。Split既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Spool |
Spool運算符將中間查詢結果保存到tempdb數據庫中。 |
|||
|
Stream Aggregate |
Stream Aggregate運算符按一列或多列對行分組，然后計算由查詢返回的一個或多個聚合表達式。此運算符的輸出可供查詢中的后續運算符引用和/或返回到客戶端。Stream Aggregate運算符要求輸入在組中按列進行排序。如果由于前面的Sort運算符或已排序的索引查找或掃描導致數據尚未排序，則優化器將在此運算符前面使用一個Sort運算符。在 SHOWPLAN_ALL 語句或 SQL Server Management Studio 的圖形執行計劃中，GROUP BY 謂詞中的列會列在Argument列中，而聚合表達式列在Defined Values列中。Stream Aggregate是一個物理運算符。 |
|||
|
Switch |
Switch是一種特殊類型的串聯迭代器，它具有n個輸入。有一個表達式與每個Switch運算符關聯。根據表達式的返回值（在 0 到n-1 之間），Switch將適當的輸入流復制到輸出流。Switch的一種用途是與某些運算符（如TOP運算符）一起實現涉及快進游標的查詢計劃。Switch既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Table Delete |
Table Delete物理運算符刪除查詢執行計劃的Argument列中所指定表中的行。 |
|||
|
Table Insert |
Table Insert運算符將輸入的行插入到在查詢執行計劃的Argument列指定的表中。Argument列還包含一個 SET:() 謂詞，用于指示為每一列設置的值。如果Table Insert的插入值沒有子項，插入的行則來自 Insert 運算符本身。Table Insert是一個物理運算符。 |
|||
|
Table Merge |
Table Merge運算符可將合并數據流應用到堆。該運算符可在其Argument列中所指定的表中刪除、更新或插入行。執行的實際操作取決于該運算符的Argument列中指定的ACTION列的運行時值。Table Merge是一個物理運算符。 |
|||
|
Table Scan |
Table Scan運算符從查詢執行計劃的Argument列所指定的表中檢索所有行。如果 WHERE:() 謂詞出現在Argument列中，則僅返回滿足此謂詞的那些行。Table Scan既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Table Spool |
Table Spool運算符掃描輸入，并將各行的一個副本放入隱藏的假脫機表中，此表存儲在tempdb數據庫中并且僅在查詢的生存期內存在。如果重繞該運算符（例如通過Nested Loops運算符重繞），但不需要任何重新綁定，則將使用假脫機數據，而不用重新掃描輸入。Table Spool是一個物理運算符。 |
|||
|
Table Update |
Table Update物理運算符更新查詢執行計劃的Argument列中所指定表中的輸入行。SET:() 謂詞確定每個更新列的值。可以在 SET 子句中、此運算符內的其他位置以及此查詢內的其他位置引用這些值。 |
|||
|
Table-valued Function |
Table-valued Function運算符計算表值函數（Transact-SQL 或 CLR）并將結果行存儲在tempdb數據庫中。當父迭代器請求這些行時，Table-valued Function將返回tempdb中的行。 調用表值函數的查詢生成具有Table-valued Function迭代器的查詢計劃。可以使用不同的參數值計算Table-valued Function： Table-valued Function XML Reader輸入 XML BLOB 作為參數，并生成一個按 XML 文檔順序表示 XML 節點的行集。其他輸入參數可能會將返回的 XML 節點限于 XML 文檔的子集。 Table Valued Function XML Reader with XPath filter是一種特殊的XML Reader Table-valued Function，它將輸出限于滿足 XPath 表達式的 XML 節點。 Table-valued Function既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
Top |
Top運算符掃描輸入，但僅基于排序順序返回最前面的指定行數或行百分比。Argument列可以包含要檢查重復值的列的列表。在更新計劃中，Top運算符用于強制實施行計數限制。Top既是一個邏輯運算符，也是一個物理運算符。Top既是一個邏輯運算符，也是一個物理運算符。 |
|||
|
無 |
Top N Sort |
Top N Sort與Sort迭代器類似，差別僅在于前者需要前N行，而不是整個結果集。如果N的值較小，SQL Server 查詢執行引擎將嘗試在內存中執行整個排序操作。如果N的值較大，查詢執行引擎將使用更通用的排序方法（該方法不采用N作為參數）重新排序。 |
||
|
UDX |
擴展運算符 (UDX) 可以實現 SQL Server 中的一種 XQuery 或 XPath 操作。所有 UDX 運算符既是邏輯運算符，又是物理運算符。 擴展運算符 (UDX)FOR XML用于將其輸入的關系行集序列化為 XML 表示形式，并以單個輸出行、單個 BLOB 列的形式存儲。它是區分順序的 XML 聚合運算符。 擴展運算符 (UDX)XML SERIALIZER是區分順序的一種 XML 聚合運算符。它以 XML 文檔順序輸入表示 XML 節點或 XQuery 標量的行，并在單個輸出行、單個 XML 列中生成序列化的 XML BLOB。 擴展運算符 (UDX)XML FRAGMENT SERIALIZER是一種特殊類型的XML SERIALIZER，用于處理表示在 XQuery 插入數據修改擴展中插入的 XML 片斷的輸入行。 擴展運算符 (UDX)XQUERY STRING計算表示 XML 節點的輸入行的 XQuery 字符串值。它是一個區分順序的字符串聚合運算符。它輸出一行多列，表示包含輸入字符串值的 XQuery 標量。 擴展運算符 (UDX)XQUERY LIST DECOMPOSER是一個 XQuery 列表分解運算符。對于表示 XML 節點的每個輸入行，它至少生成表示 XQuery 標量的一個行，如果輸入的是 XSD 列表類型的行，則每個行都包含一個列表元素值。 擴展運算符 (UDX)XQUERY DATA在表示 XML 節點的輸入行上計算 XQuery fn:data() 函數的值。它是一個區分順序的字符串聚合運算符。它輸出一行多列，表示包含fn:data()結果的 XQuery 標量。 擴展運算符XQUERY CONTAINS在表示 XML 節點的輸入行上計算 XQuery fn:contains() 函數的值。它是一個區分順序的字符串聚合運算符。它輸出一行多列，表示包含fn:contains()結果的 XQuery 標量。 擴展運算符UPDATE XML NODE更新 XML 類型的modify()方法中 XQuery 替換數據修改擴展的 XML 節點。 |
|||
|
無 |
Union |
Union運算符掃描多個輸入，輸出掃描的每一行并刪除重復項。Union是一個邏輯運算符。 |
||
|
Update |
Update運算符更新在查詢執行計劃的Argument列中所指定對象中的每一輸入行。Update是一個邏輯運算符。物理運算符為Table Update、Index Update或Clustered Index Update。 |
|||
|
While |
While運算符實現 Transact-SQL while 循環。While是一個語言元素。 |
|||
|
Window Spool |
Window Spool運算符將每個行擴展為表示與行關聯的窗口的行集。在查詢中，OVER 子句定義查詢結果集內的窗口和窗口函數，然后計算窗口中的每個行的值。Window Spool既是一個邏輯運算符，也是一個物理運算符。 |
https://msdn.microsoft.com/zh-cn/library/ms187840%28v=sql.105%29.aspx?f=255&MSPPError=-2147217396
Merge Interval 運算符可合并多個（可能重疊的）間隔以得出最小的不重疊間隔，然后將其用于查找索引項。此運算符通常出現在 Constant Scan 運算符中的一個或多個 Compute Scalar 運算符上方，Constant Scan 運算符構造了此運算符所合并的間隔（表示為一行中的多個列）。
Merge Interval 既是一個邏輯運算符，也是一個物理運算符。
圖形執行計劃圖標
|
Sequence Project |
Sequence Project運算符將添加列以便計算有序集。它基于一個或多個列的值將輸入集劃分成多個段。然后此運算符每次輸出一個段。這些列在Sequence Project運算符中作為參數顯示。Sequence Project既是一個邏輯運算符，也是一個物理運算符。 |
關系運算
投影 projection，投影運算也是單目運算，關系R上的投影是從R中選擇出若干屬性列，組成新的關系，即對關系在垂直方向進行的運算，從左到右按照指定的若干屬性以及順序取出相應列，刪除重復元組
投影運算是從列的角度進行的運算，這正是選取運算和投影運算的區別所在，選取運算是從關系的水平方向向上進行運算，而投影運算則是從關系的垂直方向上進行的
數據庫原理及應用教程 第3版 陳志泊主編
本文版權歸作者所有，未經作者同意不得轉載。
總結
以上是生活随笔為你收集整理的SQLSERVER中的假脱机spool的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： mariadb中文手册_MariaDB性
- 下一篇： 为什么要进行软件需求分析？通常对软件系统