Řešení problémů generátoru číselných řad – 3. část

Pokud se spoléháte na logiku eliminace sloupců, pokud potřebujete vrátit číselnou řadu začínající 1, dotazujete se na sloupec rn, což je levnější než dotazování na n. Pokud potřebujete číselnou řadu začínající jinou hodnotou než 1, zeptáte se n a zaplatíte příplatek. Pokud potřebujete výsledek seřadit podle číselného sloupce, s konstantami jako vstupy, můžete použít buď ORDER BY rn nebo ORDER BY n. Ale s nekonstantami jako vstupy se chcete ujistit, že používáte ORDER BY rn. Možná by bylo dobré se vždy držet používání ORDER BY rn, když potřebujete, aby byl výsledek objednán na bezpečné straně.

Myšlenka eliminace horizontální jednotky je podobná myšlence eliminace vertikální jednotky, pouze se vztahuje na sady řádků namísto sad sloupců. Ve skutečnosti na tuto myšlenku spoléhal Joe Obbish ve své funkci dbo.GetNumsObbish (z části 2) a my ji posuneme o krok dále. Ve svém řešení Joe sjednotil více dotazů představujících nesouvislé podrozsahy čísel pomocí filtru v klauzuli WHERE každého dotazu, aby definoval použitelnost podrozsahu. Když zavoláte funkci a předáte konstantní vstupy představující oddělovače požadovaného rozsahu, SQL Server eliminuje nepoužitelné dotazy v době kompilace, takže je plán ani neodráží.

Vodorovná eliminace jednotek, doba kompilace versus doba běhu

Možná by bylo dobré začít demonstrací konceptu eliminace horizontálních jednotek na obecnějším případě a také diskutovat o důležitém rozdílu mezi eliminací v době kompilace a eliminací za běhu. Pak můžeme diskutovat o tom, jak tuto myšlenku aplikovat na naši výzvu číselné řady.

V mém příkladu použiji tři tabulky nazvané dbo.T1, dbo.T2 a dbo.T3. K vytvoření a naplnění těchto tabulek použijte následující kód DDL a 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);

Předpokládejme, že chcete implementovat inline TVF s názvem dbo.OneTable, která přijímá jeden ze tří výše uvedených názvů tabulek jako vstup a vrací data z požadované tabulky. Na základě konceptu horizontální eliminace jednotek můžete funkci implementovat takto:

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

Pamatujte, že inline TVF používá vkládání parametrů. To znamená, že když předáte jako vstup konstantu, jako je N'dbo.T2', proces vkládání nahradí všechny odkazy na @WhichTable konstantou před optimalizací . Proces eliminace pak může odstranit odkazy na T1 a T3 z počátečního stromu dotazů, a optimalizace dotazu tak vede k plánu, který odkazuje pouze na T2. Pojďme tento nápad otestovat pomocí následujícího dotazu:

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

Plán pro tento dotaz je znázorněn na obrázku 1.

Obrázek 1:Plán pro dbo.OneTable s konstantním vstupem

Jak vidíte, v plánu se objevuje pouze tabulka T2.

Věci jsou trochu složitější, když jako vstup předáte nekonstantu. K tomu může dojít při použití proměnné, parametru procedury nebo předání sloupce přes APPLY. Vstupní hodnota je buď neznámá v době kompilace, nebo je třeba vzít v úvahu parametrizovaný potenciál opětovného použití plánu.

Optimalizátor nemůže odstranit žádnou z tabulek z plánu, ale stále má trik. Může používat spouštěcí operátory filtru nad podstromy, které přistupují k tabulkám, a spouštět pouze relevantní podstrom na základě runtime hodnoty @WhichTable. K otestování této strategie použijte následující kód:

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

Plán tohoto provedení je znázorněn na obrázku 2:

Obrázek 2:Plán pro dbo.OneTable s nekonstantním vstupem

V Průzkumníku plánu je úžasně zřejmé, že byl proveden pouze příslušný podstrom (Provedení =1), a podstromy, které nebyly provedeny, zašedí (Provedení =0). STATISTICS IO také zobrazuje I/O informace pouze pro tabulku, ke které byl přístup:

Aplikace horizontální logiky eliminace jednotek na výzvu číselné řady

Jak již bylo zmíněno, koncept horizontální eliminace jednotek můžete použít úpravou kteréhokoli z dřívějších řešení, která v současnosti používají logiku vertikální eliminace. Jako výchozí bod pro svůj příklad použiji funkci dbo.GetNumsAlanCharlieItzikBatch.

Připomeňme, že Joe Obbish použil horizontální eliminaci jednotek k extrakci příslušných disjunktních podrozsahů číselné řady. Tento koncept použijeme k horizontálnímu oddělení levnějšího výpočtu (rn), kde @nízká =1, od dražšího výpočtu (n), kde @nízká <> 1.

Když už jsme u toho, můžeme experimentovat přidáním nápadu Jeffa Modena do jeho funkce fnTally, kde používá řádek sentinelu s hodnotou 0 pro případy, kdy rozsah začíná @low =0.

Máme tedy čtyři horizontální jednotky:

• Řádek Sentinel s 0, kde @nízká =0, s n =0
• NEJLEPŠÍ (@vysoké) řádky, kde @nízká =0, s levným n =rownum a op =@high – rownum
• TOP (@high) řádky, kde @nízká =1, s levným n =rownum a op =@high + 1 – rownum
• NEJLEPŠÍ (@vysoké – @nízké + 1) řádky, kde @nízká <> 0 A @nízká <> 1, přičemž dražší n =@nízká – 1 + rownum a op =@vysoká + 1 – rownum

Toto řešení kombinuje nápady od Alana, Charlieho, Joea, Jeffa a mě, takže budeme volat verzi funkce v dávkovém režimu dbo.GetNumsAlanCharlieJoeJeffItzikBatch.

Nejprve se nezapomeňte ujistit, že máte stále přítomnou fiktivní tabulku dbo.BatchMe, abyste získali dávkové zpracování v našem řešení, nebo použijte následující kód, pokud nemáte:

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

Zde je kód s definicí funkce 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

Důležité:Koncept eliminace horizontálních jednotek je nepochybně složitější na implementaci než koncept vertikální, tak proč se obtěžovat? Protože to uživatele zbavuje odpovědnosti za výběr správného sloupce. Uživatel se musí starat pouze o dotazování na sloupec s názvem n, na rozdíl od toho, aby si pamatoval použití rn, když rozsah začíná 1, a jinak n.

Začněme testováním řešení s konstantními vstupy 1 a 100 000 000 a požádáme o objednání výsledku:

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

Plán tohoto provedení je znázorněn na obrázku 3.

Obrázek 3:Plán pro dbo.GetNumsAlanCharlieJoeJeffItzikBatch(1),

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);