Cómo crear una clave principal en SQL Server (ejemplos de T-SQL)

Este artículo muestra cómo crear una clave principal en SQL Server al crear una tabla con Transact-SQL.

Una clave principal es una o más columnas que se han configurado como identificador único para una tabla determinada. Las claves primarias se pueden usar para hacer cumplir la integridad de los datos en la tabla.

Una tabla solo puede tener una clave principal y las claves principales solo se pueden agregar a las columnas definidas como NOT NULL .

Este artículo demuestra cómo crear una clave principal en un nuevo tabla (es decir, al crear la tabla). Si necesita crear una clave principal en un existente tabla, consulte Cómo agregar una clave principal a una tabla existente en SQL Server.

Ejemplo 1:crear una tabla con una clave principal

Primero crearé una base de datos de prueba:

CREATE DATABASE PK_Test;

Ahora cree una nueva tabla que incluya una restricción de clave principal:

USE PK_Test;

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

Esto creó una nueva tabla llamada Colors que tiene una restricción de clave principal en su ColorId columna.

Ejemplo 2:verificar la restricción de clave principal

Podemos ejecutar el siguiente código para devolver una lista de restricciones de clave principal en la base de datos:

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                 |
+------------------------------+--------+-------------------+-------------------+

He reducido las columnas para este ejemplo. Las sys.key_constraints la vista del sistema devuelve más columnas que esta. Siempre puedes usar el * comodín para devolver todas las columnas si lo desea.

Podemos ver por el resultado de la consulta que esta base de datos tiene solo una clave principal (la que acabamos de crear).

En este caso, la clave principal fue nombrada automáticamente por el sistema. También tiene la opción de proporcionar su propio nombre (más sobre eso más adelante).

Ejemplo 3:consulta el índice

De forma predeterminada, se crea un índice agrupado cuando crea la clave principal. Puede especificar el índice agrupado explícitamente o dejar que se cree automáticamente. También tiene la opción de especificar un índice no agrupado.

Aquí hay una consulta que devuelve el índice que se creó automáticamente cuando creé la clave principal anterior:

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

Resultado (usando salida 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

En este caso, reduje los resultados a solo la fila que contiene el mismo nombre de la clave principal que acabo de crear. Siempre puedes eliminar el WHERE cláusula si necesita que se devuelvan más resultados.

Podemos ver que este índice tiene un type_desc de AGRUPADOS .

Ejemplo 4:nombrar la clave principal

El sistema nombró automáticamente la clave principal que creamos anteriormente. Puede proporcionar su propio nombre si lo prefiere.

Aquí hay un ejemplo de cómo especificar un nombre para la clave principal. En este caso también especifico un índice no agrupado.

USE PK_Test;

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

En este caso utilizo la opción CONSTRAINT palabra clave para indicar el inicio de la definición de la clave principal, seguida del nombre elegido para la clave principal. También uso el NONCLUSTERED palabra clave para especificar que un índice no agrupado.

Compruebe la clave principal:

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                 |
+------------------------------+--------+-------------------+-------------------+

Consulta el índice:

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

Resultado (usando salida 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

Entonces podemos ver que esta vez el type_desc es NO AGRUPADO .

Tenga en cuenta que al crear una tabla, CLUSTERED se puede especificar para una sola restricción. Si se especifica para un UNIQUE restricción y una PRIMARY KEY también se especifica la restricción, la PRIMARY KEY por defecto es NONCLUSTERED .

Ejemplo 5:crear una clave principal en una columna anulable

Solo se puede crear una clave principal para columnas definidas como NOT NULL . Si intenta crear una clave principal en una columna que está establecida en NULL , recibirá un error.

Sin embargo, si no especifica la nulabilidad, la columna se establece en NOT NULL por defecto.

Para demostrar esto, creemos otra tabla, pero esta vez la estableceremos en 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 era de esperar, obtenemos un error.

Eliminemos NULL de la definición de la tabla y vuelva a intentarlo:

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

Esta vez la tabla se creó con éxito.

Echémosle un vistazo:

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             |
+---------+----------+---------------+---------------+

Entonces podemos ver que no es anulable, porque is_nullable la bandera está establecida en 0 .

Ejemplo 6:clave principal en varias columnas

También puede crear una clave principal en varias columnas. Las claves primarias de varias columnas también se conocen como claves primarias compuestas. Para crear una clave principal compuesta, simplemente separe las columnas con una coma al definir la clave.

Así:

CONSTRAINT PK_Name PRIMARY KEY (Column1, Column2)

Este es un ejemplo de una situación en la que se podría usar una clave principal de varias columnas:

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

En este ejemplo, el BandMember la tabla tiene una clave principal de varias columnas. En este caso, cada columna de la clave principal también es una clave externa a la clave principal de otra tabla, pero esto no es un requisito.

Consulte Cómo crear una clave principal compuesta en SQL Server para obtener una explicación más detallada de este ejemplo.

Consulte también Cómo crear una clave externa compuesta en SQL Server para ver un ejemplo que lo lleva un paso más allá con una clave externa de varias columnas que hace referencia a la clave principal compuesta anterior.