Início / dba / Perguntas / 14789
Accepted
Andrew Savinykh
Asked: 2012-03-12 18:29:32 +0800 CST

Você pode explicar esse plano de execução?

  • 772

Eu estava pesquisando outra coisa quando me deparei com essa coisa. Eu estava gerando tabelas de teste com alguns dados e executando diferentes consultas para descobrir como diferentes maneiras de escrever consultas afetam o plano de execução. Aqui está o script que usei para gerar dados de teste aleatórios:

IF  EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID('t') AND type in (N'U'))
DROP TABLE t
GO

CREATE TABLE t 
(
 c1 int IDENTITY(1,1) NOT NULL 
,c2 int NULL
) 
GO

insert into t
select top 1000000 a from
(select t1.number*2048 + t2.number a, newid() b
from [master]..spt_values t1 
cross join  [master]..spt_values t2
where t1.[type] = 'P' and t2.[type] = 'P') a
order by b
GO

update t set c2 = null
where c2 < 2048 * 2048 / 10
GO


CREATE CLUSTERED INDEX pk ON [t] (c1)
GO

CREATE NONCLUSTERED INDEX i ON t (c2)
GO

Agora, com esses dados, chamei a seguinte consulta:

select * 
from t 
where 
      c2 < 1048576 
   or c2 is null
;

Para minha grande surpresa, o plano de execução gerado para esta consulta foi este arquivo . (Desculpe pelo link externo, é muito grande para caber aqui).

Alguém pode me explicar o que há com todas essas " varreduras constantes " e " escalas de computação "? O que está acontecendo?

Plano

  |--Nested Loops(Inner Join, OUTER REFERENCES:([Expr1010], [Expr1011], [Expr1012]))
       |--Merge Interval
       |    |--Sort(TOP 2, ORDER BY:([Expr1013] DESC, [Expr1014] ASC, [Expr1010] ASC, [Expr1015] DESC))
       |         |--Compute Scalar(DEFINE:([Expr1013]=((4)&[Expr1012]) = (4) AND NULL = [Expr1010], [Expr1014]=(4)&[Expr1012], [Expr1015]=(16)&[Expr1012]))
       |              |--Concatenation
       |                   |--Compute Scalar(DEFINE:([Expr1005]=NULL, [Expr1006]=NULL, [Expr1004]=(60)))
       |                   |    |--Constant Scan
       |                   |--Compute Scalar(DEFINE:([Expr1008]=NULL, [Expr1009]=(1048576), [Expr1007]=(10)))
       |                        |--Constant Scan
       |--Index Seek(OBJECT:([t].[i]), SEEK:([t].[c2] > [Expr1010] AND [t].[c2] < [Expr1011]) ORDERED FORWARD)
sql-server sql-server-2008-r2

2 respostas

  1. Best Answer

    Cada varredura constante produz uma única linha na memória sem colunas. O escalar de computação superior gera uma única linha com 3 colunas

    Expr1005    Expr1006    Expr1004
----------- ----------- -----------
NULL        NULL        60

    O escalar de computação inferior produz uma única linha com 3 colunas

    Expr1008    Expr1009    Expr1007
----------- ----------- -----------
NULL        1048576        10

    O operador de concatenação une essas 2 linhas e gera as 3 colunas, mas agora elas são renomeadas

    Expr1010    Expr1011    Expr1012
----------- ----------- -----------
NULL        NULL        60
NULL        1048576     10

    A Expr1012coluna é um conjunto de sinalizadores usados ​​internamente para definir certas propriedades de busca para o mecanismo de armazenamento .

    O próximo escalar de computação gera 2 linhas

    Expr1010    Expr1011    Expr1012    Expr1013    Expr1014    Expr1015
----------- ----------- ----------- ----------- ----------- -----------
NULL        NULL        60          True        4           16            
NULL        1048576     10          False       0           0

    As últimas três colunas são definidas da seguinte forma e são usadas apenas para fins de classificação antes de serem apresentadas ao Merge Interval Operator

    [Expr1013] = Scalar Operator(((4)&[Expr1012]) = (4) AND NULL = [Expr1010]), 
[Expr1014] = Scalar Operator((4)&[Expr1012]), 
[Expr1015] = Scalar Operator((16)&[Expr1012])

    Expr1014e Expr1015apenas teste se certos bits estão ativados no sinalizador. Expr1013parece retornar uma coluna booleana true se o bit for 4estiver ativado e Expr1010for NULL.

    Ao tentar outros operadores de comparação na consulta, obtenho esses resultados

    +----------+----------+----------+-------------+----+----+---+---+---+---+
