Olá galera o/
Depois de um tempo focando em lives e eventos, vamos voltar as nossas amadas postagens técnicas. Irei fazer uma série de postagens sobre as restrições de domínio vulgo constraints. Iremos abordar sobre primary keys, foreign key, unique, not null, default e check. Como extra, vamos falar da cláusula identity, lembrando que essa cláusula não se categoriza como constraint.
Let’s go para nosso primeiro episódio Guys!!!
O que é a Primary Key (PK)?
Constraint que identifica um(a) (ou mais) atributo(s) ou coluna(s) como identificador(es) da tabela. Ou seja, é uma característica do atributo/coluna informando que, aquela informação é única em toda a tabela em questão e não haverá outro registro com aquele identificador único através dela. Chave primária é a tradução em português para a palavra Primary Key, também podemos utilizar a sigla PK. A partir de agora vamos utilizar apenas PK, ok?!
Lembrando que, na teoria, valores de PKs não podem se repetir, o exemplo mais simples que posso mencionar aqui é a utilização do(a) atributo/coluna Matricula da escola/faculdade. É um código único dentro de uma possível tabela de Aluno que identifica cada aluno como único dentro da tabela. Vale ressaltar que, posso possuir 2 alunos com o mesmo nome, porém, suas matriculas serão Distintas.
Possuímos 2 tipos de PKs, os tipos Simples e Composta.
Simples: Quando uma tabela possuí apenas um(a) atributo/coluna definido como PK.
Composto: Quando uma tabela possuí mais de um(a) atributo/coluna definido como PK.
Ao definir um(a) atributo/coluna como PK, alguns SGBDs criam um índice clusterizado (Clustered Index) na tabela. Isso é assunto para outro post no futuro.
Outro fato é que, quando definimos um(a) atributo/coluna como PK, a mesma também recebe a restrição NOT NULL (não aceita nulos). Em breve faremos um post dessa constraint.
Boa prática!
Ao criar uma tabela sempre tente definir um(a) ou mais atributos/colunas como PK. Uma PK forte evita duplicações de registros na tabela.
Para facilitar o entendimento, unificaremos tudo que for referente a atributo, coluna ou campo, utilizaremos a palavra coluna (Column).
Praticando a criação de PKs!
A partir de agora, começaremos a praticar a criação de PKs e ver como as mesmas se comportam quando tentamos inserir valores iguais nas colunas.
1 – Criando a database db_constraints
Criemos uma database chamada db_constraints
Create database db_constraints
use db_constraints
2 – Tabela tb_pk – PK Simples
2.1 – Uma vez com a database criada, vamos criar uma tabela chamada tb_pk que contém uma única PK. O id foi definido como campo PK, ou seja, ele não pode receber valores iguais. Quando você cria uma PK sem declarar o nome da constraint o SGBD cria o nome automaticamente.
-- Maneira 01 de criar tabela com PK sem declarar o nome da constraint
create table tb_pk
(
id smallint primary key,
letra char(1)
)
-- Maneira 02 de criar tabela com PK sem declarar o nome da constraint
CREATE TABLE tb_pk(
id smallint,
letra char(1) ,
PRIMARY KEY (id) -- a declaração da PK fica no final do comando. As colunas que serão chave devem ficar entre os parênteses.
)
-- Maneira 03 de criar tabela com PK declarando o nome da constraint
create table tb_pk
(
id smallint CONSTRAINT pk_id primary key,
letra char(1)
)
2.2 – Vamos inserir 3 registros
insert into tb_pk (id, letra)
values (1, 'A'), (2,'G')
insert into tb_pk (id, letra)
values (3, 'B')
2.3- Vamos consultar os registros na tabela
select * from tb_pk
2.4 – Vamos tentar inserir novo registro com o valor de um id já existente. O id 3 já está associado a letra B. Podemos ter outra letra B, porém, a mesma deve ter um id diferente.
Erro apresentado:
Violation of PRIMARY KEY constraint ‘PK__tb_pk__3213E83F8A559BEB’.
Cannot insert duplicate key in object ‘dbo.tb_pk’. The duplicate key value is (3).
insert into tb_pk (id, letra)
values (3, 'F')
2.5 – Resolvendo problema da chave duplicada. Passar um novo valor de id distinto. Depois fazer um novo select para verificar os dados.
insert into tb_pk (id, letra)
values (4, 'F')select * from tb_pk
3 – Tabela tb_pk2 – Adicionando PK depois de uma tabela já criada.
3.1 – Obs.: Para adicionar uma PK após termos criado uma tabela sem pk, é necessário criar a coluna que vai receber a PK como NOT NULL (Não aceita nulos).
create table tb_pk2
(
id smallint ,
letra char(1)
)
3.2 – Alterando a tabela, adicionando o ID como PK. Um erro será apresentado porque a coluna ID não é not null
Erro apresentado:
Cannot define PRIMARY KEY constraint on nullable column in table ‘tb_pk2’.
ALTER TABLE tb_pk2
ADD PRIMARY KEY(id);
3.3 – Vamos apagar a tabela e realizar o procedimento novamente
drop table tb_pk23.4 – Criando a tabela novamente
create table tb_pk2
(
id smallint not null,
letra char(1)
)
3.4 – Alterando a tabela, adicionando o ID como PK. Aqui definimos o nome da constraint.
ALTER TABLE tb_pk2
ADD CONSTRAINT pk_id2
PRIMARY KEY (id)
3.5 – Caso queira excluir a constraint PK de uma coluna em que foi definida anteriormente, precisaremos apagar a constraint da coluna. Para fazermos isso, nos devemos apagar pelo nome da constraint. Caso a constraint não tenha o nome customizado, lembrar de colocar a constraint gerada automaticamente pelo SGBD.
ALTER TABLE tb_pk2
DROP CONSTRAINT pk_id2
4 – Tabela tb_pk3 – PK Composta
4.1 – Para criarmos uma tabela com PK Composta precisaremos criar da maneira 2 (como citado no item 2.1). Criaremos uma tabela que contém 2 colunas que identificam o registro como único na tabela, as colunas escolhidas foram ID e Letra, ou seja, a combinação das duas chaves informa que um registro é único.
create table tb_pk3
(
id smallint,
letra char(1),
nome varchar(20),
constraint pk_composta primary key (id, letra) -- as duas ou mais colunas devem ficar entre parênteses.
)
4.2 – Vamos inserir 3 registros na tabela
insert into tb_pk3 (id, letra, nome)
values
(1,'A','Atena'),
(1,'B','May'),
(1,'C','Gigi')
4.3 – Consultando os registros da tabela
select * from tb_pk3
4.4 – Inserindo um novo registro e analisando a tabela
insert into tb_pk3 (id, letra, nome)
values (1,'D','Amarelinho')
select *
from tb_pk3
4.5 – Percebam que, para identificarmos o registro “Atena”, utilizamos a combinação das colunas ID e LETRA, ou seja, valor 1 para o ID e o valor A para a LETRA.
4.6 – Agora iremos simular a inclusão de um novo registro na tabela com os valores de PK iguais a um registro existente. Tentaremos inserir um novo registro chamado “Princesa”, utilizando a combinação de chaves 1 para id e D para letra.
Erro Apresentado:
Violation of PRIMARY KEY constraint ‘pk_composta’. Cannot insert duplicate key in object ‘dbo.tb_pk3’.
The duplicate key value is (1, D).
insert into tb_pk3 (id, letra, nome)
values (1,'D','Princesa')
4.7 – Vamos tentar novamente – Inserindo um novo registro chamado “Princesa”, porém, iremos utilizar uma combinação de PKs não existente na tabela. Após realizar o insert, conferiremos os dados na tabela utilizando um select.
insert into tb_pk3 (id, letra, nome)
values (2,'D','Princesa')
5 – Considerações Finais
No episódio 01 aprendemos um pouco sobre a constraint Primary Key, como criar uma tabela com PK simples e composta, como adicionar uma PK em uma tabela já existente. o que acontece quando tentamos inserir registros duplicados e como se comportam os dados nas tabelas com PK.
Este é o primeiro de 6 posts sobre as constraints, fiquem atentos aos próximos episódios dessa série.
Espero que tenham gostado pessoal, boa leitura e bons estudos!
Quem quiser mandar comentários, sugestões, críticas ou dicas complementares, fiquem a vontade, pois feedbacks positivos ou negativos engradecem meu conhecimento para poder melhorar as postagens para vocês.
Até a próxima o/
Acessem nossas Redes Sociais:
Consulta BD 