Como criar uma chave primária no SQL Server (Exemplos de T-SQL)

Este artigo demonstra como criar uma chave primária no SQL Server ao criar uma tabela usando o Transact-SQL.

Uma chave primária é uma ou mais colunas que foram configuradas como o identificador exclusivo de uma determinada tabela. As chaves primárias podem ser usadas para impor a integridade dos dados na tabela.

Uma tabela pode ter apenas uma chave primária e as chaves primárias só podem ser adicionadas a colunas definidas como NOT NULL .

Este artigo demonstra como criar uma chave primária em um novo tabela (ou seja, ao criar a tabela). Se você precisar criar uma chave primária em um existente tabela, consulte Como adicionar uma chave primária a uma tabela existente no SQL Server.

Exemplo 1 – Criar uma tabela com uma chave primária

Primeiro vou criar um banco de dados de teste:

CREATE DATABASE PK_Test;

Agora crie uma nova tabela que inclua uma restrição de chave primária:

USE PK_Test;

CREATE TABLE Colors
(
    ColorId int IDENTITY (1,1) NOT NULL PRIMARY KEY,
    ColorName varchar(50)
);

Isso criou uma nova tabela chamada Colors que tem uma restrição de chave primária em seu ColorId coluna.

Exemplo 2 – Verifique a restrição de chave primária

Podemos executar o seguinte código para retornar uma lista de restrições de chave primária no banco de dados:

SELECT
  name,
  type,
  unique_index_id,
  is_system_named
FROM sys.key_constraints
WHERE type = 'PK';

Resultado:

+------------------------------+--------+-------------------+-------------------+
| name                         | type   | unique_index_id   | is_system_named   |
|------------------------------+--------+-------------------+-------------------|
| PK__Colors__8DA7674DD34F4585 | PK     | 1                 | 1                 |
+------------------------------+--------+-------------------+-------------------+

Eu reduzi as colunas para este exemplo. As sys.key_constraints a visualização do sistema retorna mais colunas do que isso. Você sempre pode usar o * curinga para retornar todas as colunas, se desejar.

Podemos ver pelo resultado da consulta que este banco de dados possui apenas uma chave primária (a que acabamos de criar).

Nesse caso, a chave primária foi nomeada automaticamente pelo sistema. Você também tem a opção de fornecer seu próprio nome (mais sobre isso posteriormente).

Exemplo 3 – Verifique o Índice

Por padrão, um índice clusterizado é criado quando você cria a chave primária. Você pode especificar o índice clusterizado explicitamente ou deixá-lo ser criado automaticamente. Você também tem a opção de especificar um índice não clusterizado.

Aqui está uma consulta que retorna o índice que foi criado automaticamente quando criei a chave primária acima:

SELECT *
FROM sys.indexes
WHERE name = 'PK__Colors__8DA7674DD34F4585';

Resultado (usando saída vertical):

object_id                  | 885578193
name                       | PK__Colors__8DA7674DD34F4585
index_id                   | 1
type                       | 1
type_desc                  | CLUSTERED
is_unique                  | 1
data_space_id              | 1
ignore_dup_key             | 0
is_primary_key             | 1
is_unique_constraint       | 0
fill_factor                | 0
is_padded                  | 0
is_disabled                | 0
is_hypothetical            | 0
is_ignored_in_optimization | 0
allow_row_locks            | 1
allow_page_locks           | 1
has_filter                 | 0
filter_definition          | NULL
compression_delay          | NULL
suppress_dup_key_messages  | 0
auto_created               | 0

Nesse caso, reduzi os resultados apenas à linha que contém o mesmo nome da chave primária que acabei de criar. Você sempre pode remover o WHERE cláusula se precisar que mais resultados sejam retornados.

Podemos ver que este índice tem um type_desc de CLUSTER .

Exemplo 4 – Nomeando a chave primária

A chave primária que criamos acima foi nomeada automaticamente pelo sistema. Você pode fornecer seu próprio nome, se preferir.

Aqui está um exemplo de especificação de um nome para a chave primária. Nesse caso, também especifico um índice não clusterizado.

USE PK_Test;

CREATE TABLE Cats
(
    CatId int IDENTITY (1,1) NOT NULL, 
       CONSTRAINT PK_Cats_CatId PRIMARY KEY NONCLUSTERED (CatId),
    CatName varchar(50)
);

Neste caso eu uso o opcional CONSTRAINT palavra-chave para indicar o início da definição da chave primária, seguida do meu nome escolhido para a chave primária. Eu também uso o NONCLUSTERED palavra-chave para especificar que um índice não clusterizado.

Verifique a chave primária:

SELECT
  name,
  type,
  unique_index_id,
  is_system_named
FROM sys.key_constraints
WHERE type = 'PK';

Resultado:

+------------------------------+--------+-------------------+-------------------+
| name                         | type   | unique_index_id   | is_system_named   |
|------------------------------+--------+-------------------+-------------------|
| PK__Colors__8DA7674DD34F4585 | PK     | 1                 | 1                 |
| PK_Cats_CatId                | PK     | 2                 | 0                 |
+------------------------------+--------+-------------------+-------------------+

