Criando uma Chave Estrangeira em PostgreSQL

Chave Estrangeira em PostgreSQL

Uma chave estrangeira é um campo ou conjunto de campos em uma tabela que identifica uma linha em outra tabela, criando um relacionamento entre as duas tabelas. Assim, uma chave estrangeira é uma coluna em uma tabela que faz referência à chave primária de outra tabela.

Uma tabela pode ter várias chaves estrangeiras, dependendo dos relacionamentos existentes com outras tabelas. A tabela que possui a chave estrangeira pode ser chamada de "tabela-filha", e a tabela relacionada, onde se encontra a chave primária, pode ser definida como a "tabela-pai".

Para definir uma chave estrangeira em PostgreSQL, usamos uma constraint de chave estrangeira - "FOREIGN KEY". Essa restrição indica quais valores em uma coluna ou conjunto de campos na tabela-filha possuem correspondência com os valores em um campo ou conjunto de campos na tabela-pai. Desta forma, a chave estrangeira mantém o que chamamos de "integridade referencial" entre essas relações.

Sintaxe Básica

A sintaxe básica da constraint para criar uma chave estrangeira, durante a definição de uma tabela, é a seguinte:

FOREIGN KEY (coluna) REFERENCES tabela-pai (coluna);

É importante notar que ambas as colunas precisam ser exatamente do mesmo tipo de dados para que o relacionamento seja possível.

Como definir a restrição de chave estrangeira

Para nosso exemplo vamos utilizar duas tabelas: tbl_Livro e tbl_Autor, cujas estruturas podem ser vistas a seguir:

Tabela de livros - tbl_Livro

Tabela de livros no PostgreSQL

Tabela de autores - tbl_Autor

Tabela de autores no PostgreSQL

Note que na tabela tbl_Livro temos a identificação do autor pelo seu ID, na coluna ID_Autor, que identifica os autores na tabela relacionada, tbl_Autor, onde é chave primária. Essa coluna define o relacionamento entre as duas tabelas, e é aqui que iremos definir a restrição de chave estrangeira.

Primeiro, vamos criar a tabela de autores, tbl_Autor:

CREATE TABLE tbl_Autor (
 ID_Autor int NOT NULL,
 Nome_Autor varchar(30),
 Sobrenome_Autor varchar(40),
 Data_Nasc date,
 PRIMARY KEY (ID_Autor)
);

Vamos agora criar a tabela de livros, tbl_Livro:

CREATE TABLE tbl_Livro (
 ID_Livro int NOT NULL,
 Nome_Livro varchar(40),
 ID_Autor int NOT NULL,
 ID_Editora int NOT NULL,
 Data_Pub date,
 Genero varchar(25),
 Num_Paginas int,
 PRIMARY KEY (ID_Livro),
 FOREIGN KEY (ID_Autor) REFERENCES tbl_Autor (ID_Autor)
);

Podemos listar as tabelas criadas com o comando \dt.

A definição da chave estrangeira está na declaração

FOREIGN KEY (ID_Autor) REFERENCES tbl_Autor (ID_Autor)

que indica que a coluna ID_Autor da tabela-filha faz referência à coluna ID_Autor da tabela-pai, que é tbl_Autor. Isso cria o relacionamento entre as tabelas no banco de dados.

Outra forma de estabelecer esse relacionamento é simplesmente indicar a referência de uma coluna em sua própria declaração, o que a torna uma chave primária. Neste exemplo poderíamos escrever simplesmente:

ID_Autor int REFERENCES tbl_Autor(ID_Autor);

Em nosso exemplo não especificamos explicitamente um nome para identificação da constraint de chave estrangeira. Nesse caso, o PostgreSQL irá atribuir um nome automaticamente, usando o padrão tabela_coluna_fkey. Neste exemplo, o nome da constraint será tbl_Livro_ID_Autor_fkey, atribuído automaticamente (o sufixo fkey é padrão no PostgreSQL).

EM nosso banco de exemplo consideramos que um livro só pode ter um autor, para simplificar as explicações.

Como Adicionar uma Chave Estrangeira a uma tabela já existente

Podemos também adicionar uma restrição de chave estrangeira a uma tabela já existente, usando a declaração ALTER TABLE, como segue:

