Let’s demonstrate it.

We will create two tables and fill in some data. These tables are absolutely the same including the IDENTITY specification. The only difference is their name.

DROP TABLE IF EXISTS [dbo].[To_Be_Deleted]
DROP TABLE IF EXISTS [dbo].[To_Be_Truncated]
GO

CREATE TABLE [dbo].[To_Be_Deleted] (
	Id INT IDENTITY(1,1) NOT NULL PRIMARY KEY
)
GO
CREATE TABLE [dbo].[To_Be_Truncated] (
	Id INT IDENTITY(1,1) NOT NULL PRIMARY KEY
)
GO

INSERT INTO [dbo].[To_Be_Deleted] DEFAULT VALUES
INSERT INTO [dbo].[To_Be_Deleted] DEFAULT VALUES
INSERT INTO [dbo].[To_Be_Deleted] DEFAULT VALUES
GO
INSERT INTO [dbo].[To_Be_Truncated] DEFAULT VALUES
INSERT INTO [dbo].[To_Be_Truncated] DEFAULT VALUES
INSERT INTO [dbo].[To_Be_Truncated] DEFAULT VALUES
GO

SELECT 'To_Be_Deleted', * FROM [dbo].[To_Be_Deleted] UNION ALL
SELECT 'To_Be_Truncated', * FROM [dbo].[To_Be_Truncated]
GO

We will also check the current identity value after data is inserted. It’s the same.

SELECT 'To_Be_Deleted',	'IDENT_CURRENT', IDENT_CURRENT('[dbo].[To_Be_Deleted]') UNION ALL
SELECT 'To_Be_Truncated', 'IDENT_CURRENT', IDENT_CURRENT('[dbo].[To_Be_Truncated]')
GO

Now is time to remove data from our tables. There is a difference coming: We will empty the first table via the DELETE command and the second one will be emptied using the TRUNCATE command.

DELETE FROM [dbo].[To_Be_Deleted]
TRUNCATE TABLE [dbo].[To_Be_Truncated]
GO

DBCC CHECKIDENT('[dbo].[To_Be_Deleted]', RESEED, 1)
DBCC CHECKIDENT('[dbo].[To_Be_Truncated]', RESEED, 1)
GO

SELECT 'To_Be_Deleted',	'IDENT_CURRENT', IDENT_CURRENT('[dbo].[To_Be_Deleted]') UNION ALL
SELECT 'To_Be_Truncated', 'IDENT_CURRENT', IDENT_CURRENT('[dbo].[To_Be_Truncated]')
GO

We will check the current identity value now: It’s the same.

Next, we will again insert some data into our tables. Exactly as before.

INSERT INTO [dbo].[To_Be_Deleted] DEFAULT VALUES
INSERT INTO [dbo].[To_Be_Deleted] DEFAULT VALUES
INSERT INTO [dbo].[To_Be_Deleted] DEFAULT VALUES
GO

INSERT INTO [dbo].[To_Be_Truncated] DEFAULT VALUES
INSERT INTO [dbo].[To_Be_Truncated] DEFAULT VALUES
INSERT INTO [dbo].[To_Be_Truncated] DEFAULT VALUES
GO

SELECT 'To_Be_Deleted', * FROM [dbo].[To_Be_Deleted] UNION ALL
SELECT 'To_Be_Truncated', * FROM [dbo].[To_Be_Truncated]
GO

SELECT 'To_Be_Deleted', 'IDENT_CURRENT', IDENT_CURRENT('[dbo].[To_Be_Deleted]') UNION ALL
SELECT 'To_Be_Truncated', 'IDENT_CURRENT', IDENT_CURRENT('[dbo].[To_Be_Truncated]')
GO

If we will check data in both tables, there is the surprise immediately visible:

The table which was emptied using the DELETE command has the first identity value 2 whereas the second table emptied using the TRUNCATE command has the first identity value 1!

This difference is also approved via the IDENT_CURRENT() function.

I know that this behavior isn’t too intuitive at first look. But what is positive (only:) about it is that it’s properly documented at the right place in the DBCC CHECKIDENT() command description:

