Posted on: March 05, 2024 11:43 AM

Posted by: Renato

Categories: bancodedados postgresql sql database dba inteligenciadedados

Views: 155

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 autores – tbl_Autor

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

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):

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.

#governancadedados #erwin #inteligenciadedados #modelagemdedados #bancodedados #tiposdechaves #primarykey #database

Fonte> Fábio dos Reis

- https://www.bosontreinamentos.com.br/postgresql-banco-dados/criando-chave-estrangeira-em-postgresql/

Renato

Developer

No comments yet! Be the first to comment