No PostgreSQL 12.1
, dado:
postgres=> create table abc(a int not null, b text not null, c boolean not null);
CREATE TABLE
postgres=> create index on abc (a, b, c);
CREATE INDEX
Eu então preparei uma consulta que filtra apenas em a
, ou seja, o primeiro elemento no índice.
postgres=> prepare only_a(int) as select 42 from abc where a = 1;
PREPARE
postgres=> explain execute only_a(100);
QUERY PLAN
----------------------------------------------------------------------------
Bitmap Heap Scan on abc (cost=4.20..13.67 rows=6 width=4)
Recheck Cond: (a = 1)
-> Bitmap Index Scan on abc_a_b_c_idx (cost=0.00..4.20 rows=6 width=0)
Index Cond: (a = 1)
(4 rows)
É capaz de usar o índice para filtrar a
, de acordo com o acima.
Então, preparei uma query que filtra em a
and c
, ou seja, não usa b
.
postgres=> prepare a_and_c(int) as select 42 from abc where a = 1 and c = true;
PREPARE
Então, eu corri explain execute
,
postgres=> explain execute a_and_c(100);
QUERY PLAN
----------------------------------------------------------------------------
Bitmap Heap Scan on abc (cost=4.21..11.32 rows=3 width=4)
Recheck Cond: (a = 1)
Filter: c
-> Bitmap Index Scan on abc_a_b_c_idx (cost=0.00..4.21 rows=3 width=0)
Index Cond: ((a = 1) AND (c = true))
(5 rows)
Meu entendimento é que isso Index Cond: ((a = 1) AND (c = true))
significa que abc_a_b_c_idx
foi capaz de usar ambos a
e c
valores, apesar de b
não estar envolvido no where
.
Se sim, como pode c
ser usado já que b
não é usado?
"c" está sendo usado apenas como um filtro no índice. Ele salta para a parte do índice em que "a"=1 e o varre até que "a" se torne >1. Para todas essas linhas, ele filtra qualquer coisa em que "c" não seja verdadeiro, com base no valor de "c" encontrado no índice.
É lamentável que a sintaxe EXPLAIN não diferencie uma coluna usada para pular para uma parte específica do índice (ou parar na varredura de índice no final dos valores relevantes), de uma coluna usada apenas para filtrar dentro do índice. Mas EXPLAIN não entende as partes internas dos índices, apenas sabe que "c" está sendo usado, não sabe com que eficiência está sendo usado.
Você está certo em se perguntar, e o motivo é um desleixo na saída de explicação do PostgreSQL.
Durante uma varredura de índice, algumas das condições podem ser usadas para varrer o índice e algumas condições podem ser usadas como filtro, que é uma condição adicional imposta às linhas encontradas durante a varredura de índice.
Agora
a = 1
é claramente uma condição que pode ser usada para escanear o índice.O problema é que existem duas maneiras de filtrar durante uma verificação de índice:
descartar tuplas de índice enquanto elas são varridas, antes que a tabela seja acessada.
descartar linhas de resultado com base em uma condição nos valores obtidos da tabela durante a verificação do índice.
O segundo tipo é exibido como
filter
emEXPLAIN
, mas o primeiro tipo de filtro é mostrado como parte da condição de varredura. Esta é a sua condiçãoc = true
.Não há como diferenciar uma condição de varredura de um filtro do primeiro tipo na
EXPLAIN
saída.Observe que o primeiro tipo de filtro é mais eficiente, pois reduz o número de linhas que precisam ser buscadas no heap, que é a parte cara de uma varredura de índice.