The current identity value is set to the new_reseed_value. If no rows have been inserted into the table since the table was created, or if all rows have been removed by using the TRUNCATE TABLE statement, the first row inserted after you run DBCC CHECKIDENT uses new_reseed_value as the identity. If rows are present in the table, or if all rows have been removed by using the DELETE statement, the next row inserted uses new_reseed_value + the current increment value.

To be honest, seniors should know, for sure. But juniors are spending hours investigating this based on my experience. There is a good comparison of DELETE vs TRUNCATE on sqlhack.com, but still, the RESEED issue isn’t clearly explained there.

1. level kompatibily databáze musí být nastaven na 130 a
2. je nutné použít TABLOCK hint pro cílovou tabulku.

Zda byl skutečně použit paralelní operátor zjistíme jednoduše z exekučního plánu.

Bohužel jako obvykle existuje několik výrazných omezení, která nám prvotní radost mohou zkazit. Paralelní exekuce se nedočkáme pokud:

• při insertu do row store cílová tabulka obsahuje clusterovaný nebo alespoň jeden neclusterovaný index
• tabulka má IDENTITY sloupec nebo využívá sekvence

Zvláštní pravidla platí v případě, využíváme-li jako cíl (INSERT) nebo zdroj (SELECT) column store úložiště.

Detaily:

• https://blogs.msdn.microsoft.com/sqlcat/2016/07/06/sqlsweet16-episode-3-parallel-insert-select/
• https://blogs.msdn.microsoft.com/sqlcat/2016/07/21/real-world-parallel-insert-what-else-you-need-to-know/

Poznámka:

Nezaměňovat INSERT…INTO se SELECT…INTO, který podporuje paralelní exekuční plány již od SQL Serveru 2014 (compatibility 110 a vyšší).

CREATE TABLE [dbo].[SampleTable]
	([ID] INT, 
	 [Value] NVARCHAR(100))

INSERT INTO [dbo].[Sampletable]
	( ..[Happy]..[New]...[ID], 
	  Another.[Ignored]..Alias.Value )
	SELECT  1, 'Value1'
GO

How that works? Column aliases are ignored in INSERT INTO command so that we can place any funny string there. I think that an error should be raised rather because this lazy behavior can lead to unwanted confusion.

First of all, we will try to check if this limit is really presented regarding the documentation. We will create TestTable and then dynamically create an insert statement with 1005 rows constructed using the VALUES() row constructor. Our final statement generated is visible below in the picture.

CREATE TABLE TestTable ( Value NVARCHAR(100))
GO

DECLARE @Numbers TABLE (ID INT NOT NULL PRIMARY KEY)

INSERT INTO @Numbers
	SELECT TOP(1005) ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) FROM [master].[dbo].[spt_values]

DECLARE @Stmt NVARCHAR(MAX) = ''