| Operator | Expr1010 | Expr1011 | Flags (Dec) |       Flags (Bin)       |
|          |          |          |             | 32 | 16 | 8 | 4 | 2 | 1 |
+----------+----------+----------+-------------+----+----+---+---+---+---+
| >        | 1048576  | NULL     |           6 |  0 |  0 | 0 | 1 | 1 | 0 |
| >=       | 1048576  | NULL     |          22 |  0 |  1 | 0 | 1 | 1 | 0 |
| <=       | NULL     | 1048576  |          42 |  1 |  0 | 1 | 0 | 1 | 0 |
| <        | NULL     | 1048576  |          10 |  0 |  0 | 1 | 0 | 1 | 0 |
| =        | 1048576  | 1048576  |          62 |  1 |  1 | 1 | 1 | 1 | 0 |
| IS NULL  | NULL     | NULL     |          60 |  1 |  1 | 1 | 1 | 0 | 0 |
+----------+----------+----------+-------------+----+----+---+---+---+---+

    Do qual deduzo que o Bit 4 significa "Tem início do intervalo" (em oposição a ser ilimitado) e o Bit 16 significa que o início do intervalo é inclusivo.

    Este conjunto de resultados de 6 colunas é emitido pelo SORToperador classificado por Expr1013 DESC, Expr1014 ASC, Expr1010 ASC, Expr1015 DESC. Assumir que Trueé representado por 1e Falsepelo 0conjunto de resultados representado anteriormente já está nessa ordem.

    Com base em minhas suposições anteriores, o efeito líquido desse tipo é apresentar os intervalos para o intervalo de mesclagem na seguinte ordem

     ORDER BY 
          HasStartOfRangeAndItIsNullFirst,
          HasUnboundedStartOfRangeFirst,
          StartOfRange,
          StartOfRangeIsInclusiveFirst

    O operador de intervalo de mesclagem gera 2 linhas

    Expr1010    Expr1011    Expr1012
----------- ----------- -----------
NULL        NULL        60
NULL        1048576     10

    Para cada linha emitida é realizada uma busca de alcance

    Seek Keys[1]: Start:[dbo].[t].c2 > Scalar Operator([Expr1010]), 
               End: [dbo].[t].c2 < Scalar Operator([Expr1011])

    Portanto, parece que duas buscas são realizadas. Um aparentemente > NULL AND < NULLe um > NULL AND < 1048576. No entanto, os sinalizadores que são passados ​​parecem modificar isso para IS NULLe, < 1048576respectivamente. Espero que @sqlkiwi possa esclarecer isso e corrigir quaisquer imprecisões!

    Se você alterar ligeiramente a consulta para

    select *
from t 
where 
      c2 > 1048576 
   or c2 = 0
;

    Em seguida, o plano parece muito mais simples com uma busca de índice com vários predicados de busca.

    O plano mostraSeek Keys 

    Start: c2 >= 0, End: c2 <= 0, 
Start: c2 > 1048576

    A explicação de por que esse plano mais simples não pode ser usado para o caso no OP é fornecida pelo SQLKiwi nos comentários da postagem de blog vinculada anteriormente .

    Uma busca de índice com vários predicados não pode misturar diferentes tipos de predicado de comparação (ou seja , Ise Eqno caso do OP). Esta é apenas uma limitação atual do produto (e é presumivelmente a razão pela qual o teste de igualdade na última consulta c2 = 0é implementado usando >=e <=, em vez de apenas a busca de igualdade direta que você obtém para a consulta c2 = 0 OR c2 = 1048576.

    • 29

  2. As verificações constantes são uma forma de o SQL Server criar um depósito no qual colocará algo posteriormente no plano de execução. Eu postei uma explicação mais completa sobre isso aqui . Para entender para que serve a verificação constante, você deve examinar mais a fundo o plano. Nesse caso, são os operadores Compute Scalar que estão sendo usados ​​para preencher o espaço criado pela varredura constante.

    Os operadores Compute Scalar estão sendo carregados com NULL e o valor 1045876, então eles claramente serão usados ​​com o Loop Join em um esforço para filtrar os dados.

    A parte muito legal é que esse plano é Trivial. Isso significa que ele passou por um processo mínimo de otimização. Todas as operações estão levando ao Merge Interval. Isso é usado para criar um conjunto mínimo de operadores de comparação para uma busca de índice ( detalhes sobre isso aqui ).

    A ideia é livrar-se dos valores sobrepostos para que possa extrair os dados com o mínimo de passagens. Embora ainda esteja usando uma operação de loop, você notará que o loop é executado exatamente uma vez, ou seja, é efetivamente uma varredura.

    ADENDO: Essa última frase está errada. Foram duas buscas. Eu interpretei mal o plano. O restante dos conceitos é o mesmo e o objetivo, passes mínimos, é o mesmo.

    • 13

relate perguntas