# Normalización de bases de datos

## Qué es

La normalización de bases de datos consiste en organizar una base de datos
relacional para que cada hecho se almacene una sola vez, en la tabla a la que
corresponde, y todo lo demás se refiera a él mediante su clave. En inglés
británico se escribe database normalisation. La dirección de un cliente ocupa
una fila de una tabla de clientes; un pedido solo contiene la clave del cliente,
y una combinación reúne ambos datos cuando una consulta los necesita.

Tanto la idea como la palabra proceden de Edgar F. Codd, que propuso el modelo
relacional en Communications of the ACM en junio de 1970. En aquel artículo,
normalizar significaba un paso concreto: eliminar la anidación de relaciones dentro de otras
relaciones, como un registro de empleado con su propia lista de empleos
anteriores y su propia lista de hijos. El procedimiento de Codd copia la clave
primaria del elemento padre en cada grupo anidado y extrae el grupo a una
relación independiente, cuya clave combina la clave del padre con lo que
identifique una fila dentro del grupo. El resultado está en forma normal, hoy
llamada primera forma normal: cada valor de cada columna es un único valor
simple.

Codd definió después formas normales más estrictas, entre ellas la que el
artículo de Ronald Fagin de 1977 denomina tercera forma normal mejorada de Codd,
también conocida como forma normal de Boyce–Codd. El artículo de Fagin añade una
cuarta. Se basa en un nuevo tipo de dependencia entre columnas, la dependencia
multivaluada, que incluye la conocida dependencia funcional como caso
particular, y Fagin demostró que la cuarta forma es estrictamente más fuerte que
la forma normal de Boyce–Codd.

Se llega a las formas más estrictas mediante descomposición. Una tabla se
sustituye por dos o más de sus proyecciones, tablas formadas por algunas de sus
columnas, elegidas de modo que al combinarlas se recupere exactamente la
original. El artículo de Fagin demuestra que esa garantía se cumple para su
propia forma: cualquier tabla puede descomponerse en tablas en cuarta forma
normal sin perder información, porque su combinación recupera la original. La
desnormalización hace lo contrario: conservar deliberadamente una copia de un
hecho en un segundo lugar, normalmente para evitar una combinación.

## Por qué importa

Una tabla que almacena muchas veces el mismo hecho se expone a tres tipos de
problemas. Imagine una fila por empleado y proyecto, con la oficina del empleado
repetida en cada fila. Cuando alguien cambia de oficina, varias filas necesitan
el nuevo valor, y omitir una deja la base de datos en contradicción consigo
misma. Cuando termina el último proyecto de un empleado y se elimina su fila,
desaparece también el registro de dónde trabaja. Y no hay dónde registrar la
oficina de una persona recién contratada que aún no participa en ningún
proyecto. Son las anomalías de actualización, eliminación e inserción, y
descomponer la tabla en empleado–proyecto y empleado–oficina elimina las tres.

En el trabajo diario de un equipo, estas anomalías se manifiestan como errores.
Una factura muestra la dirección antigua porque se pasó por alto una copia. Un
informe cuenta dos veces a un cliente porque el nombre se escribió de dos
maneras. Un esquema normalizado dificulta introducir esos errores desde el
principio y, si se declaran claves primarias, claves foráneas y restricciones de
comprobación, la propia base de datos rechaza los datos incorrectos en vez de
confiar en que cada fragmento del código de aplicación recuerde las reglas.

Cambiar también cuesta menos. Un esquema cuyas tablas describen una sola cosa
cada una suele admitir nuevos tipos de datos con menos reestructuración: añadir
una columna a la única tabla a la que pertenece un hecho supone una migración
menor que localizar todas las tablas que lo copiaron.

El coste está en las combinaciones. Una base de datos normalizada responde a la
mayoría de las preguntas volviendo a combinar tablas, y cada combinación exige
trabajo al servidor. Con índices en las columnas que se combinan, ese trabajo
suele ser pequeño; por eso debería ser una consulta cuya lentitud se haya medido, y
no una intuición, la que decida cuándo volver a copiar un hecho.

## Cómo se aplica en la práctica

Una pequeña tienda empieza con una sola tabla plana, cargada desde una
exportación de una hoja de cálculo:

```sql
CREATE TABLE order_flat (
    order_no       integer,
    ordered_on     date,
    customer_email text,
    customer_name  text,
    customer_city  text,
    sku            text,
    product_name   text,
    unit_price     numeric,
    quantity       integer,
    status         text
);
```

Cada fila es una línea de un pedido, así que el nombre y la ciudad de un cliente
se repiten en cada línea de cada pedido, y el nombre de un producto se repite en
cada línea de venta de ese producto. Si un cliente se muda, hay que actualizar decenas de
filas. Eliminar la última línea correspondiente a la venta de un producto hace que se olvide que el
producto existe. El estado es texto libre, de modo que pueden aparecer `shipped`, `Shipped`
y `shipd`.