ALTER TABLE tabela_filha
ADD CONSTRAINT nome_constraint FOREIGN KEY (coluna) REFERENCES tabela-pai(coluna);

Por exemplo, vamos adicionar uma chave estrangeira para criar um relacionamento entre as tabelas tbl_Livro e uma outra tabela, para cadastro das editoras, chamada tbl_Editora em nosso banco de dados. Primeiro, criamos essa tabela de editoras:

tbl_Editora

tabela de editoras no PostgreSQL

Código SQL:

CREATE TABLE tbl_Editora (  
 ID_Editora int NOT NULL, 
 Nome_Editora varchar(25),
 PRIMARY KEY (ID_Editora)
);

E então alteramos a tabela de livros para incluir a chave necessária para criar o relacionamento entre ambas:

ALTER TABLE tbl_Livro
ADD CONSTRAINT fk_id_editora FOREIGN KEY (ID_Editora) REFERENCES tbl_Editora(ID_Editora);

Esse comando irá criar o relacionamento entre as tabelas por meio dos campos de ID da editora.

Após criar as chaves estrangeiras e estabelecer os relacionamentos entre as tabelas, teremos a seguinte estrutura criada em nosso banco de dados (clique sobre a imagem para vê-la em tamanho ampliado):

Banco de Dados de Biblioteca PostrgeSQL

Também é possível consultar os relacionamentos criados em cada tabela usando o comando \d+ nome_tabela, como segue:

\d+ tbl_Livro\d+ tbl_Autor\d+ tbl_Editora

Criando Chave Estrangeira Composta

Uma Foreign Key pode ser composta de mais de uma coluna, e sua declaração será feita da seguinte forma:

FOREIGN KEY (col1, col2) REFERENCES tabela-pai (col1, col2);

Bem simples, bastando especificar as colunas que comporão a chave estrangeira e as colunas referenciadas na mesma ordem.

Cláusulas ON DELETE / ON UPDATE CASCADE

No nosso exemplo, sempre que um livro novo for cadastrado na tabela de livros, é necessário especificar o ID de seu autor, o qual é armazenado na tabela de autores. Pensemos então no seguinte: o que ocorre se um dos autores cadastrados, que possui um livro inserido na tabela de livros, for excluído da tabela de autores?

Neste caso, será impossível excluir o referido autor até que todos os livros cadastrados que o tenham como referência tenham sido excluídos também. Para evitar esse problema, podemos usar a instrução ON DELETE CASCADE ao criar a chave estrangeira, o que fará com que os livros publicados pelo autor também sejam excluídos caso o autor seja eliminado da tabela de autores ("exclusão em cascata").

O mesmo ocorre caso um registro seja atualizado (UPDATE). Se o ID de um autor for modificado na tabela de autores (tabela-pai), deve ser modificado também na tabela de livros (tabela-filho), para refletir a mudança e manter a integridade dos dados. Por padrão, isso não ocorre, e devemos especificar esse comportamento  usando a cláusula ON UPDATE CASCADE.

Desta forma, a declaração da chave ficará assim:

FOREIGN KEY (ID_Autor) REFERENCES tbl_Autor (ID_Autor) ON DELETE CASCADE ON UPDATE CASCADE;

Se não forem especificadas as cláusulas ON DELETE / ON UPDATE, o PostgreSQL utilizará a opção padrão NO ACTION, a qual gera um erro ao tentar-se excluir ou atualizar um registro que possua dados referenciados em uma tabela em uma chave estrangeira.

É isso aí! Neste tutorial mostramos como criar um chave estrangeira em uma tabela no PostgreSQL, para criar relacionamentos entre as tabelas de um banco de dados.

 

Sobre Fábio dos Reis (1198 Artigos)
Fábio dos Reis trabalha com tecnologias variadas há mais de 25 anos, tendo atuado nos campos de Eletrônica, Telecomunicações, Programação de Computadores e Redes de Dados. É um entusiasta de Unix, Linux e Open Source em geral, adora Eletrônica e Astronomia, e estuda idiomas, além de ministrar cursos e palestras sobre diversas tecnologias em São Paulo e outras cidades do Brasil.
Contato: Website

Escreva um comentário

Seu e-mail não será divulgado


*