Hasta ahora hemos estudiado varias restricciones importantes:
NOT NULL
DEFAULT
UNIQUE
Todas ellas ayudan a mejorar la calidad de los datos, pero aún queda una pregunta fundamental:
¿Cómo identificamos de manera única cada registro dentro de una tabla?
Para resolver este problema PostgreSQL utiliza la restricción PRIMARY KEY.
🧠 ¿Qué es una PRIMARY KEY?
Una Primary Key (Clave Primaria) es una columna, o conjunto de columnas, que identifica de forma única cada fila de una tabla.
En otras palabras:
✅ Cada valor debe ser único.
✅ No puede ser NULL.
✅ Permite identificar exactamente un registro.
Por ejemplo, en una tabla de empleados:
La columna id puede utilizarse como clave primaria porque cada valor es único y permite localizar un registro específico.
🎯 ¿Por qué es importante?
Las claves primarias son fundamentales porque:
Identifican registros de forma única.
Evitan duplicados.
Facilitan las búsquedas.
Sirven como base para las relaciones entre tablas.
Ayudan a mantener la integridad de los datos.
Prácticamente toda tabla debería tener una clave primaria.
🔍 PRIMARY KEY = UNIQUE + NOT NULL
Conceptualmente, una clave primaria combina dos reglas:
PRIMARY KEY
=
UNIQUE
+
NOT NULL
Por lo tanto:
✅ Los valores no pueden repetirse.
✅ Los valores no pueden ser nulos.
🏗️ Definir una PRIMARY KEY sobre una columna
La forma más sencilla es definirla junto con la columna.
CREATE TABLE empleados (
id INTEGER PRIMARY KEY,
nombre VARCHAR(100),
departamento VARCHAR(100)
);
En este caso:
id es la clave primaria.
Cada empleado debe tener un ID único.
✅ Insertar registros válidos
INSERT INTO empleados (
id,
nombre,
departamento
)
VALUES
(
1,
'Juan Pérez',
'Tecnología'
),
(
2,
'Ana López',
'Finanzas'
);
Consultar:
SELECT *
FROM empleados;
Resultado:
id | nombre | departamento
----+-------------+-------------
1 | Juan Pérez | Tecnología
2 | Ana López | Finanzas
❌ Intentar insertar una PRIMARY KEY duplicada
Ahora intentemos insertar un registro con un ID ya existente.
INSERT INTO empleados (
id,
nombre,
departamento
)
VALUES (
1,
'Carlos García',
'Ventas'
);
PostgreSQL devolverá un error similar a:
ERROR: duplicate key value violates unique constraint
Esto ocurre porque ya existe un registro con:
id = 1
❌ Intentar insertar NULL
Tampoco se permiten valores nulos.
INSERT INTO empleados (
id,
nombre
)
VALUES (
NULL,
'Roberto Martínez'
);
Resultado:
ERROR: null value in column "id"
violates not-null constraint
🏗️ PRIMARY KEY a Nivel de Tabla
También es posible declarar la clave primaria al final de la definición de la tabla.
Sin nombre explícito
CREATE TABLE empleados (
id INTEGER,
nombre VARCHAR(100),
departamento VARCHAR(100),
PRIMARY KEY (id)
);
Con nombre explícito (recomendado)
Al igual que vimos con UNIQUE, podemos asignar un nombre a la restricción.
CREATE TABLE empleados (
id INTEGER,
nombre VARCHAR(100),
departamento VARCHAR(100),
CONSTRAINT pk_empleados
PRIMARY KEY (id)
);
Beneficios:
Mayor claridad.
Administración más sencilla.
Mensajes de error más entendibles.
Facilita futuras modificaciones.
📋 Convención de nombres recomendada
Es común utilizar el prefijo:
pk_
seguido del nombre de la tabla.
Ejemplos:
pk_usuarios
pk_productos
pk_clientes
pk_empleados
pk_facturas
🧪 Ejemplo Completo
Crear tabla
CREATE TABLE productos (
codigo INTEGER,
nombre VARCHAR(100),
precio NUMERIC(10,2),
CONSTRAINT pk_productos
PRIMARY KEY (codigo)
);
Insertar datos válidos
INSERT INTO productos (
codigo,
nombre,
precio
)
VALUES
(
1001,
'Laptop',
18000.00
),
(
1002,
'Monitor',
4500.00
);
Consultar:
SELECT *
FROM productos;
Resultado:
codigo | nombre | precio
--------+----------+----------
1001 | Laptop | 18000.00
1002 | Monitor | 4500.00
Intentar insertar un código duplicado
INSERT INTO productos (
codigo,
nombre,
precio
)
VALUES (
1001,
'Teclado',
750.00
);
Resultado:
ERROR: duplicate key value violates unique constraint "pk_productos"
🔑 Claves Primarias Compuestas
Una Primary Key también puede estar formada por varias columnas.
Esto se conoce como clave primaria compuesta.
Ejemplo
Supongamos una tabla de inscripciones.
CREATE TABLE inscripciones (
alumno_id INTEGER,
curso_id INTEGER,
fecha_inscripcion DATE,
CONSTRAINT pk_inscripciones
PRIMARY KEY (
alumno_id,
curso_id
)
);
En este caso:
Un alumno puede estar en muchos cursos.
Un curso puede tener muchos alumnos.
La combinación alumno-curso debe ser única.
Registros válidos
INSERT INTO inscripciones
VALUES
(
1,
10,
'2026-07-01'
),
(
1,
20,
'2026-07-02'
);
Registro inválido
INSERT INTO inscripciones
VALUES
(
1,
10,
'2026-07-03'
);
Resultado:
ERROR: duplicate key value violates unique constraint
Porque la combinación:
(1,10)
ya existe.
🔧 Agregar una PRIMARY KEY a una tabla existente
Si la tabla ya fue creada:
ALTER TABLE empleados
ADD CONSTRAINT pk_empleados
PRIMARY KEY (id);
🔧 Eliminar una PRIMARY KEY
ALTER TABLE empleados
DROP CONSTRAINT pk_empleados;
⚠️ ¿Cuántas PRIMARY KEY puede tener una tabla?
Una tabla puede tener:
✅ Una única Primary Key.
❌ No puede tener dos Primary Keys.
Por ejemplo:
CREATE TABLE ejemplo (
id INTEGER PRIMARY KEY,
codigo INTEGER PRIMARY KEY
);
Esto generará un error.
Si necesitas controlar la unicidad de otras columnas, utiliza UNIQUE.
💡 Buenas prácticas
Toda tabla debería tener una Primary Key
✅ Recomendado
CREATE TABLE clientes (
id INTEGER PRIMARY KEY,
nombre VARCHAR(100)
);
Utiliza nombres descriptivos
cliente_id
producto_id
empleado_id
factura_id
suelen ser más claros que:
id1
id2
codigo
Asigna nombres a las restricciones
CONSTRAINT pk_clientes
PRIMARY KEY (cliente_id)
Esto simplifica el mantenimiento del esquema.
Mantén la Primary Key estable
Evita utilizar columnas cuyos valores puedan cambiar con frecuencia.
Por ejemplo:
❌
telefono
username
✅
cliente_id
empleado_id
producto_id
✅ Conclusión
La restricción PRIMARY KEY es uno de los conceptos más importantes de PostgreSQL y de las bases de datos relacionales en general.
Los puntos clave son:
Identifica de forma única cada registro.
No permite valores duplicados.
No permite valores nulos.
Cada tabla puede tener una sola Primary Key.
Puede estar formada por una o varias columnas.
Es recomendable asignar nombres explícitos a la restricción utilizando la palabra clave CONSTRAINT.
Constituye la base para crear relaciones entre tablas.
