Решения за предизвикателство за генератор на числови серии – част 3

Разчитайки на логиката за елиминиране на колони, ако трябва да върнете числови серии, започващи с 1, вие заявявате колона rn, което е по-евтино от заявката n. Ако имате нужда от серия от числа, започваща със стойност, различна от 1, вие заявявате n и заплащате допълнителната цена. Ако имате нужда от резултата, подреден по колоната с числа, с константи като входни данни, можете да използвате ORDER BY rn или ORDER BY n. Но с неконстанти като входни данни, вие искате да сте сигурни, че използвате ORDER BY rn. Може да е добра идея винаги да се придържате към използването на ORDER BY rn, когато се нуждаете от поръчания резултат, за да бъде сигурен.

Идеята за елиминиране на хоризонтални единици е подобна на идеята за елиминиране на вертикални единици, само че се прилага за набори от редове вместо набори от колони. Всъщност Джо Оббиш разчита на тази идея в своята функция dbo.GetNumsObbish (от част 2) и ние ще я направим още една стъпка. В своето решение Джо обединява множество заявки, представляващи несвързани поддиапазони от числа, като използва филтър в клаузата WHERE на всяка заявка, за да определи приложимостта на поддиапазон. Когато извиквате функцията и предавате постоянни входове, представляващи ограничителите на желания от вас диапазон, SQL Server елиминира неприложимите заявки по време на компилиране, така че планът дори не ги отразява.

Хоризонтално елиминиране на единици, време за компилиране спрямо време за изпълнение

Може би би било добра идея да започнем с демонстриране на концепцията за хоризонтално елиминиране на единици в по-общ случай и също така да обсъдим важно разграничение между елиминирането по време на компилиране и елиминиране по време на изпълнение. След това можем да обсъдим как да приложим идеята към нашето предизвикателство за серия от числа.

Ще използвам три таблици, наречени dbo.T1, dbo.T2 и dbo.T3 в моя пример. Използвайте следния DDL и DML код, за да създадете и попълните тези таблици:

DROP TABLE IF EXISTS dbo.T1, dbo.T2, dbo.T3;
GO
 
CREATE TABLE dbo.T1(col1 INT); INSERT INTO dbo.T1(col1) VALUES(1);
CREATE TABLE dbo.T2(col1 INT); INSERT INTO dbo.T2(col1) VALUES(2);
CREATE TABLE dbo.T3(col1 INT); INSERT INTO dbo.T3(col1) VALUES(3);

Да предположим, че искате да внедрите вграден TVF, наречен dbo.OneTable, който приема едно от горните три имена на таблици като вход и връща данните от исканата таблица. Въз основа на концепцията за хоризонтално елиминиране на единици, можете да приложите функцията така:

CREATE OR ALTER FUNCTION dbo.OneTable(@WhichTable AS NVARCHAR(257))
  RETURNS TABLE
AS
RETURN
  SELECT col1 FROM dbo.T1 WHERE @WhichTable = N'dbo.T1'
  UNION ALL
  SELECT col1 FROM dbo.T2 WHERE @WhichTable = N'dbo.T2'
  UNION ALL
  SELECT col1 FROM dbo.T3 WHERE @WhichTable = N'dbo.T3';
GO

Не забравяйте, че вграденият TVF прилага вграждане на параметри. Това означава, че когато подадете константа като N'dbo.T2' като вход, процесът на вграждане замества всички препратки към @WhichTable с константата преди оптимизация . След това процесът на елиминиране може да премахне препратките към T1 и T3 от първоначалното дърво на заявката и по този начин оптимизацията на заявката води до план, който препраща само към T2. Нека тестваме тази идея със следната заявка:

SELECT * FROM dbo.OneTable(N'dbo.T2');

Планът за тази заявка е показан на фигура 1.

Фигура 1:План за dbo.OneTable с постоянно въвеждане

Както можете да видите, в плана се появява само таблица T2.

