Sql Server falha ao usar o índice na simples bijeção

Esse é outro enigma do otimizador de consulta.

Talvez eu esteja apenas superestimando os otimizadores de consulta ou talvez esteja perdendo alguma coisa - por isso estou publicando isso.

Eu tenho uma mesa simples

CREATE TABLE [dbo].[MyEntities](
  [Id] [uniqueidentifier] NOT NULL,
  [Number] [int] NOT NULL,
  CONSTRAINT [PK_dbo.MyEntities] PRIMARY KEY CLUSTERED ([Id])
)

CREATE NONCLUSTERED INDEX [IX_Number] ON [dbo].[MyEntities] ([Number])

com um índice e algumas milhares de linhas, Numbersendo distribuídos igualmente nos valores 0, 1 e 2.

Agora esta consulta:

SELECT * FROM
    (SELECT
        [Extent1].[Number] AS [Number],
        CASE
        WHEN (0 = [Extent1].[Number]) THEN 'one'
        WHEN (1 = [Extent1].[Number]) THEN 'two'
        WHEN (2 = [Extent1].[Number]) THEN 'three'
        ELSE '?'
        END AS [Name]
        FROM [dbo].[MyEntities] AS [Extent1]
        ) P
WHERE P.Number = 0;

um índice procura IX_Numbercomo seria de esperar.

Se a cláusula where for

WHERE P.Name = 'one';

no entanto, torna-se uma varredura.

A cláusula de caso é obviamente uma bijeção, portanto, em teoria, uma otimização deve ser possível deduzir o primeiro plano de consulta da segunda consulta.

Também não é puramente acadêmico: a consulta é inspirada na tradução de valores enum para seus respectivos nomes amigáveis.

Eu gostaria de ouvir de alguém que sabe o que pode ser esperado dos otimizadores de consulta (e especificamente do Sql Server): Estou simplesmente esperando demais?

Estou perguntando como tive casos anteriores em que uma ligeira variação de uma consulta faria uma otimização aparecer de repente.

Estou usando o Sql Server 2016 Developer Edition.

Estou simplesmente esperando demais?

Sim. Pelo menos nas versões atuais do produto.

O SQL Server não separará a CASEinstrução e fará a engenharia reversa para descobrir que, se o resultado da coluna calculada for 'one', [Extent1].[Number]deve ser 0.

Você precisa certificar-se de escrever seus predicados para serem sargáveis. O que quase sempre envolve estar na forma. basetable_column_name comparison_operator expression.

Mesmo pequenos desvios quebram a sargabilidade.

WHERE P.Number + 0 = 0;

não usaria uma busca de índice, mesmo que seja ainda mais simples de simplificar do que a CASEexpressão.

Se você deseja procurar um nome de sequência e obter um número, você precisaria de uma tabela de mapeamento com os nomes e números e se unir a ela na consulta, então o plano pode ter uma pesquisa na tabela de mapeamento seguida por uma pesquisa correlacionada on [dbo].[MyEntities]com o número retornado do primeiro procurar.

Não projete seu enum como uma declaração de caso. Projete-o como uma tabela derivada da seguinte forma:

SELECT * FROM
   (SELECT
      [Extent1].[Number] AS [Number],
      enum.Name
   FROM
      [dbo].[MyEntities] AS [Extent1]
      LEFT JOIN (VALUES
         (0, 'one'),
         (1, 'two'),
         (2, 'three')
      ) enum (Number, Name)
         ON Extent1.Number = enum.Number
   ) P
WHERE
   P.Name = 'one';

Eu suspeito que você obterá melhores resultados. (Não converti o Nome para ?quando estava ausente, pois isso provavelmente interferiria em possíveis ganhos de desempenho. No entanto, você pode mover a WHEREcláusula dentro da consulta externa para colocar o predicado na enumtabela ou retornar duas colunas do consulta interna, uma para o predicado e outra para exibição, onde o predicado está NULLquando não há valor de enum correspondente.)

No entanto, acho que, devido a isso [Extent1], você está usando um ORM como o Entity Framework ou o Linq-To-SQL. Não posso orientá-lo sobre como realizar essa projeção nativamente, mas você poderia usar uma técnica diferente.

