Constraints no PostgreSQL (Restrições)

Constraints no PostgreSQL

Constraints, ou Restrições, são regras específicas aplicadas nas colunas de uma tabela, ou na tabela em si. É possível definir restrições em colunas e em tabelas, permitindo um grande controle sobre os dados armazenados. Caso um usuário tente armazenar dados em uma coluna de forma a violar uma restrição, um erro será gerado. Ou seja, são usadas para limitar os tipos de dados que são inseridos.

As constraints podem ser especificadas no momento de criação da tabela (comando CREATE TABLE) ou após a tabela ter sido criada (comando ALTER TABLE).

As principais constraints SQL disponíveis no PostgreSQL são as seguintes:

  • NOT NULL
  • CHECK
  • UNIQUE
  • PRIMARY KEY
  • FOREIGN KEY

Vamos explorar cada uma dessas restrições a seguir.

NOT NULL

A constraint NOT NULL impede que uma uma coluna a aceite valores NULL (nulos). Ou seja, a constraint NOT NULL obriga um campo a sempre possuir um valor inserido.

Deste modo, não é possível inserir (ou atualizar) um registro sem entrar com um dado neste campo. Veja o exemplo:

CREATE TABLE Alunos (
  ID_Aluno integer,
  Nome_Aluno text NOT NULL,
  Idade numeric
);

No exemplo acima a coluna Nome_Aluno possui a restrição NOT NULL, o que significa que é obrigatório entrar com um nome de aluno ao criar um novo registro.

Uma dica importante é a de que na maioria dos casos, as colunas nas tabelas de um banco de dados devem ser configuradas como NOT NULL, exceto quando estritamente necessário.

UNIQUE

  • A restrição UNIQUE assegura que os dados contidos em uma coluna ou grupo de colunas em uma tabela do banco de dados sejam únicos.
  • As constraints UNIQUE e PRIMARY KEY garantem a unicidade em uma coluna ou conjunto de colunas.
  • É possível termos várias constraints UNIQUE em uma mesma tabela, mas apenas uma Chave Primária por tabela (lembrando que uma PK pode ser composta, ou seja, constituída por mais de uma coluna - mas ainda assim, será uma única chave primária).

Vamos a um exemplo. Na tabela a seguir queremos garantir que não haja repetição de dados na coluna CPF:

CREATE TABLE Alunos (
  ID_Aluno integer,
  Nome_Aluno text NOT NULL,
  CPF text UNIQUE,
  Idade numeric
);

Também é possível declarar essa constraint como uma restrição de tabela:

CREATE TABLE Alunos (
  ID_Aluno integer,
  Nome_Aluno text NOT NULL,
  CPF text,
  Idade numeric,
  UNIQUE (CPF)
);

Também podemos aplicar a restrição UNIQUE a um grupo de colunas, como no exemplo:

CREATE TABLE Alunos (
  ID_Aluno integer,
  Nome_Aluno text NOT NULL,
  Hora_Matrícula time,
  CPF text UNIQUE,
  Idade numeric,
  UNIQUE (Nome_Aluno, Hora_Matrícula)
);

