Postgres e índices em chaves estrangeiras e chaves primárias

342

O Postgres coloca índices automaticamente em Chaves estrangeiras e Chaves primárias? Como posso eu saber? Existe um comando que retornará todos os índices em uma tabela?

mainstringargs
fonte

Respostas:

405

O PostgreSQL cria automaticamente índices em chaves primárias e restrições exclusivas, mas não no lado de referência dos relacionamentos de chave estrangeira.

Quando o Pg cria um índice implícito, ele emite uma NOTICEmensagem de nível que você pode ver nos psqllogs do sistema e / ou para que você possa ver quando isso acontece. Os índices criados automaticamente também são visíveis na \dsaída de uma tabela.

A documentação sobre índices exclusivos diz:

O PostgreSQL cria automaticamente um índice para cada restrição exclusiva e restrição de chave primária para impor exclusividade. Portanto, não é necessário criar um índice explicitamente para as colunas da chave primária.

e a documentação sobre restrições diz:

Como um DELETE de uma linha da tabela referenciada ou um UPDATE de uma coluna referenciada exigirão uma varredura da tabela de referência em busca de linhas que correspondam ao valor antigo, geralmente é uma boa ideia indexar as colunas de referência. Como isso nem sempre é necessário, e há muitas opções disponíveis sobre como indexar, a declaração de uma restrição de chave estrangeira não cria automaticamente um índice nas colunas de referência.

Portanto, você deve criar índices em chaves estrangeiras, se desejar.

Observe que, se você usar chaves estrangeiras primárias, como 2 FKs como PK em uma tabela M para N, terá um índice na PK e provavelmente não precisará criar índices extras.

Embora seja geralmente uma boa ideia criar um índice (ou incluindo) suas colunas de chave estrangeira no lado da referência, isso não é obrigatório. Cada índice de adicionar retarda Operações DML ligeiramente para baixo, de modo que você paga um custo de desempenho em cada INSERT, UPDATEou DELETE. Se o índice for raramente usado, pode não valer a pena.

Philipp
fonte
26
Espero que esta edição esteja correta; Adicionei links à documentação relevante, uma citação que torna totalmente explícito que o lado de referência dos relacionamentos FK não produz um índice implícito, mostrei como ver índices no psql, reformulei o 1º par para maior clareza e adicionei um observe que os índices não são gratuitos, portanto nem sempre é correto adicioná-los.
Craig Ringer
11
@ CraigRinger, como você determina se o benefício de um índice ultrapassa seu custo? Analiso os testes de unidade antes / depois de adicionar um índice e verifico se há um ganho geral de desempenho? Ou há uma maneira melhor?
Gili
2
@ Gili Esse é um tópico para uma pergunta separada do dba.stackexchange.com.
Craig Ringer
34

Se você deseja listar os índices de todas as tabelas nos seus esquemas do seu programa, todas as informações estão disponíveis no catálogo:

select
     n.nspname  as "Schema"
    ,t.relname  as "Table"
    ,c.relname  as "Index"
from
          pg_catalog.pg_class c
     join pg_catalog.pg_namespace n on n.oid        = c.relnamespace
     join pg_catalog.pg_index i     on i.indexrelid = c.oid
     join pg_catalog.pg_class t     on i.indrelid   = t.oid
where
        c.relkind = 'i'
    and n.nspname not in ('pg_catalog', 'pg_toast')
    and pg_catalog.pg_table_is_visible(c.oid)
order by
     n.nspname
    ,t.relname
    ,c.relname

Se você quiser aprofundar mais (como colunas e pedidos), é necessário consultar pg_catalog.pg_index. O uso psql -E [dbname]é útil para descobrir como consultar o catálogo.

dland
fonte
4
+1 porque o uso de pg_catalog e -E psql é realmente muito útil
Ghislain Leveque
"Para referência \ditambém listará todos os índices no banco de dados." (comentário copiado formar outra resposta, se aplica aqui também)
Risadinha
33

Essa consulta listará os índices ausentes nas chaves estrangeiras , fonte original .

Editar : Observe que ele não verifica tabelas pequenas (menos de 9 MB) e alguns outros casos. Veja a WHEREdeclaração final .