Em um projeto meu, refleti valores de enumeração de código em tabelas reais no banco de dados, através de uma classe de construção personalizada que mesclou os valores de enumeração no banco de dados. (Você precisa respeitar a regra de que deve listar explicitamente seus valores de enumeração, nunca pode excluir nenhum sem revisar suas tabelas e nunca pode alterá-los, embora você já precise observar pelo menos parte disso na configuração atual) .

Agora, eu estava usando um enumerável de uma Identifierclasse base que possui muitas subclasses concretas diferentes, mas não há razão para que isso não possa ser feito com um enum de baunilha comum. Aqui está um exemplo de uso:

new EnumOrIdentifierProjector<CodeClassOrEnum, PrivateDbDtoObject>(
   _sqlConnector.Connection,
   "dbo.TableName",
   "PrimaryKeyId",
   "NameColumnName",
   dtoObject => dtoObject.PrimaryKeyId,
   dtoObject => dtoObject.NameField,
   EnumerableOfIdentifierOrTypeOfEnum
)
   .Populate();

Você pode ver que eu passei todas as informações necessárias para escrever e ler os valores do banco de dados. (Eu tive uma situação em que a solicitação atual pode não conter todos os valores existentes, portanto, é necessário retornar qualquer adicional do banco de dados e do conjunto carregado no momento. Também deixei o banco de dados atribuir IDs, embora para uma enumeração você provavelmente não quero isso.)

A idéia é que, quando você tiver uma tabela que seja lida / gravada apenas uma vez na inicialização e que tenha todos os valores de enum de maneira confiável, basta associá-la como qualquer outra tabela, e o desempenho deverá ser bom.

Espero que essas idéias sejam suficientes para você fazer uma melhoria.

Interpreto a pergunta como se você estivesse interessado em otimizadores em geral, mas com um interesse especial pelo SQL Server. Testei seu cenário com o db2 LUW V11.1:

]$ db2 "create table myentities ( id int not null, number int not null )"
]$ db2 "create index ix_number on myentities (number)"
]$ db2 "insert into myentities (id, number) with t(n) as ( values 0 union all select n+1 from t where n<10000) select n, mod(n,3) from t"

O otimizador no DB2 reescreve a segunda consulta na primeira:

Original Statement:
------------------
SELECT 
  * 
FROM 
  (SELECT 
     number,

   CASE 
   WHEN (0 = Number) 
   THEN 'one' 
   WHEN (1 = Number) 
   THEN 'two' 
   WHEN (2 = Number) 
   THEN 'three' 
   ELSE '?' END AS Name 
   FROM 
     MyEntities
  ) P 
WHERE 
  P.name = 'one'


Optimized Statement:
-------------------
SELECT 
  Q1.NUMBER AS "NUMBER",

CASE 
WHEN (0 = Q1.NUMBER) 
THEN 'one' 
WHEN (1 = Q1.NUMBER) 
THEN 'two' 
WHEN (2 = Q1.NUMBER) 
THEN 'three' 
ELSE '?' END AS "NAME" 
FROM 
  LELLE.MYENTITIES AS Q1 
WHERE 
  (0 = Q1.NUMBER)

O plano se parece com:

Access Plan:
-----------
        Total Cost:             33.5483
        Query Degree:           1


      Rows 
     RETURN
     (   1)
      Cost 
       I/O 
       |
      3334 
     IXSCAN
     (   2)
     33.1861 
     4.66713 
       |
      10001 
 INDEX: LELLE   
    IX_NUMBER
       Q1

Não sei muito sobre outros otimizadores, mas sinto que o otimizador do DB2 é considerado muito bom, mesmo entre os concorrentes.

Nesta consulta em particular, é muito bobo até ter uma CASEdeclaração. Você está filtrando para um caso específico! Talvez este seja apenas um detalhe da consulta de exemplo específica que você forneceu, mas, se não, você pode escrever essa consulta para obter resultados equivalentes:

SELECT
    [Extent1].[Number] AS [Number],
    'one' AS [Name]
FROM [dbo].[MyEntities] AS [Extent1]
WHERE [Extent1].[Number] = 0;

Isso fornecerá exatamente o mesmo conjunto de resultados e, como você já está codificando os valores em uma CASEinstrução de qualquer maneira, não estará perdendo nenhuma manutenção aqui.