Нещата са малко по-трудни, когато подавате неконстанта като вход. Това може да се случи при използване на променлива, параметър на процедура или предаване на колона чрез APPLY. Входната стойност е или неизвестна по време на компилиране, или трябва да се вземе предвид потенциалът за повторно използване на параметризиран план.

Оптимизаторът не може да премахне нито една от таблиците от плана, но все пак има трик. Той може да използва оператори за стартиране на филтър над поддърветата, които имат достъп до таблиците, и да изпълнява само съответното поддърво въз основа на стойността по време на изпълнение на @WhichTable. Използвайте следния код, за да тествате тази стратегия:

DECLARE @T AS NVARCHAR(257) = N'dbo.T2';
 
SELECT * FROM dbo.OneTable(@T);

Планът за това изпълнение е показан на Фигура 2:

Фигура 2:План за dbo.OneTable с непостоянен вход

Plan Explorer прави чудесно очевидно да се види, че е изпълнено само приложимото поддърво (Изпълнения =1) и оцветява поддърветата, които не са били изпълнени (Изпълнения =0). Също така, STATISTICS IO показва I/O информация само за таблицата, до която е бил достъпен:

Прилагане на логиката за елиминиране на хоризонтални единици към предизвикателството на серия от числа

Както споменахме, можете да приложите концепцията за хоризонтално елиминиране на единици, като модифицирате някое от по-ранните решения, които в момента използват логика за вертикално елиминиране. Ще използвам функцията dbo.GetNumsAlanCharlieItzikBatch като отправна точка за моя пример.

Припомнете си, че Джо Оббиш използва елиминиране на хоризонтални единици, за да извлече съответните непреходни поддиапазони на числовите серии. Ще използваме концепцията, за да разделим хоризонтално по-евтиното изчисление (rn), където @low =1 от по-скъпото изчисление (n), където @low <> 1.

Докато сме на това, можем да експериментираме, като добавим идеята на Джеф Модън в неговата функция fnTally, където той използва ред за наблюдение със стойност 0 за случаите, когато диапазонът започва с @low =0.

Така че имаме четири хоризонтални единици:

• Сентинен ред с 0, където @low =0, с n =0
• TOP (@high) редове, където @low =0, с евтин n =rownum и op =@high – rownum
• TOP (@high) редове, където @low =1, с евтин n =rownum и op =@high + 1 – rownum
• TOP(@high – @low + 1) редове, където @low <> 0 И @low <> 1, с по-скъпо n =@low – 1 + rownum и op =@high + 1 – rownum

Това решение съчетава идеи от Алън, Чарли, Джо, Джеф и мен, така че ще наречем пакетната версия на функцията dbo.GetNumsAlanCharlieJoeJeffItzikBatch.

Първо, не забравяйте да се уверите, че все още имате фиктивната таблица dbo.BatchMe, за да получите пакетна обработка в нашето решение, или използвайте следния код, ако не го направите:

DROP TABLE IF EXISTS dbo.BatchMe;
GO
 
CREATE TABLE dbo.BatchMe(col1 INT NOT NULL, INDEX idx_cs CLUSTERED COLUMNSTORE);

Ето кода с дефиницията на функцията dbo.GetNumsAlanCharlieJoeJeffItzikBatch:

CREATE OR ALTER FUNCTION dbo.GetNumsAlanCharlieJoeJeffItzikBatch(@low AS BIGINT = 1, @high AS BIGINT)
  RETURNS TABLE