-- check for FKs where there is no matching index
-- on the referencing side
-- or a bad index

WITH fk_actions ( code, action ) AS (
    VALUES ( 'a', 'error' ),
        ( 'r', 'restrict' ),
        ( 'c', 'cascade' ),
        ( 'n', 'set null' ),
        ( 'd', 'set default' )
),
fk_list AS (
    SELECT pg_constraint.oid as fkoid, conrelid, confrelid as parentid,
        conname, relname, nspname,
        fk_actions_update.action as update_action,
        fk_actions_delete.action as delete_action,
        conkey as key_cols
    FROM pg_constraint
        JOIN pg_class ON conrelid = pg_class.oid
        JOIN pg_namespace ON pg_class.relnamespace = pg_namespace.oid
        JOIN fk_actions AS fk_actions_update ON confupdtype = fk_actions_update.code
        JOIN fk_actions AS fk_actions_delete ON confdeltype = fk_actions_delete.code
    WHERE contype = 'f'
),
fk_attributes AS (
    SELECT fkoid, conrelid, attname, attnum
    FROM fk_list
        JOIN pg_attribute
            ON conrelid = attrelid
            AND attnum = ANY( key_cols )
    ORDER BY fkoid, attnum
),
fk_cols_list AS (
    SELECT fkoid, array_agg(attname) as cols_list
    FROM fk_attributes
    GROUP BY fkoid
),
index_list AS (
    SELECT indexrelid as indexid,
        pg_class.relname as indexname,
        indrelid,
        indkey,
        indpred is not null as has_predicate,
        pg_get_indexdef(indexrelid) as indexdef
    FROM pg_index
        JOIN pg_class ON indexrelid = pg_class.oid
    WHERE indisvalid
),
fk_index_match AS (
    SELECT fk_list.*,
        indexid,
        indexname,
        indkey::int[] as indexatts,
        has_predicate,
        indexdef,
        array_length(key_cols, 1) as fk_colcount,
        array_length(indkey,1) as index_colcount,
        round(pg_relation_size(conrelid)/(1024^2)::numeric) as table_mb,
        cols_list
    FROM fk_list
        JOIN fk_cols_list USING (fkoid)
        LEFT OUTER JOIN index_list
            ON conrelid = indrelid
            AND (indkey::int2[])[0:(array_length(key_cols,1) -1)] @> key_cols

),
fk_perfect_match AS (
    SELECT fkoid
    FROM fk_index_match
    WHERE (index_colcount - 1) <= fk_colcount
        AND NOT has_predicate
        AND indexdef LIKE '%USING btree%'
),
fk_index_check AS (
    SELECT 'no index' as issue, *, 1 as issue_sort
    FROM fk_index_match
    WHERE indexid IS NULL
    UNION ALL
    SELECT 'questionable index' as issue, *, 2
    FROM fk_index_match
    WHERE indexid IS NOT NULL
        AND fkoid NOT IN (
            SELECT fkoid
            FROM fk_perfect_match)
),
parent_table_stats AS (
    SELECT fkoid, tabstats.relname as parent_name,
        (n_tup_ins + n_tup_upd + n_tup_del + n_tup_hot_upd) as parent_writes,
        round(pg_relation_size(parentid)/(1024^2)::numeric) as parent_mb
    FROM pg_stat_user_tables AS tabstats
        JOIN fk_list
            ON relid = parentid
),
fk_table_stats AS (
    SELECT fkoid,
        (n_tup_ins + n_tup_upd + n_tup_del + n_tup_hot_upd) as writes,
        seq_scan as table_scans
    FROM pg_stat_user_tables AS tabstats
        JOIN fk_list
            ON relid = conrelid
)
SELECT nspname as schema_name,
    relname as table_name,
    conname as fk_name,
    issue,
    table_mb,
    writes,
    table_scans,
    parent_name,
    parent_mb,
    parent_writes,
    cols_list,
    indexdef
FROM fk_index_check
    JOIN parent_table_stats USING (fkoid)
    JOIN fk_table_stats USING (fkoid)
