Aplicação de restrições a “duas mesas de distância”

Eu tive alguns problemas ao modelar um esquema elétrico no SQL. A estrutura que eu gostaria de capturar é

  part ←────────── pin
   ↑                ↑
part_inst ←───── pin_inst

onde "inst" é a abreviação de "instance".

Por exemplo, eu posso ter como um partamplificador operacional LM358 com pins 1OUT, 1IN-, 1IN +, GND, 2IN +, 2IN-, 2OUT e V _CC . Eu poderia então colocar esta parte em um esquema, criando a part_inste 8 pin_insts.

Ignorando os campos de dados, minha tentativa inicial de um esquema foi

create table parts (
    part_id bigserial primary key
);
create table pins (
    pin_id bigserial primary key,
    part_id bigint not null references parts
);
create table part_insts (
    part_inst_id bigserial primary key,
    part_id bigint not null references parts
);
create table pin_insts (
    pin_inst_id bigserial primary key,
    part_inst_id bigint not null references part_insts,
    pin_id bigint not null references pins
);

O principal problema com esse esquema é que um pin_instpode estar vinculado a um part_instcom part_id=1mas pintem part_id=2.

Eu gostaria de evitar esse problema no nível do banco de dados e não no nível do aplicativo. Então, eu modifiquei minhas chaves primárias para impor isso. Marquei as linhas alteradas com --.

create table parts (
    part_id bigserial primary key
);
create table pins (
    pin_id bigserial,                                          --
    part_id bigint not null references parts,
    primary key (pin_id, part_id)                              --
);
create table part_insts (
    part_inst_id bigserial,                                    --
    part_id bigint not null references parts,
    primary key (part_inst_id, part_id)                        --
);
create table pin_insts (
    pin_inst_id bigserial primary key,
    part_inst_id bigint not null,                              --
    pin_id bigint not null,                                    --
    part_id bigint not null references parts,                  --
    foreign key (part_inst_id, part_id) references part_insts, --
    foreign key (pin_id, part_id) references pins              --
);

Minha queixa com esse método é que polui as chaves primárias: em todos os lugares em que me refiro a part_inst, preciso acompanhar tanto o part_inst_idquanto o part_id. Existe outra maneira de impor a restrição pin_inst.part_inst.part_id = pin_inst.pin.part_idsem ser excessivamente detalhado?

Solução mínima

Uma solução radical pode ser remover pin_instcompletamente:

  part ←────────── pin
    ↑               ↑
part_inst ←───── pin_inst

Não há nada na sua pergunta que sugira que você realmente precise da tabela redundante. Para pins associado a a part_inst, observe os pins do associado part.

Isso simplificaria o código para:

create table part (    -- using singular terms for table names
    part_id bigserial primary key
);
create table pin (
    pin_id bigserial primary key,
    part_id bigint not null references part
);
create table part_inst (
    part_inst_id bigserial primary key,
    part_id bigint not null references part
);

^{Mas seu comentário deixou claro que não vamos nos safar disso ...}

Alternativa se pin_instfor necessário

Incluir part_idcomo você fez é a solução mais simples com restrições de chave estrangeira. Você não pode fazer referência a uma tabela "a duas tabelas de distância" com restrições de chave estrangeira .

Mas você pode pelo menos se contentar sem "poluir" as chaves primárias. Adicione UNIQUErestrições .

create table part (
    part_id bigserial primary key
);
create table pin (
    pin_id bigserial primary key,
    part_id bigint not null references part,
    unique(part_id, pin_id)         -- note sequence of columns
);
create table part_inst (
    part_inst_id bigserial primary key,
    part_id bigint not null references part,
    unique(part_id, part_inst_id)
);
create table pin_inst (
    pin_inst_id bigserial primary key,
    part_inst_id bigint not null,
    pin_id bigint not null,
    part_id bigint not,
    foreign key (part_id, pin_id) references pin,
    foreign key (part_id, part_inst_id) references part_inst
);

Coloquei part_idprimeiro as restrições únicas. Isso é irrelevante para a integridade referencial, mas é importante para o desempenho. As chaves primárias já implementam índices para as colunas pk. É melhor ter a outra coluna primeiro nos índices de várias colunas implementando as restrições exclusivas. Detalhes sobre estas perguntas relacionadas:

• Trabalho de índices no PostgreSQL
• Um índice composto também é bom para consultas no primeiro campo?
• Muitas para muitas e entidades fracas

Perguntas relacionadas ao SO:

• Uma restrição UNIQUE de vários campos pode incluir campos de mais de uma tabela?
• Restrição de chave estrangeira com alguns valores de coluna residentes em outras tabelas

Alternativa com gatilhos

Você pode recorrer a funções de gatilhos, que são mais flexíveis, mas um pouco mais complicadas, propensas a erros e um pouco menos rigorosas. O benefício: você poderia prescindir part_inst.part_ide pin.part_id...