Neste exemplo o Nome de Aluno pode se repetir na tabela, assim como mais de um aluno pode se matricular no mesmo hor[ario, porém nao é possível que dois alunos com o mesmo nome se matriculem exatamente no mesmo horário.

E, finalmente, podemos atribuir um nome a uma constraint UNIQUE da forma habitual:

CREATE TABLE Alunos (
  ID_Aluno integer,
  Nome_Aluno text NOT NULL,
  Hora_Matrícula time,
  CPF text UNIQUE,
  Idade numeric,
  CONSTRAINT uq_nome_hora_matr UNIQUE (Nome_Aluno, Hora_Matrícula)
);

PRIMARY KEY

A restrição PRIMARY KEY (Chave Primária) indica que uma coluna ou grupo de colunas identifica de forma única cada registro em uma tabela de banco de dados.

As Chaves Primárias devem sempre conter valores únicos e não-nulos - ou seja, uma chave primária é sempre UNIQUE e NOT NULL. E não é necessário especificar essas constraints quando definimos uma coluna como chave primária.

Cada tabela deve ter uma chave primária e apenas uma chave primária, que pode ser constituída por uma coluna ou por um grupo de colunas (chave primária composta).

No exemplo a seguir, definimos que a coluna ID_Aluno será a chave primária da tabela, sendo utilizada para identificar cada registro de forma exclusiva (não há dois IDs de alunos iguais na tabela):

CREATE TABLE Alunos (
  ID_Aluno integer PRIMARY KEY,
  Nome_Aluno text NOT NULL,
  CPF text,
  Idade numeric,
  UNIQUE (CPF)
);

Também podemos usar a sintaxe a seguir:

CREATE TABLE Alunos (
  ID_Aluno integer,
  Nome_Aluno text NOT NULL,
  CPF text UNIQUE,
  Idade numeric,
  PRIMARY KEY (ID_Aluno)
);

É possível criar uma chave primária combinado duas ou mais colunas da tabela, como mostra o código seguinte:

CREATE TABLE Alunos (
  ID_Aluno integer,
  Nome_Aluno text NOT NULL,
  CPF text,
  Idade numeric,
  PRIMARY KEY (ID_Aluno, CPF)
);

Neste caso a combinação de CPF e ID_Aluno será a chave primária dessa tabela. Esses dois dados não podem se repetir juntos em mais de um registro diferente (mas podem se repetir se não estiverem combinados).

FOREIGN KEY

Uma FOREIGN KEY (Chave Estrangeira) em uma tabela é um campo que aponta para uma chave primária em outra tabela. Desta forma, é usada para criar os relacionamentos entre as tabelas no banco de dados.

Especifica que os valores em uma coluna, ou grupo de colunas, devem corresponder aos valores que estão registrados em uma coluna de outra tabela. Dessa forma é mantida a integridade referencial entre as tabelas relacionadas.

Veja um exemplo de restrição de chave estrangeira aplicada, relacionando duas tabelas de nomes tbl_livros e tbl_autores:

CREATE TABLE tbl_livros (
  ID_Livro integer PRIMARY KEY,
  Nome_Livro text NOT NULL,
  Data_Pub date,
  ID_Autor integer NOT NULL,
  CONSTRAINT fk_ID_Autor FOREIGN KEY (ID_Autor)
  REFERENCES tbl_autores(ID_Autor)
);

Neste exemplo a chave primária está em uma tabela de nome tbl_autores, e uma chave estrangeira de nome fk_ID_Autor foi criada na tabela atual (tbl_livros), usando a coluna de nome ID_Autor (ambas as colunas devem ser do mesmo tipo de dados, em ambas as tabelas relacionadas).

Há muito mais o que ser dito sobre chaves estrangeiras no Postgresql, e o faremos na lição especial sobre o assunto.

CHECK

A constraint CHECK permite especificar se o valor em uma dada coluna deve satisfazer a uma expressão lógica (booleana), ou seja, que pode retornar um valor verdadeiro ou um valor falso. Por exemplo, suponha que desejamos impedir o registro de um valor de idade inferior a 18 anos em uma coluna:

CREATE TABLE Alunos (
  ID_Aluno integer,
  Nome_Aluno text NOT NULL,
  Idade numeric CHECK (Idade >= 18)
);

Desta forma, se tentarmos inserir uma idade com valor abaixo de 18 a expressão lógica Idade > 18 retornará falso, e o registro não será inserido.

Também podemos dar um nome específico a uma constraint CHECK, usando a palavra-chave CONSTRAINT, como mostra o exemplo:

CREATE TABLE Alunos (
  ID_Aluno integer,
  Nome_Aluno text,
  Idade numeric CONSTRAINT maior_de_idade CHECK (Idade >= 18)
);

Também é possível criar uma restrição CHECK que faça referência a mais de uma coluna, ou ainda usar mais de um CHECK na tabela. Veja o exemplo a seguir:

CREATE TABLE Alunos (
  ID_Aluno integer,
  Nome_Aluno text NOT NULL,
  Idade_Mínima integer NOT NULL CHECK (Idade_Mínima > 0),
  Idade_Atual integer,
  CHECK (Idade_Atual >= Idade_Mínima)
);

Note também que a coluna Idade_Mínima possui duas restrições aplicadas: NOT NULL e CHECK. Podemos aplicar quantas restrições forem necessárias nas colunas de uma tabela.

Bibliografia:

Documentação oficial do PostgreSQL - https://www.postgresql.org/docs/

 

Sobre Fábio dos Reis (1209 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 Música, 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


*