WHERE table_mb > 9
    AND ( writes > 1000
        OR parent_writes > 1000
        OR parent_mb > 10 )
ORDER BY issue_sort, table_mb DESC, table_name, fk_name;
SergeyB
fonte
7
Não parece funcionar. Retorna 0 linhas quando eu sei que tenho colunas sem índices que fazem referência a tabelas de domínio.
juanitogan
6
@juanitogan Assista às wherecláusulas: Entre outras, apenas são consideradas tabelas com tamanho superior a 9 MB.
Matthias
@ Matthias - Ah, entendi. Obrigado. Sim, eu obviamente não tive tempo para ler o código. Não era crítico o suficiente para incomodar. O OP poderia ter mencionado as limitações. Talvez eu deva verificar novamente algum dia.
Juanitogan 31/03
@SergeyB, parece dar falso positivo em colunas referenciadas com restrição de chave primária, tendo automaticamente um índice, mas a consulta ainda as sinaliza.
Debasish Mitra 22/03/18
21

Sim - para chaves primárias, não - para chaves estrangeiras (mais nos documentos ).

\d <table_name>

em "psql" mostra uma descrição de uma tabela incluindo todos os seus índices.

Milen A. Radev
fonte
11
Para referência \ di também listará todos os índices no banco de dados.
Daemin 19/02/10
14

Adoro como isso é explicado no artigo Recursos interessantes de desempenho do EclipseLink 2.5

Indexação de chaves estrangeiras

O primeiro recurso é a indexação automática de chaves estrangeiras. A maioria das pessoas supõe incorretamente que os bancos de dados indexam chaves estrangeiras por padrão. Bem, eles não. As chaves primárias são indexadas automaticamente, mas as chaves estrangeiras não. Isso significa que qualquer consulta baseada na chave estrangeira fará varreduras completas da tabela. Este é qualquer relacionamento OneToMany , ManyToMany ou ElementCollection , bem como muitos relacionamentos OneToOne , e a maioria das consultas sobre qualquer relacionamento que envolva junções ou comparações de objetos . Esse pode ser um problema de desempenho importante e você sempre deve indexar seus campos de chaves estrangeiras.

Nabi
fonte
5
Se devemos sempre indexar nossos campos de chaves estrangeiras, por que os mecanismos de banco de dados já não fazem isso? Parece-me que há mais do que aparenta.
Bobort
3
@Bobort Como a adição de índice incorre em penalidade de desempenho em todas as inserções, atualizações e exclusões, e muitas chaves estrangeiras podem realmente ser adicionadas nesse caso. É por isso que esse comportamento é opcional, eu acho - o desenvolvedor deve fazer escolhas conscientes nesse assunto. Também pode haver casos em que a chave estrangeira é usada para impor a integridade dos dados, mas não é consultada com frequência ou de forma alguma - nesse caso, a penalidade de desempenho do índice seria inútil
Dr.Strangelove
3
Também existem casos complicados com índices compostos, uma vez que esses são aplicados da esquerda para a direita: ou seja, o índice composto em [user_id, article_id] na tabela de comentários cobriria efetivamente a consulta de TODOS os comentários do usuário (por exemplo, para mostrar o log de comentários agregados no site) e a busca de todos comentários feitos por esse usuário para um artigo específico. Adicionar um índice separado em user_id, nesse caso, é efetivamente um desperdício de espaço em disco e tempo de CPU em inserções / atualizações / exclusões.
Dr.Strangelove
2
Aha! Então o conselho é ruim! Nem sempre devemos indexar nossas chaves estrangeiras. Como @ Dr.Strangelove apontou, na verdade existem momentos em que não queremos indexá-los! Muito obrigado, Dr.!
Bobort
Por que eles não são indexados por padrão? Existe um caso de uso importante que torna isso necessário?
Adam Arold 22/08/19
7

Para a PRIMARY KEY, um índice será criado com a seguinte mensagem:

NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "index" for table "table" 

Para um FOREIGN KEY, a restrição não será criada se não houver nenhum índice na referenc ed mesa.

Um índice de referenc ing mesa não é necessária (embora desejado), e, portanto, não será criado implicitamente.

Quassnoi
fonte