Retângulos não sobrepostos restritos a um limite

Resposta básica

Sugiro o tipo geométricobox e uma restrição de exclusão (Postgres 9.2+ ). Deve ser a solução perfeita para o seu problema. Ele cria implicitamente um índice GiST que também oferece suporte a determinadas consultas.

Combine-o com igualdade board_idpara permitir várias placas em uma única tabela. Você precisará do módulo adicional btree_gist. Uma vez por banco de dados:

CREATE EXTENSION btree_gist;

Para limitar as peças a uma placa, adicione uma CHECKrestrição . Você precisa da caixa confinante do tabuleiro na board_partmesa (redundante). Poderia ficar assim:

CREATE TABLE board_part (
  board_id bigint NOT NULL REFERENCES board
, board_box box NOT NULL
, part_id bigint NOT NULL REFERENCES part
, part_box box NOT NULL
, EXCLUDE USING gist (board_id WITH =, part_box WITH &&)
, CHECK (part_box <@ board_box)
);

&&.. operador "overlaps"
<@.. operador "contido"

A desvantagem: você precisa das dimensões de cada peça e caixa na tabela de forma board_partredundante.

Resposta avançada

Para evitar armazenamento redundante, gosto mais dessa nova ideia: IMMUTABLEfunções falsas que retornam a caixa para um id e criam restrições sobre essas funções. Suas tabelas podem se contentar apenas com as colunas de seu design original.

Fiz um teste completo para verificar se funciona.

esquema completo

Tabelas básicas:

CREATE TABLE part (
  part_id serial PRIMARY KEY
, part text NOT NULL
, wide int NOT NULL
, high int NOT NULL
);

CREATE TABLE board (
  board_id serial PRIMARY KEY
, board text NOT NULL
, wide int NOT NULL
, high int NOT NULL
);

IMMUTABLEfunções:

CREATE OR REPLACE FUNCTION f_boardbox(_board_id int)
  RETURNS box
  LANGUAGE sql IMMUTABLE AS
'SELECT box(point(0,0), point (b.wide, b.high))
 FROM   public.board b WHERE board_id = $1'; 

CREATE OR REPLACE FUNCTION f_partbox(_part_id int, _wide int, _high int)
  RETURNS box
  LANGUAGE sql IMMUTABLE AS
'SELECT box(point($2,$3), point($2 + p.wide, $3 + p.high))
 FROM   public.part p WHERE part_id = $1';

Substitua publicpelo esquema real de suas tabelas.
No Postgres 9.6 ou posterior, adicione PARALLEL SAFE. Ver:

• Quando marcar funções como PARALLEL RESTRICTED vs PARALLEL SAFE?

Tabela principal:

CREATE TABLE board_part (
  board_id int NOT NULL REFERENCES board
, part_id int NOT NULL REFERENCES part
, wide int NOT NULL
, high int NOT NULL
, EXCLUDE USING gist (board_id WITH =, f_partbox(part_id, wide, high) WITH &&)
, CHECK (f_partbox(part_id, wide, high) <@ f_boardbox(board_id))
);

Obviamente, se você atualizar as dimensões para um board_idou part_idem uso, anulará parcialmente o índice e/ou a restrição. Você precisaria recriar qualquer índice ou restrição com base na promessa de que o valor de retorno da IMMUTABLEfunção nunca muda. Ver:

• O PostgreSQL suporta collations “insensíveis a acentos”?

No entanto, você pode evitar essa operação cara com gatilhos para atualizar apenas as linhas afetadas:

Gatilhos

CREATE OR REPLACE FUNCTION f_board_upaft()
  RETURNS trigger
  LANGUAGE plpgsql AS
$func$
BEGIN
   UPDATE board_part
   SET    board_id = board_id        -- enough to trigger CHECK constraint
   WHERE  board_id = NEW.board_id;   -- limit to relevant rows

   RETURN NULL;
END
$func$;

CREATE TRIGGER board_upaft
AFTER UPDATE OF wide, high ON board  -- limit to relevant columns
FOR EACH ROW EXECUTE PROCEDURE f_board_upaft();


CREATE OR REPLACE FUNCTION f_part_upaft()
  RETURNS trigger
  LANGUAGE plpgsql AS
$func$
BEGIN
   UPDATE board_part
   SET    part_id = 0
   WHERE  part_id = NEW.part_id;

   UPDATE board_part
   SET    part_id = NEW.part_id
   WHERE  part_id = 0;               -- enough to update EXCL. constraint

   RETURN NULL;
END
$func$;

CREATE TRIGGER part_upaft
AFTER UPDATE OF wide, high ON part
FOR EACH ROW EXECUTE PROCEDURE f_part_upaft();

part_id = 0é uma linha especial na tabela partcom tamanho 0. Necessária para o gatilho.

Dados de teste:

INSERT INTO board (board, wide, high)
VALUES ('b1010',10,10), ('b2030',20, 30);

INSERT INTO part (part_id, part, wide, high)
VALUES (0,'p0',0,0);          -- special row needed for trigger!

INSERT INTO part (part, wide, high)
VALUES ('p11',1,1), ('p33',3,3);

INSERT INTO board_part (board_id, part_id, wide, high)
VALUES (1,1,3,3)
     , (1,1,5,5)   -- no overlap, inside board
     , (2,1,3,3);  -- different board, no overlap

Teste

Estes devem gerar exceções se os gatilhos e restrições fizerem seu trabalho:

UPDATE part SET wide = 6 , high = 6
WHERE  part_id = 1;            -- violates EXCL. & CHECK constraint

UPDATE part SET wide = 3 , high = 3
WHERE  part_id = 1;            -- violates EXCL. constraint

UPDATE board SET wide = 2 , high = 2
WHERE  board_id = 1;            -- violates CHECK constraint

db<>fiddle aqui
_{Old sqlfiddle}