{"canonical_url":"https://engineer.company/es/glossary/normalization/","content_markdown":"# Normalización de bases de datos\n\n## Qué es\n\nLa normalización de bases de datos consiste en organizar una base de datos\nrelacional para que cada hecho se almacene una sola vez, en la tabla a la que\ncorresponde, y todo lo demás se refiera a él mediante su clave. En inglés\nbritánico se escribe database normalisation. La dirección de un cliente ocupa\nuna fila de una tabla de clientes; un pedido solo contiene la clave del cliente,\ny una combinación reúne ambos datos cuando una consulta los necesita.\n\nTanto la idea como la palabra proceden de Edgar F. Codd, que propuso el modelo\nrelacional en Communications of the ACM en junio de 1970. En aquel artículo,\nnormalizar significaba un paso concreto: eliminar la anidación de relaciones dentro de otras\nrelaciones, como un registro de empleado con su propia lista de empleos\nanteriores y su propia lista de hijos. El procedimiento de Codd copia la clave\nprimaria del elemento padre en cada grupo anidado y extrae el grupo a una\nrelación independiente, cuya clave combina la clave del padre con lo que\nidentifique una fila dentro del grupo. El resultado está en forma normal, hoy\nllamada primera forma normal: cada valor de cada columna es un único valor\nsimple.\n\nCodd definió después formas normales más estrictas, entre ellas la que el\nartículo de Ronald Fagin de 1977 denomina tercera forma normal mejorada de Codd,\ntambién conocida como forma normal de Boyce–Codd. El artículo de Fagin añade una\ncuarta. Se basa en un nuevo tipo de dependencia entre columnas, la dependencia\nmultivaluada, que incluye la conocida dependencia funcional como caso\nparticular, y Fagin demostró que la cuarta forma es estrictamente más fuerte que\nla forma normal de Boyce–Codd.\n\nSe llega a las formas más estrictas mediante descomposición. Una tabla se\nsustituye por dos o más de sus proyecciones, tablas formadas por algunas de sus\ncolumnas, elegidas de modo que al combinarlas se recupere exactamente la\noriginal. El artículo de Fagin demuestra que esa garantía se cumple para su\npropia forma: cualquier tabla puede descomponerse en tablas en cuarta forma\nnormal sin perder información, porque su combinación recupera la original. La\ndesnormalización hace lo contrario: conservar deliberadamente una copia de un\nhecho en un segundo lugar, normalmente para evitar una combinación.\n\n## Por qué importa\n\nUna tabla que almacena muchas veces el mismo hecho se expone a tres tipos de\nproblemas. Imagine una fila por empleado y proyecto, con la oficina del empleado\nrepetida en cada fila. Cuando alguien cambia de oficina, varias filas necesitan\nel nuevo valor, y omitir una deja la base de datos en contradicción consigo\nmisma. Cuando termina el último proyecto de un empleado y se elimina su fila,\ndesaparece también el registro de dónde trabaja. Y no hay dónde registrar la\noficina de una persona recién contratada que aún no participa en ningún\nproyecto. Son las anomalías de actualización, eliminación e inserción, y\ndescomponer la tabla en empleado–proyecto y empleado–oficina elimina las tres.\n\nEn el trabajo diario de un equipo, estas anomalías se manifiestan como errores.\nUna factura muestra la dirección antigua porque se pasó por alto una copia. Un\ninforme cuenta dos veces a un cliente porque el nombre se escribió de dos\nmaneras. Un esquema normalizado dificulta introducir esos errores desde el\nprincipio y, si se declaran claves primarias, claves foráneas y restricciones de\ncomprobación, la propia base de datos rechaza los datos incorrectos en vez de\nconfiar en que cada fragmento del código de aplicación recuerde las reglas.\n\nCambiar también cuesta menos. Un esquema cuyas tablas describen una sola cosa\ncada una suele admitir nuevos tipos de datos con menos reestructuración: añadir\nuna columna a la única tabla a la que pertenece un hecho supone una migración\nmenor que localizar todas las tablas que lo copiaron.\n\nEl coste está en las combinaciones. Una base de datos normalizada responde a la\nmayoría de las preguntas volviendo a combinar tablas, y cada combinación exige\ntrabajo al servidor. Con índices en las columnas que se combinan, ese trabajo\nsuele ser pequeño; por eso debería ser una consulta cuya lentitud se haya medido, y\nno una intuición, la que decida cuándo volver a copiar un hecho.\n\n## Cómo se aplica en la práctica\n\nUna pequeña tienda empieza con una sola tabla plana, cargada desde una\nexportación de una hoja de cálculo:\n\n```sql\nCREATE TABLE order_flat (\n    order_no       integer,\n    ordered_on     date,\n    customer_email text,\n    customer_name  text,\n    customer_city  text,\n    sku            text,\n    product_name   text,\n    unit_price     numeric,\n    quantity       integer,\n    status         text\n);\n```\n\nCada fila es una línea de un pedido, así que el nombre y la ciudad de un cliente\nse repiten en cada línea de cada pedido, y el nombre de un producto se repite en\ncada línea de venta de ese producto. Si un cliente se muda, hay que actualizar decenas de\nfilas. Eliminar la última línea correspondiente a la venta de un producto hace que se olvide que el\nproducto existe. El estado es texto libre, de modo que pueden aparecer `shipped`, `Shipped`\ny `shipd`.\n\nCon la normalización, cada hecho tiene un único lugar:\n\n```sql\nCREATE TABLE customers (\n    customer_id integer PRIMARY KEY,\n    email       text NOT NULL UNIQUE,\n    name        text NOT NULL,\n    city        text NOT NULL\n);\n\nCREATE TABLE products (\n    sku        text PRIMARY KEY,\n    name       text NOT NULL,\n    list_price numeric NOT NULL CHECK (list_price \u003e= 0)\n);\n\nCREATE TABLE order_status (\n    status_id smallint PRIMARY KEY,\n    label     text NOT NULL UNIQUE\n);\n\nCREATE TABLE orders (\n    order_id    integer PRIMARY KEY,\n    customer_id integer NOT NULL REFERENCES customers ON DELETE RESTRICT,\n    status_id   smallint NOT NULL REFERENCES order_status,\n    ordered_on  date NOT NULL\n);\n\nCREATE TABLE order_lines (\n    order_id   integer REFERENCES orders ON DELETE CASCADE,\n    sku        text NOT NULL REFERENCES products,\n    quantity   integer NOT NULL CHECK (quantity \u003e 0),\n    unit_price numeric NOT NULL CHECK (unit_price \u003e= 0),\n    PRIMARY KEY (order_id, sku)\n);\n```\n\nLa ciudad de un cliente se almacena ahora una sola vez, y una mudanza se\nresuelve actualizando una fila. Las etiquetas de estado están en una pequeña\ntabla de referencia con una clave `smallint`, así que cada pedido contiene un número\ncorto en lugar de una cadena repetida, y no puede entrar un estado mal escrito:\nla clave foránea rechaza cualquier `status_id` que no figure en `order_status`.\n\n`unit_price` permanece en `order_lines`, aunque `products` ya tiene un precio. No es un descuido. El\nprecio que pagó un cliente es un hecho sobre la venta, no sobre el producto, y\nno debe cambiar cuando cambie el catálogo. La normalización pregunta a qué lugar\npertenece cada hecho, y este pertenece a la línea.\n\nLas dos cláusulas `ON DELETE` indican qué significa una eliminación. Eliminar un pedido\nelimina también sus líneas, porque una línea no tiene sentido sin su pedido.\nEliminar un cliente que tiene pedidos falla, porque esos pedidos son registros\nque la tienda debe conservar. El valor predeterminado de PostgreSQL, `NO ACTION`,\ntambién rechaza esa eliminación; `RESTRICT` expresa la intención y, a diferencia de\n`NO ACTION`, no puede diferirse hasta el final de la transacción.\n\nPostgreSQL crea un índice para cada clave primaria, pero no para el lado que\nhace referencia en una clave foránea. Su documentación sugiere añadir uno,\nporque eliminar o actualizar una fila referenciada exige encontrar todas las\nfilas que apuntan a ella:\n\n```sql\nCREATE INDEX ON orders (customer_id);\nCREATE INDEX ON order_lines (sku);\n```\n\n`order_lines.order_id` no necesita nada más: es la primera columna de la clave primaria de esa\ntabla.\n\nPor último, una vista recupera la estructura plana para quien la necesite:\n\n```sql\nCREATE VIEW order_report AS\nSELECT o.order_id, o.ordered_on, c.email, c.name AS customer_name, c.city,\n       l.sku, p.name AS product_name, l.unit_price, l.quantity, s.label\nFROM   orders o\nJOIN   customers c    USING (customer_id)\nJOIN   order_status s USING (status_id)\nJOIN   order_lines l  USING (order_id)\nJOIN   products p     USING (sku);\n```\n\nLos informes pueden leer `order_report` de forma muy parecida a como leían la tabla\nantigua, mientras que cada hecho subyacente se almacena una sola vez. El\ntutorial de PostgreSQL defiende lo mismo para las vistas en general: una vista\nda a una consulta un nombre que puede usarse como una tabla y permite que\ncambien las tablas subyacentes tras una interfaz que permanece estable.\n\nLas mismas reglas se cumplen a una escala mucho mayor. En el trabajo de la\nfundadora en NextMariner, el [modelo de datos marítimos](/es/portfolio/modeled-348-tables-across-34-postgres-schemas/) se diseñó con esquemas PostgreSQL\nnormalizados y organizados por dominio; su página lo situaba en 348 tablas repartidas entre 34\nesquemas en octubre de 2026. Los conjuntos pequeños y estables, como estados,\ntipos y categorías, se convirtieron en tablas de referencia `SMALLINT`, lo que mantiene\ncompactas las filas y baratas las combinaciones, y claves foráneas y\nrestricciones reales mantienen unidas las relaciones, de modo que la integridad\nes responsabilidad de la base de datos y no algo que la aplicación deba\nrecordar.\n\n## Dónde surgen los problemas\n\n**Listas empaquetadas en una columna.** Una columna `tags` que contenga `red,large,sale`, o una\ncolumna de teléfono con dos números, incumple la primera forma normal. La base\nde datos no puede comprobar los valores por separado, hacer que una clave\nforánea apunte a ellos ni utilizarlos en una combinación, y cada consulta debe dividir primero la\ncadena. Dé a la lista su propia tabla, con una fila por valor y una clave\nformada por la clave del padre más el valor: el procedimiento de Codd de 1970.\n\n**Eliminar la historia al normalizar.** El precio de una línea de pedido, o la\ndirección de entrega de un pedido, parece duplicar lo que contienen las tablas\nde productos y clientes. No es un duplicado: registra lo que era cierto cuando\nse hizo el pedido. Sustituirlo por una clave al catálogo actual hace que todas\nlas facturas antiguas cambien la próxima vez que cambie un precio. Mantenga los\nhechos de un evento en el propio evento.\n\n**Claves foráneas sin índices.** El lado referenciado de una clave foránea\nsiempre está indexado, porque debe ser una clave primaria, una restricción de\nunicidad o un índice único. El lado que hace referencia no lo está, así que\neliminar un cliente o cambiar el SKU de un producto implica recorrer toda la\ntabla que hace referencia para encontrar las filas que apuntan a él. Indexe las\ncolumnas que hacen referencia, como en el ejemplo anterior. PostgreSQL deja esa decisión en sus\nmanos porque no siempre es necesario.\n\n**Cascadas que eliminan registros.** `ON DELETE CASCADE` de clientes a facturas significa que\nuna eliminación descuidada de un cliente borra silenciosamente registros que el\nnegocio debe conservar. Aplique la cascada solo a filas que no tengan sentido\nsin su padre, como las líneas de pedido, y utilice `RESTRICT`, o el valor\npredeterminado, en todos los demás casos.\n\n**Un diseño normalizado que nada hace cumplir.** Las tablas creadas a mano o\ncargadas desde hojas de cálculo suelen llegar sin clave primaria ni claves\nforáneas, por lo que nada impide una fila duplicada o un pedido de un cliente\ninexistente. PostgreSQL no exige una clave primaria, aunque su documentación\nseñala que la teoría relacional requiere una en cada tabla. Declare las claves y\nla base de datos rechazará la fila incorrecta con un error que identifique la\nrestricción.\n\n**Totales en caché que se desajustan.** Una columna `order_total` en `orders`, mantenida junto\na las líneas que suma, es una desnormalización, y toda ruta de código que cambie\nuna línea debe actualizarla también. Si alguna lo olvida, el total queda mal sin\nproducir ningún error. Calcule el total en una consulta o una vista. Si resulta\ndemasiado lento, conserve la copia, pero manténgala en un único lugar, dentro de\nla misma transacción que cambia las líneas.\n\n**Desnormalizar antes de medir.** Las combinaciones mediante claves indexadas\nson baratas, y copiar columnas para evitarlas cambia un coste pequeño y conocido\npor las anomalías descritas arriba. Lea primero el plan de consulta. Cuando las\nlecturas sean realmente demasiado lentas, una vista materializada o una base de\ndatos separada para informes puede conservar la estructura plana mientras las\ntablas de origen mantienen una sola copia de cada hecho. La elaboración de\ninformes es un ámbito donde la desnormalización tiene cabida deliberadamente,\ncomo en el esquema en estrella de un almacén de datos.\n\n**Descomponer en exceso.** La normalización pide un único lugar por hecho, no\ntantas tablas como sea posible. Descomponer una tabla cuyas columnas ya dependen\nde su clave y de nada más solo añade combinaciones y nombres de tablas que todo\nel mundo debe aprender. Un esquema que necesita una docena de combinaciones para\nmostrar un pedido no es más fácil de manejar que uno plano. Deténgase cuando\ncada hecho tenga un único lugar.\n\n## Lecturas adicionales\n\n- [Un modelo relacional de datos para grandes bancos de datos compartidos](https://doi.org/10.1145/362384.362685)\n  — artículo de Codd de 1970 en Communications of the ACM que introdujo el\n  modelo relacional, la forma normal y la normalización.\n- [Dependencias multivaluadas y una nueva forma normal](https://doi.org/10.1145/320557.320571)\n  — artículo de Fagin de 1977 que define la dependencia multivaluada y la cuarta\n  forma normal y demuestra que cualquier tabla puede descomponerse en cuarta\n  forma normal sin perder información.\n- [Restricciones](https://www.postgresql.org/docs/current/ddl-constraints.html)\n  — PostgreSQL sobre claves primarias, claves foráneas, restricciones de\n  comprobación y acciones `ON DELETE`, y por qué conviene indexar las columnas que hacen\n  referencia.\n- [Vistas](https://www.postgresql.org/docs/current/tutorial-views.html)\n  — argumentos del tutorial de PostgreSQL a favor de las vistas como interfaz\n  estable sobre tablas cuya estructura cambia.\n\n\u003chttps://engineer.company/es/glossary/normalization/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Qué es la normalización de bases de datos: formas normales de Codd, claves foráneas en PostgreSQL, anomalías que elimina y errores al aplicarla.","formats":{"gemtext":"https://engineer.company/es/glossary/normalization/index.gmi","gopher":"https://engineer.company/es/glossary/normalization/gophermap","html":"https://engineer.company/es/glossary/normalization/","json":"https://engineer.company/es/glossary/normalization/index.json","markdown":"https://engineer.company/es/glossary/normalization/index.md","pdf":"https://engineer.company/es/glossary/normalization/index.pdf"},"kind":"page","language":"es","title":"¿Qué es la normalización de bases de datos?","url":"https://engineer.company/es/glossary/normalization/","version":1}