Con la normalización, cada hecho tiene un único lugar:

```sql
CREATE TABLE customers (
    customer_id integer PRIMARY KEY,
    email       text NOT NULL UNIQUE,
    name        text NOT NULL,
    city        text NOT NULL
);

CREATE TABLE products (
    sku        text PRIMARY KEY,
    name       text NOT NULL,
    list_price numeric NOT NULL CHECK (list_price >= 0)
);

CREATE TABLE order_status (
    status_id smallint PRIMARY KEY,
    label     text NOT NULL UNIQUE
);

CREATE TABLE orders (
    order_id    integer PRIMARY KEY,
    customer_id integer NOT NULL REFERENCES customers ON DELETE RESTRICT,
    status_id   smallint NOT NULL REFERENCES order_status,
    ordered_on  date NOT NULL
);

CREATE TABLE order_lines (
    order_id   integer REFERENCES orders ON DELETE CASCADE,
    sku        text NOT NULL REFERENCES products,
    quantity   integer NOT NULL CHECK (quantity > 0),
    unit_price numeric NOT NULL CHECK (unit_price >= 0),
    PRIMARY KEY (order_id, sku)
);
```

La ciudad de un cliente se almacena ahora una sola vez, y una mudanza se
resuelve actualizando una fila. Las etiquetas de estado están en una pequeña
tabla de referencia con una clave `smallint`, así que cada pedido contiene un número
corto en lugar de una cadena repetida, y no puede entrar un estado mal escrito:
la clave foránea rechaza cualquier `status_id` que no figure en `order_status`.

`unit_price` permanece en `order_lines`, aunque `products` ya tiene un precio. No es un descuido. El
precio que pagó un cliente es un hecho sobre la venta, no sobre el producto, y
no debe cambiar cuando cambie el catálogo. La normalización pregunta a qué lugar
pertenece cada hecho, y este pertenece a la línea.

Las dos cláusulas `ON DELETE` indican qué significa una eliminación. Eliminar un pedido
elimina también sus líneas, porque una línea no tiene sentido sin su pedido.
Eliminar un cliente que tiene pedidos falla, porque esos pedidos son registros
que la tienda debe conservar. El valor predeterminado de PostgreSQL, `NO ACTION`,
también rechaza esa eliminación; `RESTRICT` expresa la intención y, a diferencia de
`NO ACTION`, no puede diferirse hasta el final de la transacción.

PostgreSQL crea un índice para cada clave primaria, pero no para el lado que
hace referencia en una clave foránea. Su documentación sugiere añadir uno,
porque eliminar o actualizar una fila referenciada exige encontrar todas las
filas que apuntan a ella:

```sql
CREATE INDEX ON orders (customer_id);
CREATE INDEX ON order_lines (sku);
```

`order_lines.order_id` no necesita nada más: es la primera columna de la clave primaria de esa
tabla.

Por último, una vista recupera la estructura plana para quien la necesite:

```sql
CREATE VIEW order_report AS
SELECT o.order_id, o.ordered_on, c.email, c.name AS customer_name, c.city,
       l.sku, p.name AS product_name, l.unit_price, l.quantity, s.label
FROM   orders o
JOIN   customers c    USING (customer_id)
JOIN   order_status s USING (status_id)
JOIN   order_lines l  USING (order_id)
JOIN   products p     USING (sku);
```

Los informes pueden leer `order_report` de forma muy parecida a como leían la tabla
antigua, mientras que cada hecho subyacente se almacena una sola vez. El
tutorial de PostgreSQL defiende lo mismo para las vistas en general: una vista
da a una consulta un nombre que puede usarse como una tabla y permite que
cambien las tablas subyacentes tras una interfaz que permanece estable.

Las mismas reglas se cumplen a una escala mucho mayor. En el trabajo de la
fundadora en NextMariner, el [modelo de datos marítimos](/es/portfolio/modeled-348-tables-across-34-postgres-schemas/) se diseñó con esquemas PostgreSQL
normalizados y organizados por dominio; su página lo situaba en 348 tablas repartidas entre 34
esquemas en octubre de 2026. Los conjuntos pequeños y estables, como estados,
tipos y categorías, se convirtieron en tablas de referencia `SMALLINT`, lo que mantiene
compactas las filas y baratas las combinaciones, y claves foráneas y
restricciones reales mantienen unidas las relaciones, de modo que la integridad
es responsabilidad de la base de datos y no algo que la aplicación deba
recordar.

## Dónde surgen los problemas

