# 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 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 — 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 — 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 — 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 — argumentos del tutorial de PostgreSQL a favor de las vistas como interfaz estable sobre tablas cuya estructura cambia.

=> /es/portfolio/modeled-348-tables-across-34-postgres-schemas/ modelo de datos marítimos
=> https://doi.org/10.1145/362384.362685 Un modelo relacional de datos para grandes bancos de datos compartidos
=> https://doi.org/10.1145/320557.320571 Dependencias multivaluadas y una nueva forma normal
=> https://www.postgresql.org/docs/current/ddl-constraints.html Restricciones
=> https://www.postgresql.org/docs/current/tutorial-views.html Vistas

=> https://engineer.company/es/glossary/normalization/ Esta página en la web
