Tenho um caso estranho de uma consulta que demora para ser executada, apesar de ter um bom índice de correspondência. O problema é que os valores das 2 primeiras colunas em um índice não clusterizado são NULL em todas as linhas. (Para contexto, ficou assim depois de arquivar dados antigos de processos de negócios antigos). A consulta tem cláusula WHERE nessas 2 colunas usando igualdade e valores não NULL, portanto, deve ser fácil para o SQL Server preparar um bom plano usando index seek+lookup, especialmente porque os dados que estão sendo procurados não existem, então as estimativas são 0 ou 1 linha.
Infelizmente, a consulta é muito sensível a alterações na tabela, nem mesmo à atualização automática de estatísticas ou distorção de dados. Suspeito que pode ser um bug no otimizador, onde ele não pode fazer uso de histogramas de estatísticas de etapa única, onde NULL é o único valor no intervalo. Não tenho certeza se explorei todas as opções, portanto, gostaria que alguém desse uma olhada. O servidor de produção é 2017, mas preparei esta reprodução em 2022, e o comportamento é idêntico nessas 2 versões.
A tabela em produção contém 35 milhões de linhas e cerca de 60 colunas e está sendo atualizada (principalmente inserção+atualização) em cerca de 3.000 linhas em 1 hora, portanto, não há muito tráfego de gravação, principalmente leituras.
Tem alguma coisa que eu esqueci? Ou é um bug real?
Agradeço antecipadamente.
use tempdb;
go
-- The simplest repro of the issue.
-- Just in case you wondered if it's enabled. It's not needed, but included for your reference.
alter database tempdb set auto_create_statistics on;
alter database tempdb set auto_update_statistics on;
drop table if exists t1;
create table t1 (
ID int identity(1,1) not null
primary key clustered,
c2 int null,
c3 varchar(16) null,
c4 int null,
c5 varchar(128) null,
-- in prod there are ~50 more columns
);
-- The actual prod index has 4 columns with explicit ID PK at the end.
create index ix_test on t1 (c2, c3, c4, ID);
-- The prod table contains ~35 million rows. The issue occurs with much smaller
-- number of rows so I only use 1 million here to not waste your time playing with it.
--
-- It happens that in prod all rows have NULL values in c2 and c3.
insert into t1 (c4, c5)
select top (1000*1000) crypt_gen_random(2), 'a'
from sys.all_columns ac1, sys.all_columns ac2;
-- At this point the query uses the index (see the plan).
declare @0 int = 100; -- value that may or may not exist
select ID, c2, c3, c4, c5 -- and all remaining columns in prod
from t1
where c2 = @0 and c3 = 'x' -- 'x' is a value that may or may not exist
order by c2, c3, c4, ID; -- this is the exact order of the index
go
-- But with "option (recompile)" it does the full scan of the clustered index
-- and has awful estimates.
declare @0 int = 100;
select ID, c2, c3, c4, c5
from t1
where c2 = @0 and c3 = 'x'
order by c2, c3, c4, ID
option (recompile);
go
-- The same issue also occurs when not using parameters.
select ID, c2, c3, c4, c5
from t1
where c2 = 100 and c3 = 'x'
order by c2, c3, c4, ID
option (recompile);
-- Now let's update statistics to be as great as possible.
update statistics t1 with fullscan, maxdop=1;
-- After which it picks the right index and have great estimates with or
-- without "option (recompile)".
declare @0 int = 100;
select ID, c2, c3, c4, c5
from t1
where c2 = @0 and c3 = 'x'
order by c2, c3, c4, ID
option (recompile);
-- Insert only a tiny bit of more data. It does not trigger auto update of the
-- statistics.
insert into t1 (c4, c5)
select top (10) 1, crypt_gen_random(2)
from sys.all_columns ac1, sys.all_columns ac2;
-- And now it again does the full scan even when not using the hint nor the
-- @parameter.
select ID, c2, c3, c4, c5
from t1
where c2 = 100 and c3 = 'x'
order by c2, c3, c4, ID;
go
-- If the above gave you seek+lookup, this one will not:
declare @0 int = 100;
select ID, c2, c3, c4, c5
from t1
where c2 = @0 and c3 = 'x'
order by c2, c3, c4, ID
option (recompile);
-- When using the index hint it works fine, but has awful estimates.
select ID, c2, c3, c4, c5
from t1
where c2 = 100 and c3 = 'x'
order by c2, c3, c4, ID
option (table hint (t1, index (ix_test)));
-- I would expect it to just always use the index seek + lookup. The query
-- should always be fast. It's easy to determine that there's no data
-- satisfying the filter.
-- When you check the stats histogram, there's none.
declare @stats_id int = (
select stats_id from sys.stats
where [object_id] = object_id('t1') and name = 'ix_test');
select * from sys.dm_db_stats_histogram(object_id('t1'), @stats_id);
/* In SSMS you can see that there's only 1 step:
Statistics for INDEX 'ix_test'.
-------------------------------------------------------------------------------------------------------------------
Name Updated Rows Rows Sampled Steps Density Average Key Length String Index
-------------------------------------------------------------------------------------------------------------------
ix_test Sep 9 2024 4:59PM 1000000 1000000 1 0 8 NO 1000000 0
All Density Average Length Columns
--------------------------------------------
1 0 c2
1 0 c2, c3
1.525879E-05 4 c2, c3, c4
1E-06 8 c2, c3, c4, ID
Histogram Steps
RANGE_HI_KEY RANGE_ROWS EQ_ROWS DISTINCT_RANGE_ROWS AVG_RANGE_ROWS
----------------------------------------------------------------------
0 1000000 0 1
so the optimizer has the knowledge that all rows have NULL values, and
that there's nothing else in the table, it just is unable to use that
information in some cases.
*/
EDIT: Este é o plano de consulta ao usar OPTION (RECOMPILE)
:
e esse é o plano sem a dica. Eu perdi o fato de que ele foi parametrizado apesar de passar o valor literal na string:
Esse é um bug em
sys.dm_db_stats_histogram
.DBCC SHOW_STATISTICS
mostra a linha NULL corretamente (é o que o SSMS usa). O problema original comsys.dm_db_stats_histogram
era que ele nunca exibia a etapa NULL extra. Eles consertaram isso, mas ele ainda não mostra umaNULL
etapa se essa for a única etapa . Eles não demonstraram interesse em consertar isso.Sim, mas isso é apenas um cenário de bananas. É simplesmente estranho criar um índice com uma coluna inicial do mesmo jeito. O histograma (construído apenas na primeira coluna) é quase inútil. Sim, ele dá uma boa estimativa (o SQL Server nunca estima 0 linhas, exceto em um caso estreito com o qual ninguém se importa) quando as estatísticas são recém-construídas.
Quando modificações são feitas na tabela subjacente, o SQL Server registra esse fato e o usa para modificar o histograma e suas estimativas de seletividade em geral. Ele não sabe nada sobre os valores usados nessas modificações.
O que ele deveria assumir? Que os novos valores são todos NULL? Talvez, mas não é. Não há razão para pensar que novos valores serão NULL só porque os existentes são. Estamos firmemente entrincheirados em território de adivinhação aqui. Se o SQL Server assumisse que todos os valores futuros caíssem dentro do histograma existente, outras pessoas reclamariam dessa suposição.
Outra suposição de modelagem é que os usuários geralmente escrevem consultas para encontrar dados que existem. Isso pode ou não ser sempre uma boa suposição, mas é o que é. Você está procurando por dados que sabe que não existem. Sua consulta simplesmente não se encaixa no modelo.
No geral, não é de se espantar que você esteja recebendo planos e estimativas instáveis. Você está fazendo perguntas malucas ao otimizador e não dando a ele nenhuma informação útil para trabalhar. O SQL Server não é mágico e não consegue adivinhar que está operando em uma situação maluca. Algo sobre o design ou índices e consultas de suporte precisará mudar.
Se você não puder fazer mais nada, pelo menos diga ao otimizador que essas colunas são sempre NULL:
Todos os seus planos ficarão assim, já que não há necessidade de acessar a tabela:
Vale a pena mencionar que seu script sempre resulta em um plano de busca mais pesquisa para mim, testando no SQL Server 2022 CU14 usando o nível de compatibilidade 160 e o estimador de cardinalidade padrão.
Você sempre pode usar uma
FORCESEEK
dica, diretamente na consulta ou via Query Store ou guias de plano. Não sei por que você se importaria com estimativas de cardinalidade se você obtém o plano seek plus lookup, mas talvez essa informação esteja simplesmente faltando na pergunta.De qualquer forma, a resposta à sua pergunta é não, não é um bug do SQL Server.
Você pode criar um índice parcial apenas com os valores NOT NULL:
Este índice será extremamente pequeno (e rápido) e será atualizado somente quando novos registros forem inseridos com valores não nulos.
Para que o otimizador use esse índice, você precisa repetir a condição do índice na consulta que deseja otimizar:
Odeio aprovar minhas próprias respostas, mas dessa vez acho que acertei.
Depois de 3 dias mexendo com esse problema, cheguei à conclusão de que o SQL Server se perde com estatísticas de etapa única. Depois de atualizar os valores na coluna c2 para -1 e c3 para 'a' em todas as linhas, o problema ainda ocorreu, então não é específico para NULLs.
Até que a mesa fique grande, isso não é um problema. Mas quando o tamanho é substancial, você começa a notar.
Após adicionar apenas 1000 linhas com alguns valores não NULL em c2, o problema desapareceu completamente. No sistema de produção, desarquivamos essa pequena quantidade de dados antigos, atualizamos estatísticas e pronto! Os planos são estáveis e têm seek+lookup com número estimado de linhas em torno de 1, conforme o esperado.
Uma observação lateral: PostgreSQL 16 e SQLite lidam com esse cenário muito bem. Testado até 30 milhões de tamanho.
Obrigado a todos pelas respostas e comentários.