**Listas empaquetadas en una columna.** Una columna `tags` que contenga `red,large,sale`, o una
columna de teléfono con dos números, incumple la primera forma normal. La base
de datos no puede comprobar los valores por separado, hacer que una clave
foránea apunte a ellos ni utilizarlos en una combinación, y cada consulta debe dividir primero la
cadena. Dé a la lista su propia tabla, con una fila por valor y una clave
formada por la clave del padre más el valor: el procedimiento de Codd de 1970.

**Eliminar la historia al normalizar.** El precio de una línea de pedido, o la
dirección de entrega de un pedido, parece duplicar lo que contienen las tablas
de productos y clientes. No es un duplicado: registra lo que era cierto cuando
se hizo el pedido. Sustituirlo por una clave al catálogo actual hace que todas
las facturas antiguas cambien la próxima vez que cambie un precio. Mantenga los
hechos de un evento en el propio evento.

**Claves foráneas sin índices.** El lado referenciado de una clave foránea
siempre está indexado, porque debe ser una clave primaria, una restricción de
unicidad o un índice único. El lado que hace referencia no lo está, así que
eliminar un cliente o cambiar el SKU de un producto implica recorrer toda la
tabla que hace referencia para encontrar las filas que apuntan a él. Indexe las
columnas que hacen referencia, como en el ejemplo anterior. PostgreSQL deja esa decisión en sus
manos porque no siempre es necesario.

**Cascadas que eliminan registros.** `ON DELETE CASCADE` de clientes a facturas significa que
una eliminación descuidada de un cliente borra silenciosamente registros que el
negocio debe conservar. Aplique la cascada solo a filas que no tengan sentido
sin su padre, como las líneas de pedido, y utilice `RESTRICT`, o el valor
predeterminado, en todos los demás casos.

**Un diseño normalizado que nada hace cumplir.** Las tablas creadas a mano o
cargadas desde hojas de cálculo suelen llegar sin clave primaria ni claves
foráneas, por lo que nada impide una fila duplicada o un pedido de un cliente
inexistente. PostgreSQL no exige una clave primaria, aunque su documentación
señala que la teoría relacional requiere una en cada tabla. Declare las claves y
la base de datos rechazará la fila incorrecta con un error que identifique la
restricción.

**Totales en caché que se desajustan.** Una columna `order_total` en `orders`, mantenida junto
a las líneas que suma, es una desnormalización, y toda ruta de código que cambie
una línea debe actualizarla también. Si alguna lo olvida, el total queda mal sin
producir ningún error. Calcule el total en una consulta o una vista. Si resulta
demasiado lento, conserve la copia, pero manténgala en un único lugar, dentro de
la misma transacción que cambia las líneas.

**Desnormalizar antes de medir.** Las combinaciones mediante claves indexadas
son baratas, y copiar columnas para evitarlas cambia un coste pequeño y conocido
por las anomalías descritas arriba. Lea primero el plan de consulta. Cuando las
lecturas sean realmente demasiado lentas, una vista materializada o una base de
datos separada para informes puede conservar la estructura plana mientras las
tablas de origen mantienen una sola copia de cada hecho. La elaboración de
informes es un ámbito donde la desnormalización tiene cabida deliberadamente,
como en el esquema en estrella de un almacén de datos.

**Descomponer en exceso.** La normalización pide un único lugar por hecho, no
tantas tablas como sea posible. Descomponer una tabla cuyas columnas ya dependen
de su clave y de nada más solo añade combinaciones y nombres de tablas que todo
el mundo debe aprender. Un esquema que necesita una docena de combinaciones para
mostrar un pedido no es más fácil de manejar que uno plano. Deténgase cuando
cada hecho tenga un único lugar.

## Lecturas adicionales

- [Un modelo relacional de datos para grandes bancos de datos compartidos](https://doi.org/10.1145/362384.362685)
  — artículo de Codd de 1970 en Communications of the ACM que introdujo el
  modelo relacional, la forma normal y la normalización.
- [Dependencias multivaluadas y una nueva forma normal](https://doi.org/10.1145/320557.320571)
  — artículo de Fagin de 1977 que define la dependencia multivaluada y la cuarta
  forma normal y demuestra que cualquier tabla puede descomponerse en cuarta
  forma normal sin perder información.
- [Restricciones](https://www.postgresql.org/docs/current/ddl-constraints.html)
  — PostgreSQL sobre claves primarias, claves foráneas, restricciones de
  comprobación y acciones `ON DELETE`, y por qué conviene indexar las columnas que hacen
  referencia.
- [Vistas](https://www.postgresql.org/docs/current/tutorial-views.html)
  — argumentos del tutorial de PostgreSQL a favor de las vistas como interfaz
  estable sobre tablas cuya estructura cambia.

<https://engineer.company/es/glossary/normalization/>
