CS Fundamentals Trainer · Guias
Como funcionam os índices de banco de dados
B-trees, ordem de índices compostos, índices de cobertura, como ler o EXPLAIN e por que o banco ignora o seu índice.
21 min de leitura
Um índice é uma segunda cópia de algumas colunas de uma tabela, mantida em uma ordem que torna a busca rápida. Sem ele, o banco lê todas as linhas para responder "quais pedidos pertencem ao cliente 4242?". Com ele, vai direto ao lugar certo. Quase todo problema de desempenho em um banco relacional termina em uma de duas frases: "não existe índice para esta consulta" ou "existe um índice, e a consulta não consegue usá-lo". Este guia explica como os índices funcionam o suficiente para você saber em qual dos casos está.
1. O problema que um índice resolve
Uma tabela é armazenada como um monte de páginas (blocos de alguns kilobytes, 8 KB no PostgreSQL). Para achar as linhas que atendem a uma condição sem índice, o banco faz uma varredura sequencial (sequential scan): lê todas as páginas e confere todas as linhas. O custo cresce com a tabela. Um milhão de linhas é tranquilo; cem milhões levam um minuto.
Um índice faz o custo crescer com o logaritmo da tabela. Buscar em uma lista ordenada, dividindo-a ao meio repetidamente, é a mesma ideia da busca binária, só que organizada para discos, onde o caro é o número de páginas lidas, não o número de comparações.
Pense no índice remissivo no fim de um livro. Você não lê o livro inteiro para achar "mutex"; procura em ordem alfabética e vai às páginas indicadas.
2. Como funciona uma B-tree
O índice padrão em praticamente todo banco relacional é a B-tree (a rigor, uma B+tree na maioria dos sistemas) [1]. É uma árvore de páginas:
- Páginas folha guardam os valores indexados em ordem, cada um com um ponteiro para a linha da tabela. As folhas são ligadas às vizinhas, então percorrer em ordem é barato.
- Páginas internas guardam valores separadores e ponteiros para as páginas filhas, como placas em um cruzamento.
- Todas as folhas ficam na mesma profundidade, então toda busca custa o mesmo número de leituras de página.
Diagram: A tiny B-tree: find 57 by following one page per level
Para achar 57: na raiz, 57 está entre 40 e 80, então vá ao filho do meio; ali, ele fica entre 50 e 60, então vá a essa folha; varra-a e encontre 57. Três páginas, por maior que seja a tabela.
Por que a árvore é tão rasa
Uma página guarda centenas de entradas, então cada nível multiplica o alcance por centenas. Com cerca de 300 entradas por página:
| Níveis | Linhas alcançáveis |
|---|---|
| 2 | 300 × 300 = 90 000 |
| 3 | 300^3 = 27 milhões |
| 4 | 300^4 = 8,1 bilhões |
Uma tabela com dezenas de milhões de linhas exige uma busca de cerca de 3 ou 4 leituras de página. Os níveis do topo ficam na memória porque toda consulta passa por eles, então na prática o custo é uma ou duas leituras do disco. É por isso que uma busca por índice leva quase o mesmo tempo em uma tabela pequena e em uma enorme.
Escritas: mantendo a ordem
Inserir um valor significa achar sua folha e adicioná-lo ali. Se a folha está cheia, ela é dividida (split) em duas, e um novo separador sobe para o pai (que pode se dividir também). Apagar e atualizar valores indexados também mexe no índice. Esse é o preço de um índice: todo insert, todo update de uma coluna indexada e todo delete faz trabalho extra em cada índice da tabela.
Onde mora a linha em si
Até aqui, uma entrada de índice "aponta para a linha". Como isso acontece depende do banco.
- O PostgreSQL guarda as linhas da tabela em um heap, sem ordem particular. Todo índice, inclusive o da chave primária, aponta para a localização física de uma linha. Uma busca percorre o índice e depois busca a linha.
- O MySQL (InnoDB) e o SQL Server (por padrão, para a chave primária) usam um índice clusterizado: a tabela é a B-tree da chave primária, com as linhas completas nas folhas. Um índice secundário não guarda a localização da linha; guarda o valor da chave primária. Uma busca por índice secundário percorre, portanto, duas árvores: a secundária para achar a chave primária e depois a primária para achar a linha [2].
Isso muda alguns conselhos. No InnoDB, uma chave primária larga (uma string UUID de 36 caracteres) é copiada em todo índice secundário e deixa todos maiores, e uma chave primária aleatória espalha as inserções pela própria tabela, não só por um índice. A ideia do "índice de cobertura" funciona especialmente bem ali, porque pula a segunda caminhada.
3. O que um índice pode fazer por uma consulta
Uma B-tree mantém os valores ordenados, então ajuda em mais do que "igual a":
- Igualdade:
WHERE email = 'ada@example.com'. - Intervalos:
WHERE created_at >= '2026-01-01' AND created_at < '2026-02-01'. Ache o início e depois leia ao longo das folhas. - Prefixos:
WHERE name LIKE 'Ada%', mas só se o índice estiver preparado para isso. No PostgreSQL, o índice comum funciona paraLIKEapenas em uma coluna com a collationC; senão, crie-o comtext_pattern_ops(a seção 7 mostra o teste). No SQLite, oLIKEnão diferencia maiúsculas de minúsculas e por padrão não usa um índice comum; oGLOB 'Ada*'usa. - Ordenação:
ORDER BY created_at DESC LIMIT 10pode ler as dez últimas entradas em vez de ordenar tudo. - Mínimo e máximo: a primeira ou a última entrada de folha.
- Joins: o índice da coluna de junção permite ao banco buscar as linhas correspondentes uma a uma.
Ele não ajuda em WHERE name LIKE '%ada%' (o casamento pode começar em qualquer lugar, então a ordem não serve de nada), nem na maioria dos cálculos feitos sobre a coluna (mais na seção 7).
4. Vendo na prática: EXPLAIN
Nunca adivinhe; peça o plano ao banco. No PostgreSQL isso é o EXPLAIN, e o EXPLAIN ANALYZE também executa a consulta e mostra contagens de linhas e tempos reais [3].
Cuidado: o
EXPLAIN ANALYZErealmente executa o comando. Em umUPDATE,INSERTouDELETE, a mudança acontece. Envolva-o:BEGIN; EXPLAIN ANALYZE UPDATE ...; ROLLBACK;. No meu teste, o update mudou 5 linhas dentro da transação e nenhuma depois doROLLBACK.
Um experimento no PostgreSQL
Copie isto para o psql. Ele cria 200 000 pedidos para 20 000 clientes e pede os dez últimos pedidos pagos de um cliente:
CREATE TABLE orders (
id bigserial PRIMARY KEY, customer_id int, status text, created_at date, total numeric(8,2));
INSERT INTO orders (customer_id, status, created_at, total)
SELECT 1 + floor(random() * 20000)::int,
(ARRAY['new', 'paid', 'shipped'])[1 + floor(random() * 3)::int],
date '2026-01-01' + floor(random() * 300)::int,
round((random() * 100)::numeric, 2)
FROM generate_series(1, 200000);
ANALYZE orders;
EXPLAIN (ANALYZE, COSTS OFF)
SELECT id, total FROM orders
WHERE customer_id = 4242 AND status = 'paid'
ORDER BY created_at DESC LIMIT 10;
Isto foi o que obtive no PostgreSQL 16 (os seus números serão diferentes). Sem índice:
Limit (actual rows=2 loops=1)
-> Gather Merge (actual rows=2 loops=1)
-> Sort (actual rows=1 loops=2)
Sort Key: created_at DESC
-> Parallel Seq Scan on orders (actual rows=1 loops=2)
Filter: ((customer_id = 4242) AND (status = 'paid'::text))
Rows Removed by Filter: 99999
Execution Time: 14.205 ms
Depois de CREATE INDEX orders_cust_status_created ON orders (customer_id, status, created_at); ANALYZE orders;:
Limit (actual rows=2 loops=1)
-> Sort (actual rows=2 loops=1)
Sort Key: created_at DESC
-> Bitmap Heap Scan on orders (actual rows=2 loops=1)
Recheck Cond: ((customer_id = 4242) AND (status = 'paid'::text))
-> Bitmap Index Scan on orders_cust_status_created (actual rows=2 loops=1)
Index Cond: ((customer_id = 4242) AND (status = 'paid'::text))
Execution Time: 0.081 ms
De 14,2 ms para 0,08 ms: o primeiro plano olha todas as 200 000 linhas (cada uma é lida e rejeitada, "Rows Removed by Filter"), o segundo olha as 2 que casam. Como apenas duas linhas casam, o PostgreSQL as ordena sem problema; para um cliente com milhares de pedidos pagos, ele percorreria o índice de trás para frente e pararia após dez entradas, sem nenhuma ordenação. Mais dois planos da mesma tabela:
WHERE status = 'paid'(um terço da tabela) continua sendo um Seq Scan, 12 ms: o índice começa comcustomer_id, então não consegue buscar só porstatus(seção 5).- Depois de
CREATE INDEX orders_cover ON orders (customer_id, created_at) INCLUDE (total); VACUUM ANALYZE orders;, a consultaSELECT created_at, total FROM orders WHERE customer_id = 4242vira um Index Only Scan comHeap Fetches: 0e 0,04 ms (seção 6).
O mesmo experimento no SQLite
Se você só tem Python, o SQLite [4] não exige nada instalado. Ele cria a mesma tabela:
import sqlite3, random
db = sqlite3.connect(":memory:")
db.execute("""CREATE TABLE orders (
id INTEGER PRIMARY KEY, customer_id INTEGER, status TEXT, created_at TEXT, total REAL)""")
random.seed(1)
db.executemany(
"INSERT INTO orders (customer_id, status, created_at, total) VALUES (?, ?, ?, ?)",
[(random.randint(1, 20000), random.choice(["new", "paid", "shipped"]),
f"2026-{random.randint(1, 10):02d}-{random.randint(1, 28):02d}", random.random() * 100)
for _ in range(200000)])
query = """SELECT id, total FROM orders
WHERE customer_id = 4242 AND status = 'paid'
ORDER BY created_at DESC LIMIT 10"""
def plan():
for row in db.execute("EXPLAIN QUERY PLAN " + query):
print(" ", row[3])
print("no index"); plan()
db.execute("CREATE INDEX orders_customer ON orders (customer_id)")
print("index on customer_id"); plan()
db.execute("DROP INDEX orders_customer")
db.execute("CREATE INDEX orders_cust_status_created ON orders (customer_id, status, created_at)")
print("composite index"); plan()
Esta é a saída que obtive (SQLite 3.45):
no index
SCAN orders
USE TEMP B-TREE FOR ORDER BY
index on customer_id
SEARCH orders USING INDEX orders_customer (customer_id=?)
USE TEMP B-TREE FOR ORDER BY
composite index
SEARCH orders USING INDEX orders_cust_status_created (customer_id=? AND status=?)
Três histórias diferentes:
SCAN orders: a tabela inteira e, depois, uma ordenação do que casou.SEARCH ... (customer_id=?): salta para as linhas deste cliente (cerca de 10 das 200 000), mas ainda precisa filtrar por status e ordenar.SEARCH ... (customer_id=? AND status=?)sem etapa de ordenação: o índice acha as linhas certas e as entrega na ordem decreated_at, então oLIMIT 10pode parar depois de dez entradas. (O PostgreSQL preferiu ordenar duas linhas por conta própria; ambos servem para tão poucas linhas.)
Na minha máquina, a consulta levou cerca de 6,5 ms sem índice e 0,09 ms com o composto. A diferença cresce com a tabela: a varredura é proporcional às linhas, a busca à profundidade da árvore.
As palavras que vale conhecer para ler planos do PostgreSQL:
- Seq Scan: lê a tabela inteira. Bom para tabelas pequenas ou quando a maioria das linhas é necessária.
- Index Scan: percorre o índice e visita a tabela para cada correspondência.
- Index Only Scan: responde só com o índice, sem tocar na tabela (seção 6).
- Bitmap Index Scan + Bitmap Heap Scan: primeiro junta as localizações das linhas correspondentes e depois lê as páginas da tabela em ordem. É a escolha do PostgreSQL para "muitas, mas não a maioria" das linhas.
5. Índices compostos: a ordem das colunas é tudo
Um índice em (customer_id, status, created_at) é ordenado por cliente, depois, dentro de um cliente, por status, depois, dentro de um status, por data. Como uma lista telefônica ordenada por sobrenome e depois por nome, é excelente para "todos os Silva" e para "João Silva", e inútil para "todo mundo chamado João" [5].
| Consulta | Usa bem o índice? |
|---|---|
WHERE customer_id = 4242 | Sim: a coluna líder |
WHERE customer_id = 4242 AND status = 'paid' | Sim: as duas primeiras colunas |
WHERE customer_id = 4242 AND status = 'paid' ORDER BY created_at | Sim, e sem precisar ordenar |
WHERE customer_id = 4242 AND created_at > '2026-06-01' | Em parte: acha o cliente, mas precisa filtrar as datas dentro dele |
WHERE status = 'paid' | Mal: falta a coluna líder, então não consegue buscar |
WHERE status = 'paid' AND created_at > '2026-06-01' | Mal, pelo mesmo motivo |
(Versões recentes do PostgreSQL às vezes conseguem "pular" uma coluna líder ausente quando ela tem poucos valores distintos. Ajuda em alguns casos, mas não projete em cima disso.)
Uma regra prática para a ordem
- Colunas de igualdade primeiro (
=). A ordem entre elas quase não muda o custo de uma busca; o que ela muda é quais outras consultas podem reaproveitar o índice, porque precisam usar um prefixo à esquerda. Coloque primeiro a coluna que a maioria das suas consultas filtra. - Depois a coluna usada para um intervalo ou para ordenar (
>,BETWEEN,ORDER BY). - Colunas depois de uma coluna de intervalo só são usadas para filtrar dentro do intervalo, não para buscar.
Projete índices a partir das suas consultas reais, não da tabela. Liste as dez consultas que mais importam; um índice que atende três delas vale mais do que três índices estreitos. Um índice composto em (a, b) também atende consultas só em a, então um índice separado em a é redundante e custa a cada escrita.
6. Índices de cobertura e index-only scans
Normalmente o índice acha a linha e o banco visita a tabela para ler as outras colunas. Se o próprio índice contém todas as colunas de que a consulta precisa, a visita é desnecessária: um index-only scan. No meu teste com SQLite, incluir total no índice mudou o plano para USING COVERING INDEX.
O PostgreSQL permite adicionar colunas a um índice sem fazê-las parte da sua ordenação, com INCLUDE:
CREATE INDEX orders_customer_covering
ON orders (customer_id, created_at)
INCLUDE (total);
Um índice de cobertura é mais rápido para consultas quentes, mas é maior e custa mais a cada escrita, então use-o só para algumas consultas importantes. No PostgreSQL, um index-only scan também precisa que o visibility map da tabela esteja atualizado, o que o VACUUM mantém; em uma tabela que muda o tempo todo, a economia pode diminuir [6].
7. Por que o banco ignora o seu índice
Você criou o índice, e o plano ainda mostra uma varredura sequencial. Os motivos usuais:
- A condição não é pesquisável. Envolver a coluna em uma função a esconde:
WHERE lower(email) = 'ada@example.com'não consegue usar um índice ememail. Crie um índice de expressão emlower(email)ou guarde o valor em uma forma que dispense a função. O mesmo vale paraWHERE created_at::date = '2026-06-01'(use um intervalo na coluna original) eWHERE price * 2 > 100(passe a aritmética para o outro lado:price > 50). - Os tipos diferem (este depende do banco). No MySQL, comparar uma coluna de string com um número converte cada string guardada em número, então o índice não pode ser usado; no SQL Server, comparar uma coluna
varcharcom um parâmetronvarcharfaz o mesmo. O PostgreSQL é mais estrito:WHERE status = 5em uma coluna de texto é rejeitado comoperator does not exist: text = integer, então você descobre na hora. Em qualquer caso, case o tipo do seu parâmetro com o da coluna. - Um curinga no início:
LIKE '%ada'não pode usar uma B-tree (meu teste: Seq Scan). E um padrão de prefixo comoLIKE 'User42%'precisa do índice certo: em um banco PostgreSQL com a collationC.UTF-8, o índice comum ememailfoi ignorado, e um índice criado comCREATE INDEX ON users (email text_pattern_ops)foi usado. - Baixa seletividade. Se a condição casa com a maior parte da tabela, ler o índice e depois saltar pela tabela é mais lento do que uma leitura sequencial, e o planejador está certo em varrer. Não há um limite fixo, e os motores diferem. No meu teste com PostgreSQL (200 000 linhas, índice na coluna), uma condição que casava 5 % das linhas usou um Index Scan, 25 % e 33 % usaram um Bitmap scan, e 95 % usaram um Seq Scan. Outros motores (SQLite, MySQL) traçam a linha em outro ponto. Olhe o plano, não uma regra prática.
ORentre colunas diferentes.WHERE a = 1 OR b = 2precisa de dois índices combinados ou de uma reescrita comUNION.- Estatísticas desatualizadas. O planejador escolhe com estimativas das estatísticas da tabela. Depois de uma carga grande, rode
ANALYZE(PostgreSQL) para que as estimativas correspondam à realidade. - A tabela é pequena. Ler três páginas é mais barato do que usar um índice. Não é um problema.
- A ordem das colunas está errada, como na seção 5.
Quando suspeitar de um problema, não confie só no plano: o EXPLAIN ANALYZE mostra o número estimado e o real de linhas em cada etapa. Uma grande diferença entre eles é a pista.
8. Tipos especiais de índices
- Índices únicos impõem uma regra ("uma conta por e-mail") e são pesquisáveis. Uma
PRIMARY KEYe uma restriçãoUNIQUEcriam um. - Índices parciais cobrem apenas algumas linhas:
CREATE INDEX ON orders (customer_id) WHERE status = 'new'. São pequenos e rápidos quando as consultas olham uma fatia conhecida, como "jobs não processados" [7]. Um limite a conhecer: o planejador só usa um índice parcial quando consegue provar que a condição da consulta implica a condição do índice.WHERE status = 'new'se qualifica;WHERE status = $1em um prepared statement com plano genérico não, porque o valor não é conhecido quando o plano é feito. No meu teste, o plano genérico ignorou o índice parcial e usou outro. Escreva a constante na consulta ou mantenha um índice completo. - Índices de expressão indexam um valor calculado:
CREATE INDEX ON users (lower(email)). - Outros tipos de índice existem para outras perguntas:
| Tipo | Bom para | Exemplo |
|---|---|---|
| B-tree | Igualdade, intervalos, ordenação. O padrão | Quase tudo |
| Hash | Só igualdade | Raramente vale mais que uma B-tree |
| GIN | Valores que contêm muitos itens | Busca de texto completo, jsonb, arrays |
| GiST / SP-GiST | Geometria, vizinho mais próximo, intervalos | Mapas, "achar num raio de 5 km" |
| BRIN | Tabelas enormes cujos valores seguem a ordem física | Logs de séries temporais, índice minúsculo |
- LSM trees (RocksDB, Cassandra, LevelDB) são uma estrutura alternativa para armazenamento com muitas escritas: juntam as escritas na memória e as mesclam no disco em lotes ordenados. As escritas são mais baratas do que em uma B-tree; as leituras podem precisar checar vários níveis. Se uma pergunta for "B-tree ou LSM?", a resposta é: muita leitura e consultas por intervalo favorecem a B-tree, ingestão com muita escrita favorece a LSM.
9. O que os índices custam
Índices não são de graça, e uma tabela com quinze deles é um mau sinal.
- Escritas mais lentas. Cada insert e delete atualiza todos os índices; um update toca os índices das colunas que ele muda (e, se a linha precisa se mover, todos eles; o PostgreSQL evita isso em updates que não mudam nenhuma coluna indexada, por meio de "heap-only tuples").
- Espaço. Os índices podem facilmente ocupar tanto disco e memória quanto a tabela. A memória usada por um índice é memória que não é usada para dados.
- Bloat. Depois de muitos updates e deletes, as páginas ficam meio vazias; um
REINDEXperiódico (ou a recriação concorrente) resolve. - Planejamento e manutenção ficam mais complicados a cada um.
Ache os que ninguém usa. No PostgreSQL, pg_stat_user_indexes.idx_scan conta quantas vezes cada índice foi usado desde a última zeragem das estatísticas. Um índice com zero varreduras ao longo de semanas (e que não impõe uma restrição única) é candidato à remoção. Crie índices em tabelas grandes e ativas com CREATE INDEX CONCURRENTLY, para que as escritas não fiquem bloqueadas enquanto ele é construído.
Indexe suas chaves estrangeiras
Uma chave estrangeira (orders.customer_id REFERENCES customers(id)) faz o banco verificar, sempre que um cliente é apagado ou sua chave muda, que nenhum pedido ainda aponta para ele. O PostgreSQL indexa a coluna referenciada (a chave primária), mas não cria um índice na coluna que referencia; o InnoDB do MySQL cria. Sem um, cada verificação varre a tabela filha inteira. No meu teste (200 000 pedidos, nenhum índice começando com customer_id), apagar um cliente sem pedidos ainda levou 7,6 ms, porque a verificação varreu a tabela orders inteira, e 0,4 ms depois de CREATE INDEX ON orders (customer_id); o custo cresce com a tabela, e a mesma varredura deixa lento todo join nessa coluna. Como hábito, indexe as colunas de chave estrangeira, sozinhas ou como coluna líder de um índice composto.
10. Paginação: onde os índices encontram o design do produto
Mostrar a página 5 000 de uma lista com OFFSET é lento, mesmo com índice, porque o banco precisa passar por todas as linhas puladas:
-- slow for deep pages: reads and throws away 100 000 rows
SELECT * FROM orders WHERE customer_id = 4242 ORDER BY created_at DESC, id DESC
LIMIT 20 OFFSET 100000;
-- fast at any depth: seek to where the previous page ended
SELECT * FROM orders
WHERE customer_id = 4242 AND (created_at, id) < ('2026-06-01 10:00', 9812)
ORDER BY created_at DESC, id DESC
LIMIT 20;
A segunda forma é a paginação por keyset: o cliente devolve o último (created_at, id) que viu, e a consulta busca até ele usando o índice em (customer_id, created_at, id). O id desempata, então nenhuma linha é pulada ou repetida. O preço é que você não pode saltar para a "página 5 000", o que ninguém precisa em feeds e rolagem infinita [5].
11. Perguntas que entrevistadores gostam de acrescentar
"Devo indexar todas as colunas?"
Não. Indexe o que você filtra, junta e ordena, na ordem que suas consultas usam, e meça. Todo índice deixa as escritas mais lentas e ocupa espaço.
"Como você descobre qual índice adicionar?"
Comece pelo log de consultas lentas ou pelo pg_stat_statements, para as consultas que consomem mais tempo total. Rode EXPLAIN ANALYZE. Adicione o índice. Rode EXPLAIN ANALYZE de novo e compare os números, não só o plano.
"Chave primária: UUID ou inteiro?"
Um UUID aleatório é inserido em lugares aleatórios da árvore, o que causa muitas divisões de página e deixa o índice maior e mais lento de manter do que inteiros sequenciais ou ids ordenados por tempo (como o UUID versão 7). Ids aleatórios também espalham o conjunto de trabalho por todas as páginas, em vez de só as recentes. No InnoDB é pior, porque a chave primária é a própria ordem da tabela e é copiada em todo índice secundário (veja "Onde mora a linha em si"); guarde UUIDs como 16 bytes (BINARY(16)), não como 36 caracteres. Escolha conforme as necessidades (unicidade global, esconder contagens) e conheça o custo.
"Por que minha consulta fica lenta só às vezes?"
O plano pode mudar com os parâmetros (um cliente com 3 pedidos e um com 3 milhões precisam de planos diferentes), com estatísticas desatualizadas, ou quando o índice deixa de caber na memória.
12. Coisas a mencionar em uma entrevista
- Uma B-tree é rasa e ordenada: uma busca lê um punhado de páginas, e intervalos e ordenação vêm de graça.
- Índices compostos seguem a regra do prefixo à esquerda; ponha as colunas de igualdade primeiro, intervalos e ordenação depois.
- Índices de cobertura podem evitar a tabela por completo.
- Confira com o
EXPLAIN; colunas envolvidas em funções, tipos incompatíveis e curingas impedem o uso de um índice. - Índices tornam as leituras mais rápidas e as escritas mais lentas; remova os que não são usados.
- A paginação por keyset vence o
OFFSET.
Resumo rápido
- Sem um índice, uma consulta lê a tabela inteira. Uma B-tree a reduz a cerca de 3 ou 4 leituras de página, mesmo com bilhões de linhas.
- A árvore é ordenada, então atende igualdade, intervalos, ordenação, mínimo e máximo.
- Em um índice composto, a ordem das colunas decide quais consultas ele atende: colunas líderes primeiro, igualdade antes de intervalo.
- Um índice de cobertura (
INCLUDE) pode responder a uma consulta sem visitar a tabela. - Funções sobre a coluna, curingas no início, tipos incompatíveis e baixa seletividade fazem o planejador pular o índice.
- Cada índice custa escritas, espaço e manutenção. Meça e pode.
- Use
EXPLAIN ANALYZEantes e depois de cada mudança.
Fontes
- Bayer e McCreight, Organization and maintenance of large ordered indexes, Acta Informatica, 1972. O artigo original da B-tree.
- Documentação do MySQL, Clustered and Secondary Indexes. Como o InnoDB armazena linhas e o que seus índices secundários contêm.
- Documentação do PostgreSQL, Using EXPLAIN.
- Documentação do SQLite, EXPLAIN QUERY PLAN. A ferramenta usada no experimento acima.
- Markus Winand, Use The Index, Luke. Um livro gratuito sobre indexação SQL para desenvolvedores; cobre a ordem de índices compostos e a paginação por keyset ("no offset").
- Documentação do PostgreSQL, Index-Only Scans and Covering Indexes.
- Documentação do PostgreSQL, Partial Indexes e Multicolumn Indexes.
Pratique este tema: Databases