SELECT @Stmt = @Stmt + '(''' + CAST(ID AS VARCHAR(10)) + '''),'
FROM @Numbers

SET @Stmt = 'INSERT INTO TestTable VALUES ' + LEFT(@Stmt, LEN(@Stmt)-1) + ''

PRINT @Stmt

EXECUTE(@Stmt)
GO

After we have executed our @Stmt, the Messages window in Management Studio shows this output:

As expected, error 10378 was generated clearly declaring, that we simply can´t ignore the 1000 rows limit for the row constructor.

Luckily there is a simple solution how to skip this limitation: The only thing we need to do is to move the row  constructor from direct INSERT to derived table as is visible on the marked line in this script:

DECLARE @Numbers TABLE (ID INT NOT NULL PRIMARY KEY)

INSERT INTO @Numbers
	SELECT TOP(1005) ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) FROM [master].[dbo].[spt_values]

DECLARE @Stmt NVARCHAR(MAX) = ''

SELECT @Stmt = @Stmt + '(''' + CAST(ID AS VARCHAR(10)) + '''),'
FROM @Numbers

SET @Stmt = 'INSERT INTO TestTable SELECT * FROM (VALUES ' + LEFT(@Stmt, LEN(@Stmt)-1) + ') a (Col1)'

PRINT @Stmt

EXECUTE(@Stmt)
GO

Rows in TestTable aren´t inserted directly, but with help of FROM(derived table) trick. There is the final result message:

Table Row Value constructor is really powerful construct in T-SQL and in the next article we will show other fun we can have with it.

EXEC sp_MSForEachTable 'ALTER TABLE ? NOCHECK CONSTRAINT ALL'
GO

EXEC sp_MSForEachTable '
    IF OBJECTPROPERTY(object_id(''?''), ''TableHasForeignRef'') = 1
        DELETE FROM ?
    ELSE
        TRUNCATE TABLE ?'
GO

EXEC sp_MSForEachTable 'ALTER TABLE ? CHECK CONSTRAINT ALL'
GO

EXEC sp_MSForEachTable 'SELECT * FROM ?'
GO

Skript si umí poradit s mazáním i v případě, že databáze obsahuje cizí klíče, které za normálních okolností brání smazání dat z tabulky, pokud jsou použita jako cizí klíč v jiné tabulce. V prvním kroku se proto volá sp_MSForEachTable s ALTER TABLE NO CHECK CONSTRAINT ALL, který zakáže všechna omezení na tabulkou, pro kterou je volán. Jméno tabulky do skriptu doplňuje automaticky právě sp_MSForEachTable, a to do místa, kde je vložen ?. Po smazání se obdobným způsobem omezení opět povolí.

Samotné mazání lze provést dvěma způsoby: DELETE nebo TRUNCATE. Pro TRUNCATE platí omezení, že tento příkaz nelze použít pro tabulky, které mají cizí klíče, a to ani v případě, že jsme cizí klíče zakázali, protože jejich definice stále zůstává uložena v metadatech. TRUNCATE je samozřejmě výrazně rychlejší a byla by škoda si vystačit jen s DELETE. Proto musíme zjistit, jestli právě mazaná tabulka cizí klíče obsahuje či nikoliv a podle toho rozhodnout, zda se použije DELETE nebo TRUNCATE. Pomocí OBJECTPROPERTY() zjistíme nastavení vlastnosti  TableHasForeignRef, a pokud je 1, zavoláme DELETE, pokud 0, pak TRUNCATE.

V posledním kroku použijeme sp_MSForEachTable ještě jednou pro kontrolu, že v žádné tabulce nezůstaly nějaké řádky.

Zopakujme si ale nejprve základní fakta o použití OUTPUT:

• vrací data pro každý řádek, který byl ovlivněn některým z příkazů INSERT, UPDATE, DELETE nebo MERGE (DML operace)
• výstup je možné vrátit rovnou jako data klientovi nebo uložit do tabulky, temporární tabulky nebo table variable
• OUTPUT je možné použít i jako vnořenou část všech čtyř DML příkazů
• s výstupními daty lze přímo pracovat pomocí nejrůznějších výrazů

Příklady jsou zpracovány co nejjednodušší formou pro rychlé použíti metodou copy & paste.

INSERT:

CREATE TABLE dbo.SampleTable
(Id INT IDENTITY(1,1) PRIMARY KEY,
 Name VARCHAR(50)
)
GO

-- OUTPUT from INSERT into @TableVariable

DECLARE @InsertedRows TABLE (RowId INT)

INSERT INTO dbo.SampleTable
    OUTPUT INSERTED.Id
        INTO @InsertedRows
VALUES
    ('Name1'), 
    ('Name2'),
    ('Name3'),
    ('Name4'),
    ('Name5')

SELECT * FROM @InsertedRows
GO


-- OUTPUT from INSERT into ##TemporaryTable

CREATE TABLE ##tmp (RowId INT)

INSERT INTO dbo.SampleTable
    OUTPUT INSERTED.Id
        INTO ##tmp
VALUES
    ('Name1'), 
    ('Name2'),
    ('Name3'),
    ('Name4'),
    ('Name5')

SELECT * FROM ##tmp
GO

-- OUTPUT from INSERT into UserTable

CREATE TABLE UserTable (RowId INT)
GO

INSERT INTO dbo.SampleTable
    OUTPUT INSERTED.Id
        INTO UserTable
VALUES
    ('Name1'), 
    ('Name2'),
    ('Name3'),
    ('Name4'),
    ('Name5')

SELECT * FROM UserTable
GO

-- OUTPUT from INSERT with *

DECLARE @InsertedRows TABLE (RowId INT, Name VARCHAR(50))

INSERT INTO dbo.SampleTable
    OUTPUT INSERTED.*
        INTO @InsertedRows
VALUES
    ('Name1'), 
    ('Name2'),
    ('Name3'),
    ('Name4'),
    ('Name5')

SELECT * FROM @InsertedRows
GO

-- OUTPUT from multiple INSERTs

DECLARE @InsertedRows TABLE (RowId INT, Name VARCHAR(50))

INSERT INTO dbo.SampleTable
    OUTPUT INSERTED.*
        INTO @InsertedRows
VALUES
    ('Name1')

INSERT INTO dbo.SampleTable
    OUTPUT INSERTED.*
        INTO @InsertedRows
VALUES
    ('Name2')

SELECT * FROM @InsertedRows
GO

-- OUTPUT from INSERT from SELECT

DECLARE @InsertedRows TABLE (RowId INT, Name VARCHAR(50))

INSERT INTO dbo.SampleTable
    OUTPUT INSERTED.*
        INTO @InsertedRows
SELECT 'Name1' 

SELECT * FROM @InsertedRows
GO

-- OUTPUT from INSERT with column names on output table

DECLARE @InsertedRows TABLE (RowId INT, Name VARCHAR(50))

INSERT INTO dbo.SampleTable
    OUTPUT INSERTED.Id
        INTO @InsertedRows (RowId)
SELECT 'Name1' 

SELECT * FROM @InsertedRows
GO

-- OUTPUT from INSERT with SELECT output values only
INSERT INTO dbo.SampleTable
    OUTPUT INSERTED.*
VALUES
    ('Name1'), 
    ('Name2'),
    ('Name3'),
    ('Name4'),
    ('Name5')

UPDATE:

CREATE TABLE dbo.SampleTable
(Id INT IDENTITY(1,1) PRIMARY KEY,
 Name VARCHAR(50)
)
GO

INSERT INTO dbo.SampleTable
VALUES
    ('Name1'), 
    ('Name2'),
    ('Name3'),
    ('Name4'),
    ('Name5')

SELECT * FROM dbo.SampleTable
GO

-- OUTPUT from UPDATE with SELECT output values only
UPDATE dbo.SampleTable
    SET Name = 'Name3UPDATED'
OUTPUT 
    INSERTED.Id,
    DELETED.Id,
    INSERTED.Name,
    DELETED.Name
WHERE Id = 3
GO

-- OUTPUT from UPDATE into @TableVariable
DECLARE @Updated TABLE (Id INT,
                        NewValue VARCHAR(50),
                        OldValue VARCHAR(50))

UPDATE dbo.SampleTable
    SET Name = 'Name4UPDATED'
OUTPUT 
    INSERTED.Id,
    INSERTED.Name,
    DELETED.Name
    INTO @Updated
WHERE Id = 4

SELECT * FROM @Updated
GO

DELETE:

CREATE TABLE dbo.SampleTable
(Id INT IDENTITY(1,1) PRIMARY KEY,
 Name VARCHAR(50)
)
GO

INSERT INTO dbo.SampleTable
VALUES
    ('Name1'), 
    ('Name2'),
    ('Name3'),
    ('Name4'),
    ('Name5')
GO

-- OUTPUT from DELETE with SELECT output values only
DELETE FROM dbo.SampleTable
    OUTPUT DELETED.Id,
           DELETED.Name
WHERE Id = 3
GO

-- OUTPUT from DELETE into @TableVariable
DECLARE @Deleted TABLE (Id INT)

DELETE FROM dbo.SampleTable
    OUTPUT DELETED.Id
        INTO @Deleted
WHERE Id = 5

SELECT * FROM @Deleted
GO

Kouzlo je v tom, že i UPDATE můžeme udělat proti aliasu tabulky, jak ukazuje následující příklad:

-- create sample table
CREATE TABLE dbo.SampleTable
(
    Id INT IDENTITY(1,1) NOT NULL,
    StrValue VARCHAR(10)
)
GO

-- insert sample data
INSERT dbo.SampleTable VALUES ('Value1')
INSERT dbo.SampleTable VALUES ('Value2')
INSERT dbo.SampleTable VALUES ('Value3')
GO

UPDATE STalias
    SET StrValue = 'Value1Upd' 
FROM dbo.SampleTable STalias
WHERE StrValue = 'Value1'
GO

SELECT * FROM dbo.SampleTable
GO

Vytvořili jsme si testovací tabulku a napsali proti ní UPDATE příkaz, kde jsme tabulce přiřadili alias STalias a ten odkazovali v UDPATE hlavičce. Na tom není složitého. A k čemu je to tedy dobré?

Podívejme se na následující UPDATE:

UPDATE dbo.[Employee]
	SET FirstName = 'AAA'
FROM ems.[Employee] [emp]
	INNER JOIN ems.[EmployeeStatus] [es] ON [es].[EmployeeStatus_ID] = [emp].[EmployeeStatus_ID]
WHERE emp.[EmployeeStatus_ID] = 3
GO

Napsali jsme si krásný příkaz, kterým chceme nastavit všem zaměstnancům se statusem 3 jejich [FirstName] na ‘AAA’. A co se stane po spuštění? Došlo ke změně dat. Ano, došlo. A dokonce se nastavilo [FirstName] na ‘AAA’. Ovšem nastavilo se všem zaměstnancům bez ohledu na jejich status , a to ještě v úplně jiné tabulce, která leží místo ve schématu [ems] ve schématu [dbo]. Drobné přehlédnutí a průšvih je na světě.

Jak tomu předejít? Velmi jednoduše právě pomocí aliasu tabulky a správného pořadí, v jakém budeme UPDATE sestavovat. Postupovat bychom měli takto:

1. Nejprve si napíšeme SELECT tak, abychom dostali přesně ta data, která se chystáme změnit a provedeme vizuální kontrolu, že data opravdu odpovídají naší představě:

SELECT emp.[Employee_ID], emp.[FirstName]
FROM ems.[Employee] [emp]
	INNER JOIN ems.[EmployeeStatus] [es] ON [es].[EmployeeStatus_ID] = [emp].[EmployeeStatus_ID]
WHERE es.[EmployeeStatus_ID] = 3
GO

2. Vybereme správný alias tabulky a použijeme ho v UPDATE příkazu. SELECT si zakomentujeme pro pozdější opakované spuštění:

UPDATE [emp]
	SET [emp].[FirstName] = 'AAA'
--SELECT emp.[Employee_ID], emp.[FirstName]
FROM ems.[Employee] [emp]
	INNER JOIN ems.[EmployeeStatus] [es] ON [es].[EmployeeStatus_ID] = [emp].[EmployeeStatus_ID]
WHERE es.[EmployeeStatus_ID] = 3
GO

3. Spustíme znovu označením do bloku část dotazu se SELECT příkazem a zkontrolujeme, zda data jsou opravdu změněná podle očekávání.

4. Pokud pokračujeme ve stejném okně v psaní dalších příkazů, doporučuji zakomentovat si UPDATE a odkomentovat SELECT pro případ, že bychom omylem spustili znovu celý skript poté, co jsme si správnou část zapomněli označit do bloku:

--UPDATE [emp]
--	SET [emp].[FirstName] = 'AAA'
SELECT emp.[Employee_ID], emp.[FirstName]
FROM ems.[Employee] [emp]
	INNER JOIN ems.[EmployeeStatus] [es] ON [es].[EmployeeStatus_ID] = [emp].[EmployeeStatus_ID]
WHERE es.[EmployeeStatus_ID] = 3
GO

Vše jsou to pouze triviální operace, ale osvojit si tyto 4 kroky jako povinné pro každodenní práci znamená výraznou minimalizaci rizika, že to jedno dne nedopadne dobře. Úplně stejně můžeme pochopitelně postupovat v případě DELETE příkazu.

SET IDENTITY_INSERT SampleTable ON
GO

INSERT SampleTable (RowID, Name, Value) 
    VALUES (1, 'Name1', 'Value1')
GO

SET IDENTITY_INSERT SampleTable OFF
GO

SET IDENTITY INSERT je ovšem dobrý sluha, ale zlý pán. Nesmíme totiž nikdy zapomenout, že se jedná o SET příkaz, který nastavuje vlastnosti aktuálního připojení. A platí, že v daném připojení může mít explicitní vkládání IDENTITY hodnot povolena vždy pouze jedna tabulka. Takže následující sekvence příkazů skončí s chybou:

CREATE TABLE dbo.SampleTable (
	RowID INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
	Name NVARCHAR(100),
	Value NVARCHAR(100)
)
GO

SET IDENTITY_INSERT SampleTable ON

INSERT SampleTable (RowID, Name, Value) 
    VALUES (1, 'Name1', 'Value1')

--SET IDENTITY_INSERT SampleTable OFF
GO

CREATE TABLE dbo.SampleTable2 (
	RowID INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
	Name NVARCHAR(100),
	Value NVARCHAR(100)
)
GO

SET IDENTITY_INSERT SampleTable2 ON
GO

INSERT SampleTable2 (RowID, Name, Value) 
    VALUES (10, 'Name1', 'Value1')
GO

SET IDENTITY_INSERT SampleTable2 OFF
GO

We will create a table [dbo].[SampleTable] and fill it with some dummy data first.

-- Create sample table
CREATE TABLE [dbo].[SampleTable]
(
    [Id] INT IDENTITY(1,1) PRIMARY KEY,
    [ProductName] VARCHAR(50) NOT NULL,
    [Price] MONEY NOT NULL
)
GO

-- Populate data
INSERT [dbo].[SampleTable] ([ProductName], [Price])
    SELECT 'Product1', 100 UNION ALL
    SELECT 'Product2', 200 UNION ALL
    SELECT 'Product3', 300
GO

-- Review sample data
SELECT [Id], [ProductName],	[Price] FROM dbo.[SampleTable]
GO

Table [dbo].[TrackedChanges] will be used to store changes history from DML we will run againts [dbo].[SampleTable]:

-- Create table for changes history
CREATE TABLE [dbo].[TrackedChanges]
(
    [RowId] INT,
    [OldValue] MONEY,
    [NewValue] MONEY,
    [ChangeDate] DATETIME DEFAULT (GETDATE())
)
GO

We will run the main Composable DML statement now: It’s an UPDATE statement to change Product price followed by OUTPUT clause. That all is nested in INSERT…SELECT statement with WHERE filter condition to track changes in [dbo].[TrackedChanges] table only in case when the updated [Price] is over 300.

-- Perform Composable DML
INSERT INTO [dbo].[TrackedChanges]
        ( [RowId], [OldValue], [NewValue] )
SELECT 
	[RowId], [OldValue], [NewValue]
FROM 
(
    UPDATE [dbo].[SampleTable]
        SET [Price] = [Price] * 1.5
    OUTPUT
        [INSERTED].[Id] AS [RowId],
        [DELETED].[Price] AS [OldValue],
        [INSERTED].[Price] AS [NewValue] 
) [upd] 
WHERE NewValue > 300
GO

-- Check results
SELECT [RowId], [OldValue], [NewValue],	[ChangeDate] FROM [dbo].[TrackedChanges]
GO

This query concept is mainly useful when handling SDC Type II in data warehouse scenarios.

Few limitations exist still and Composable DML is not fully done 10 years after publishing. I.e. we can’t use JOINs, TOP or GROUP BY clauses. Let’s demonstrate it on JOIN example:

INSERT INTO [dbo].[TrackedChanges]
        ( [RowId], [OldValue], [NewValue] )
SELECT 
	[RowId], [OldValue], [NewValue]
FROM 
(
    UPDATE [dbo].[SampleTable]
        SET [Price] = [Price] * 1.5
    OUTPUT
        [INSERTED].[Id] AS [RowId],
        [DELETED].[Price] AS [OldValue],
        [INSERTED].[Price] AS [NewValue] 
) [upd] 
	INNER JOIN [dbo].[SampleTable] st ON [st].[Id] = upd.Row_Id
WHERE NewValue > 300
GO

Besides these limitations, I really like it and have a lot of fun when junior developers are scratching heads what the hell is it for peace of code:)