Quando as classificações do SQL Server retrocedem?

Introdução

• Carretel de mesa
• Carretel de contagem de linhas
• Spool de índice não clusterizado
• Função com valor de tabela
• Classificar
• Consulta Remota
• Afirmar e Filtrar operadores com uma Expressão de inicialização

Ordenar retrocessos

Tipos de classificação

1. Classificação na memória (CQScanInMemSortNew ).
   • Sempre na memória; não pode derramar para o disco.
   • Usa a classificação rápida da biblioteca padrão.
   • Máximo de 500 linhas e duas páginas de 8 KB no total.
   • Todas as entradas devem ser constantes de tempo de execução. Normalmente, isso significa que toda a subárvore de classificação deve consistir em somente Verificação Constante e/ou Computar escalar operadores.
   • Somente distinguível explicitamente em planos de execução quando plano de exibição detalhado está habilitado (sinalizador de rastreamento 8666). Isso adiciona propriedades extras ao Classificar operador, um dos quais é “InMemory=[0|1]”.
2. Todas as outras classificações.

Retroceder comportamentos

• 
  Classificações na memória pode sempre retroceder quando é seguro. Se não houver parâmetros de loop correlacionados ou se os valores dos parâmetros não forem alterados desde a iteração imediatamente anterior, esse tipo de classificação pode reproduzir seus dados armazenados em vez de executar novamente os operadores abaixo dele no plano de execução.
  
• 
  Classificações fora da memória pode retroceder quando seguro, mas somente se a opção Classificar operador contém no máximo uma linha . Observe uma Classificação input pode fornecer uma linha em algumas iterações, mas não em outras. O comportamento do tempo de execução pode, portanto, ser uma mistura complexa de retrocessos e religações. Depende completamente de quantas linhas são fornecidas ao Classificar em cada iteração em tempo de execução. Geralmente, você não pode prever o que uma Classificação fará em cada iteração inspecionando o plano de execução.
  

Nota importante sobre planos de execução

Histórico e minha explicação

Demonstração 1:retrocessos imprecisos

DECLARE @T1 table (c1 integer NOT NULL INDEX i);
DECLARE @T2 table (c2 integer NOT NULL, c3 integer NOT NULL);
 
INSERT @T1
    (c1)
VALUES
    (1), (1), (1),
    (2), (2), (2),
    (3), (3), (3);
 
INSERT @T2 
    (c2, c3)
VALUES
    (1, 1),
    (1, 2),
    (2, 3),
    (2, 4),
    (3, 5),
    (3, 6);
 
SELECT
    T1.c1,
    CA.c2,
    CA.c3
FROM @T1 AS T1
CROSS APPLY
(
    SELECT TOP (1)
        T2.c2,
        T2.c3
    FROM @T2 AS T2
    WHERE 
        T2.c2 = T1.c1
    ORDER BY 
        T2.c3 DESC
) AS CA
ORDER BY T1.c1 ASC
OPTION (NO_PERFORMANCE_SPOOL);

Demonstração 2:classificar retrocessos

DECLARE @T1 table (c1 integer NOT NULL INDEX i);
DECLARE @T2 table (c2 integer NOT NULL, c3 integer NOT NULL);
 
INSERT @T1
    (c1)
VALUES
    (1), (1), (1),
    (2), (2), (2),
    (3), (3), (3);
 
-- Only one matching row per iteration now
INSERT @T2 
    (c2, c3)
VALUES
    --(1, 1),
    (1, 2),
    --(2, 3),
    (2, 4),
    --(3, 5),
    (3, 6);
 
SELECT
    T1.c1,
    CA.c2,
    CA.c3
FROM @T1 AS T1
CROSS APPLY
(
    SELECT TOP (1)
        T2.c2,
        T2.c3
    FROM @T2 AS T2
    WHERE 
        T2.c2 = T1.c1
    ORDER BY 
        T2.c3 DESC
) AS CA
ORDER BY T1.c1 ASC
OPTION (NO_PERFORMANCE_SPOOL);

Demo 3:Rebobinando nada

DECLARE @T1 table (c1 integer NOT NULL INDEX i);
DECLARE @T2 table (c2 integer NOT NULL, c3 integer NOT NULL);
 
INSERT @T1
    (c1)
VALUES
    (1), (1), (1),
    (2), (2), (2),
    (3), (3), (3);
 
-- No rows added to table @T2
 
-- No longer projecting c2
SELECT
    T1.c1,
    --CA.c2,
    CA.c3
FROM @T1 AS T1
OUTER APPLY
(
    SELECT TOP (1)
        --T2.c2,
        T2.c3
    FROM @T2 AS T2
    WHERE 
        T2.c2 = T1.c1
    ORDER BY 
        T2.c3 DESC
) AS CA
ORDER BY T1.c1 ASC
OPTION (NO_PERFORMANCE_SPOOL);

Demonstração 4:Retrocesso máximo!

DECLARE @T1 table (c1 integer NOT NULL INDEX i);
DECLARE @T2 table (c2 integer NOT NULL, c3 integer NOT NULL);
 
INSERT @T1
    (c1)
VALUES
    (1), (1), (1),
    (2), (2), (2),
    (3), (3), (3);
 
-- Still no rows in @T2
-- Column c2 is back!
SELECT
    T1.c1,
    CA.c2,
    CA.c3
FROM @T1 AS T1
OUTER APPLY
(
    SELECT TOP (1)
        T2.c2,
        T2.c3
    FROM @T2 AS T2
    WHERE 
        T2.c2 = T1.c1
    ORDER BY 
        T2.c3 DESC
) AS CA
ORDER BY T1.c1 ASC
OPTION (NO_PERFORMANCE_SPOOL);

Demonstração 5:classificação na memória

DECLARE @T table (v integer NOT NULL);
 
INSERT @T 
    (v)
VALUES 
    (1), (2), (3), 
    (4), (5), (6);
 
SELECT 
    T.v,
    OA.i 
FROM @T AS T
OUTER APPLY
(
    SELECT TOP (1) 
        X.i 
    FROM 
    (
        VALUES
            (REPLICATE('Z', 1390)),
            ('0'), ('1'), ('2'), ('3'), ('4'), 
            ('5'), ('6'), ('7'), ('8'), ('9')
    ) AS X (i)
    ORDER BY NEWID()
) AS OA
OPTION (NO_PERFORMANCE_SPOOL);

Demonstração 6:Sem classificação na memória

DECLARE @T table (v integer NOT NULL);
 
INSERT @T 
    (v)
VALUES 
    (1), (2), (3), 
    (4), (5), (6);
 
SELECT 
    T.v,
    OA.i 
FROM @T AS T
OUTER APPLY
(
    SELECT TOP (1) 
        X.i 
    FROM 
    (
        VALUES
            -- 1391 instead of 1390
            (REPLICATE('Z', 1391)),
            ('0'), ('1'), ('2'), ('3'), ('4'), 
            ('5'), ('6'), ('7'), ('8'), ('9')
    ) AS X (i)
    ORDER BY NEWID()
) AS OA
OPTION (NO_PERFORMANCE_SPOOL);

Resumo e Considerações Finais