AS
RETURN
  WITH
    L0 AS ( SELECT 1 AS c
            FROM (VALUES(1),(1),(1),(1),(1),(1),(1),(1),
                        (1),(1),(1),(1),(1),(1),(1),(1)) AS D(c) ),
    L1 AS ( SELECT 1 AS c FROM L0 AS A CROSS JOIN L0 AS B ),
    L2 AS ( SELECT 1 AS c FROM L1 AS A CROSS JOIN L1 AS B ),
    L3 AS ( SELECT 1 AS c FROM L2 AS A CROSS JOIN L2 AS B ),
    Nums AS ( SELECT ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) AS rownum
              FROM L3 )
  SELECT @low AS n, @high AS op WHERE @low = 0 AND @high > @low
  UNION ALL
  SELECT TOP(@high)
     rownum AS n,
     @high - rownum AS op
  FROM Nums LEFT OUTER JOIN dbo.BatchMe ON 1 = 0
  WHERE @low = 0
  ORDER BY rownum
  UNION ALL
  SELECT TOP(@high)
     rownum AS n,
     @high + 1 - rownum AS op
  FROM Nums LEFT OUTER JOIN dbo.BatchMe ON 1 = 0
  WHERE @low = 1
  ORDER BY rownum
  UNION ALL
  SELECT TOP(@high - @low + 1)
     @low - 1 + rownum AS n,
     @high + 1 - rownum AS op
  FROM Nums LEFT OUTER JOIN dbo.BatchMe ON 1 = 0
  WHERE @low <> 0 AND @low <> 1
  ORDER BY rownum;
GO

Важно:Концепцията за хоризонтално елиминиране на единици несъмнено е по-сложна за изпълнение от вертикалната, така че защо да се притеснявате? Защото премахва отговорността за избор на правилната колона от потребителя. Потребителят трябва да се тревожи само за запитване на колона, наречена n, вместо да помни да използва rn, когато диапазонът започва с 1, и n в противен случай.

Нека започнем с тестване на решението с постоянни входове 1 и 100 000 000, като поискаме резултатът да бъде подреден:

DECLARE @n AS BIGINT;
 
SELECT @n = n FROM dbo.GetNumsAlanCharlieJoeJeffItzikBatch(1, 100000000) ORDER BY n OPTION(MAXDOP 1);

Планът за това изпълнение е показан на Фигура 3.

Фигура 3:План за dbo.GetNumsAlanCharlieJoeJeffItzik>01, 01, 10

DECLARE @n AS BIGINT;
 
SELECT @n = n FROM dbo.GetNumsAlanCharlieJoeJeffItzikBatch(0, 99999999) ORDER BY n OPTION(MAXDOP 1);

DECLARE @n AS BIGINT;
 
SELECT @n = n FROM dbo.GetNumsAlanCharlieJoeJeffItzikBatch(2, 100000001) ORDER BY n OPTION(MAXDOP 1);

CREATE OR ALTER FUNCTION dbo.GetNumsAlanCharlieJoeItzikBatch(@low AS BIGINT = 1, @high AS BIGINT)
  RETURNS TABLE
AS
RETURN
  WITH
    L0 AS ( SELECT 1 AS c
            FROM (VALUES(1),(1),(1),(1),(1),(1),(1),(1),
                        (1),(1),(1),(1),(1),(1),(1),(1)) AS D(c) ),
    L1 AS ( SELECT 1 AS c FROM L0 AS A CROSS JOIN L0 AS B ),
    L2 AS ( SELECT 1 AS c FROM L1 AS A CROSS JOIN L1 AS B ),
    L3 AS ( SELECT 1 AS c FROM L2 AS A CROSS JOIN L2 AS B ),
    Nums AS ( SELECT ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) AS rownum
              FROM L3 )
  SELECT TOP(@high)
     rownum AS n,
     @high + 1 - rownum AS op
  FROM Nums LEFT OUTER JOIN dbo.BatchMe ON 1 = 0
  WHERE @low = 1
  ORDER BY rownum
  UNION ALL
  SELECT TOP(@high - @low + 1)
     @low - 1 + rownum AS n,
     @high + 1 - rownum AS op
  FROM Nums LEFT OUTER JOIN dbo.BatchMe ON 1 = 0
  WHERE @low <> 1
  ORDER BY rownum;
GO

DECLARE @n AS BIGINT;
 
