[Edit 2016: Check out my new resource – a comprehensive library of all wait types and latch classes – see here.]
SQL Server 2014 (and Azure SQL Database V12) added some cool new functionality for online index operations to allow you to prevent long-term blocking because of the two blocking locks that online index operations require.
At the start of any online index operation, it acquires a S (share) table lock. This lock will be blocked until all transactions that are changing the table have committed, and while the lock is pending, it will block any transactions wanting to change the table in any way. The S lock is only held for a short amount of time, then dropped to an IS (Intent-Share) lock for the long duration of the operation. At the end of any online index operation, it acquires a SCH-M (schema modification) table lock, which you can think of as a super-exclusive lock. This lock will be blocked by any transaction accessing or changing the table, and while the lock is pending, it will block any transactions wanting to read or change the table in any way.
The new syntax allow you to specify how long the online index operation will wait for each of these locks, and what to do when the timeout expires (nothing: NONE, kill the online index operation: SELF, or kill the blockers of the online index operation: BLOCKERS – see Books Online for more info). While the online index operation is blocked, it shows a different lock wait type than we’re used to seeing, and any lock requests are allowed to essentially jump over the online index operation in the lock pending queues – i.e. the online index operation waits with lower priority than everything else on the system.
To demonstrate this, I’ve got a table called NonSparseDocRepository, with a clustered index called NonSparse_CL, and 100,000 rows in the table.
First, I’ll kick off an online index rebuild of the clustered index, specifying a 1 minute wait, and to kill itself of the wait times out:
ALTER INDEX [NonSparse_CL] ON [nonsparsedocrepository] REBUILD WITH (FILLFACTOR = 70, ONLINE = ON ( WAIT_AT_LOW_PRIORITY ( MAX_DURATION = 1 MINUTES, ABORT_AFTER_WAIT = SELF) ) ); GO
I let it run for ten seconds or so, so make sure it got past the initial table S lock required. Now, in another connection, I’ll start a transaction that takes an IX table lock, which will block the final SCH-M lock the online index operation requires:
BEGIN TRAN; GO UPDATE [NonSparseDocRepository] SET [c4] = '1' WHERE [DocID] = 1; GO
And then I’ll wait until the drive light on my laptop goes off, which lets me know that the online index rebuild is stalled. If I look in sys.dm_os_waiting_tasks (using the script in this post), I’ll see the rebuild is blocked (script output heavily edited for clarity and brevity):
session_id exec_context_id scheduler_id wait_duration_ms wait_type blocking_session_id resource_description 57 0 4 7786 LCK_M_SCH_M_LOW_PRIORITY 58 objectlock
Look at the wait type: LCK_M_SCH_M_LOW_PRIORITY. The _LOW_PRIORITY suffix indicates that this is a special lock wait attributable to the online index operation being blocked.
This also neatly proves that the wait-at-low-priority feature applies to both the blocking locks that online index operations require, even if the first one isn’t blocked.
And eventually the online index operation fails, as follows:
Msg 1222, Level 16, State 56, Line 1 Lock request time out period exceeded.
If I leave that open transaction in the other connection (holding its IX table lock), and try the index rebuild again, with the exact same syntax, it’s immediately blocked and the sys.dm_os_waiting_tasks script shows:
session_id exec_context_id scheduler_id wait_duration_ms wait_type blocking_session_id resource_description 57 0 4 8026 LCK_M_S_LOW_PRIORITY 58 objectlock
This shows that the initial blocking lock is blocked, and is waiting at low priority.
So if either of these wait types show up during your regular wait statistics analysis, now you know what’s causing them.