Confira o índice:

SELECT *
FROM sys.indexes
WHERE name = 'PK_Cats_CatId';

Resultado (usando saída vertical):

object_id                  | 917578307
name                       | PK_Cats_CatId
index_id                   | 2
type                       | 2
type_desc                  | NONCLUSTERED
is_unique                  | 1
data_space_id              | 1
ignore_dup_key             | 0
is_primary_key             | 1
is_unique_constraint       | 0
fill_factor                | 0
is_padded                  | 0
is_disabled                | 0
is_hypothetical            | 0
is_ignored_in_optimization | 0
allow_row_locks            | 1
allow_page_locks           | 1
has_filter                 | 0
filter_definition          | NULL
compression_delay          | NULL
suppress_dup_key_messages  | 0
auto_created               | 0

Assim, podemos ver que desta vez o type_desc é SEM CONCLUSÕES .

Observe que ao criar uma tabela, CLUSTERED pode ser especificado para apenas uma restrição. Se for especificado para um UNIQUE restrição e uma PRIMARY KEY restrição também é especificada, a PRIMARY KEY o padrão é NONCLUSTERED .

Exemplo 5 – Criar uma chave primária em uma coluna anulável

Uma chave primária só pode ser criada para colunas definidas como NOT NULL . Se você tentar criar uma chave primária em uma coluna definida como NULL , você receberá um erro.

No entanto, se você não especificar a nulidade, a coluna será definida como NOT NULL por padrão.

Para demonstrar isso, vamos criar outra tabela, mas desta vez, vamos defini-la como NULL :

USE PK_Test;

CREATE TABLE Dogs
(
    DogId int IDENTITY (1,1) NULL PRIMARY KEY,
    DogName varchar(50)
);

Resultado:

Msg 8147, Level 16, State 1, Line 3
Could not create IDENTITY attribute on nullable column 'DogId', table 'Dogs'.
Msg 8111, Level 16, State 1, Line 3
Cannot define PRIMARY KEY constraint on nullable column in table 'Dogs'.
Msg 1750, Level 16, State 0, Line 3
Could not create constraint or index. See previous errors.

Como esperado, recebemos um erro.

Vamos remover NULL da definição da tabela e tente novamente:

USE PK_Test;

CREATE TABLE Dogs
(
    DogId int IDENTITY (1,1) PRIMARY KEY,
    DogName varchar(50)
);

Resultado:

Commands completed successfully.
Total execution time: 00:00:00.015

Desta vez a tabela foi criada com sucesso.

Vamos dar uma olhada nisso:

SELECT 
  t.name AS 'Table',
  c.name AS 'Column', 
  c.is_nullable,
  c.is_identity
FROM sys.columns c
INNER JOIN sys.tables T
ON c.object_id = t.object_id
WHERE c.name = 'DogId';

Resultado:

+---------+----------+---------------+---------------+
| Table   | Column   | is_nullable   | is_identity   |
|---------+----------+---------------+---------------|
| Dogs    | DogId    | 0             | 1             |
+---------+----------+---------------+---------------+

Assim, podemos ver que não é anulável, porque o is_nullable sinalizador está definido como 0 .

Exemplo 6 – Chave primária em várias colunas

Você também pode criar uma chave primária em várias colunas. As chaves primárias de várias colunas também são conhecidas como chaves primárias compostas. Para criar uma chave primária composta, basta separar as colunas com uma vírgula ao definir a chave.

Assim:

CONSTRAINT PK_Name PRIMARY KEY (Column1, Column2)

Aqui está um exemplo de uma situação em que uma chave primária de várias colunas pode ser usada:

CREATE TABLE Musician (
MusicianId int NOT NULL,
FirstName varchar(60),
LastName varchar(60),
CONSTRAINT PK_Musician PRIMARY KEY (MusicianID)
);

CREATE TABLE Band (
BandId int NOT NULL,
BandName varchar(255),
CONSTRAINT PK_Band PRIMARY KEY (BandId)
);

CREATE TABLE BandMember (
MusicianId int NOT NULL,
BandId int NOT NULL,
CONSTRAINT PK_BandMember PRIMARY KEY (MusicianID, BandId),
CONSTRAINT FK_BandMember_Band FOREIGN KEY (BandId) REFERENCES Band(BandId),
CONSTRAINT FK_BandMember_Musician FOREIGN KEY (MusicianId) REFERENCES Musician(MusicianId)
);

Neste exemplo, o BandMember tabela tem uma chave primária de várias colunas. Nesse caso, cada coluna na chave primária também é uma chave estrangeira para a chave primária de outra tabela, mas isso não é um requisito.

Consulte Como criar uma chave primária composta no SQL Server para obter uma explicação mais detalhada deste exemplo.

Consulte também Como criar uma chave estrangeira composta no SQL Server para obter um exemplo que leva um passo adiante com uma chave estrangeira de várias colunas que faz referência à chave primária composta acima.