SELECT @n = n FROM dbo.GetNumsAlanCharlieJoeItzikBatch(1, 100000000) ORDER BY n OPTION(MAXDOP 1);

DECLARE @n AS BIGINT;
 
SELECT @n = n FROM dbo.GetNumsAlanCharlieJoeItzikBatch(0, 99999999) ORDER BY n OPTION(MAXDOP 1);

DECLARE @n AS BIGINT;
 
SELECT @n = n FROM dbo.GetNumsAlanCharlieJoeItzikBatch(2, 100000001) ORDER BY n OPTION(MAXDOP 1);

DECLARE @mylow AS BIGINT = 1, @myhigh AS BIGINT = 100000000;
 
DECLARE @n AS BIGINT;
 
SELECT @n = rn FROM dbo.GetNumsAlanCharlieItzikBatch(@mylow, @myhigh) ORDER BY rn OPTION(MAXDOP 1);

DECLARE @mylow AS BIGINT = 1, @myhigh AS BIGINT = 100000000;
 
DECLARE @n AS BIGINT;
 
SELECT @n = n FROM dbo.GetNumsAlanCharlieItzikBatch(@mylow, @myhigh) ORDER BY n OPTION(MAXDOP 1);

DECLARE @mylow AS BIGINT = 1, @myhigh AS BIGINT = 100000000;
 
DECLARE @n AS BIGINT;
 
SELECT @n = n FROM dbo.GetNumsAlanCharlieItzikBatch(@mylow, @myhigh) ORDER BY rn OPTION(MAXDOP 1);

DECLARE @mylow AS BIGINT = 1, @myhigh AS BIGINT = 10;
 
DECLARE @n AS BIGINT;
 
SELECT @n = n FROM dbo.GetNumsAlanCharlieJoeItzikBatch(@mylow, @myhigh) ORDER BY n OPTION(MAXDOP 1);

CREATE OR ALTER FUNCTION dbo.GetNumsAlanCharlieJoeItzikBatch(@low AS BIGINT = 1, @high AS BIGINT)
  RETURNS TABLE
AS
RETURN
  WITH
    L0 AS ( SELECT 1 AS c
            FROM (VALUES(1),(1),(1),(1),(1),(1),(1),(1),
                        (1),(1),(1),(1),(1),(1),(1),(1)) AS D(c) ),
    L1 AS ( SELECT 1 AS c FROM L0 AS A CROSS JOIN L0 AS B ),
    L2 AS ( SELECT 1 AS c FROM L1 AS A CROSS JOIN L1 AS B ),
    L3 AS ( SELECT 1 AS c FROM L2 AS A CROSS JOIN L2 AS B ),
    Nums AS ( SELECT ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) AS rownum
              FROM L3 )
  SELECT *
  FROM ( SELECT TOP(@high)
            rownum AS n,
            @high + 1 - rownum AS op
         FROM Nums LEFT OUTER JOIN dbo.BatchMe ON 1 = 0
         ORDER BY rownum ) AS D1
  WHERE @low = 1
  UNION ALL
  SELECT *
  FROM ( SELECT TOP(@high - @low + 1)
            @low - 1 + rownum AS n,
            @high + 1 - rownum AS op
         FROM Nums LEFT OUTER JOIN dbo.BatchMe ON 1 = 0
         ORDER BY rownum ) AS D2
  WHERE @low <> 1;
GO

DECLARE @mylow AS BIGINT = 1, @myhigh AS BIGINT = 10;
 
DECLARE @n AS BIGINT;
 
SELECT @n = n FROM dbo.GetNumsAlanCharlieJoeItzikBatch(@mylow, @myhigh) ORDER BY n OPTION(MAXDOP 1);

DECLARE @mylow AS BIGINT = 1, @myhigh AS BIGINT = 100000000;
 
DECLARE @n AS BIGINT;
 
SELECT @n = n FROM dbo.GetNumsAlanCharlieJoeItzikBatch(@mylow, @myhigh) ORDER BY n OPTION(MAXDOP 1);