Principios de Normalización de Bases de Datos

La normalización es un proceso esencial en el diseño de bases de datos relacionales, cuyo objetivo es minimizar la redundancia de datos y mejorar la integridad de los mismos. Se logra estructurando las tablas de una manera que reduce las anomalías por inserción, actualización y eliminación.

¿Qué son las Formas Normlaes?

Las Formas Normales (NF) son un conjunto de reglas que definen cómo deben organizarse los atributos en las tablas para alcanzar ciertos niveles de normalización. Las tres formas normales más comunes son 1NF, 2NF y 3NF, y se aplican de manera progresiva: cada forma normal superior se construye sobre la anterior.

Primera Forma Normal (1NF)

La Primera Forma Normal (1NF) exige que cada columna de una tabla contenga valores atómicos, es decir, indivisibles. No debe haber grupos repetitivos dentro de una columna, y cada fila debe ser única.

Es importante diferenciar la atomiciadd en 1NF de la atomicidad de las propiedades ACID en transacciones de bases de datos. La atomicidad de 1NF se refiere a la granularidad de los datos dentro de una celda.

Atomicidad en 1NF:

Un campo no puede contener múltiples valores que puedan ser descompuestos en unidades de datos más pequeñas. Cada celda de la tabla debe contener un único valor.

Ejemplo de tabla que NO cumple 1NF:

+----+--------------------------+-----------+-------+
| ID | Detalles_Contacto        | Asignatura| Calificación|
+----+--------------------------+-----------+-------+
| 1  | Juan Pérez, Masculino, 30| Matemáticas| 85    |
| 2  | Ana Soto, Femenino, 25   | Historia  | 92    |
| 3  | Carlos Ruiz, Masculino, 35| Química   | 78    |
+----+--------------------------+-----------+-------+

En este ejemplo, la columna Detalles_Contacto contiene múltiples piezas de información (nombre, género, edad) que deberían estar en columnas separadas.

Transformando la tabla para cumplir 1NF:

+----+--------------+----------+-----+-----------+-------+
| ID | Nombre       | Género   | Edad| Asignatura| Calificación|
+----+--------------+----------+-----+-----------+-------+
| 1  | Juan Pérez   | Masculino| 30  | Matemáticas| 85    |
| 2  | Ana Soto     | Femenino | 25  | Historia  | 92    |
| 3  | Carlos Ruiz  | Masculino| 35  | Química   | 78    |
+----+--------------+----------+-----+-----------+-------+

Ahora, cada celda contiene un valor atómico, y la tabla cumple con la Primera Forma Normal.

Segunda Forma Normal (2NF)

Para que una tabla cumpla con la Segunda Forma Normal (2NF), debe primero satisfacer la 1NF. Además, todas las columnas no clave (es decir, que no forman parte de la clave primaria) deben depender funcionalmente de la clave primaria completa.

Esto significa que no debe haber dependencias funcionales parciales, donde una columna no clave depende solo de una parte de una clave primaria compuesta.

Ejemplo de tabla que NO cumple 2NF (con clave primaria compuesta: ID_Pedido, ID_Producto):

+-----------+------------+------------------+------------------+----------+
| ID_Pedido | ID_Producto| Nombre_Producto  | Precio_Unitario  | Cantidad |
+-----------+------------+------------------+------------------+----------+
| 101       | P001       | Laptop           | 1200.00          | 2        |
| 101       | P002       | Ratón            | 25.00            | 3        |
| 102       | P001       | Laptop           | 1200.00          | 1        |
+-----------+------------+------------------+------------------+----------+

Aquí, la clave primaria compuesta es (ID_Pedido, ID_Producto). Sin embargo, Nombre_Producto y Precio_Unitario dependen únicamente de ID_Producto (una parte de la clave primaria), no de la clave primaria completa. Esto viola 2NF.

Transformando la tabla para cumplir 2NF:

-- Tabla de Productos
+------------+------------------+------------------+
| ID_Producto| Nombre_Producto  | Precio_Unitario  |
+------------+------------------+------------------+
| P001       | Laptop           | 1200.00          |
| P002       | Ratón            | 25.00            |
+------------+------------------+------------------+

-- Tabla de Detalle_Pedidos
+-----------+------------+----------+
| ID_Pedido | ID_Producto| Cantidad |
+-----------+------------+----------+
| 101       | P001       | 2        |
| 101       | P002       | 3        |
| 102       | P001       | 1        |
+-----------+------------+----------+

Ahora, en la tabla Detalle_Pedidos, Cantidad depende completamente de la clave primaria compuesta (ID_Pedido, ID_Producto). La información del producto se ha movido a una tabla separada, Productos.

Tercera Forma Normal (3NF)

Una tabla está en Tercera Forma Normal (3NF) si cumple con 2NF y, además, no tiene dependencias funcionales transitivas.

Una dependencia transitiva ocurre cuando una columna no clave depende de otra columna no clave, en lugar de depender directamente de la clave primaria.

Ejemplo de tabla que NO cumple 3NF:

+-------------+--------------+-----------------+-------------------+-------------------+
| ID_Empleado | Nombre_Emp   | ID_Departamento | Nombre_Departamento| Ubicacion_Depto  |
+-------------+--------------+-----------------+-------------------+-------------------+
| E001        | Laura Gómez  | D01             | Ventas            | Edificio A        |
| E002        | Pedro Sanz   | D02             | Marketing         | Edificio B        |
| E003        | Sofía Vidal  | D01             | Ventas            | Edificio A        |
+-------------+--------------+-----------------+-------------------+-------------------+

Aquí, ID_Empleado es la clave primaria. * Nombre_Emp depende de ID_Empleado. * ID_Departamento depende de ID_Empleado. * Pero Nombre_Departamento y Ubicacion_Depto dependen de ID_Departamento (una columna no clave), lo que a su vez depende de ID_Empleado. Esta es una dependencia transitiva.

Transformando la tabla para cumplir 3NF:

-- Tabla de Empleados
+-------------+--------------+-----------------+
| ID_Empleado | Nombre_Emp   | ID_Departamento |
+-------------+--------------+-----------------+
| E001        | Laura Gómez  | D01             |
| E002        | Pedro Sanz   | D02             |
| E003        | Sofía Vidal  | D01             |
+-------------+--------------+-----------------+

-- Tabla de Departamentos
+-----------------+-------------------+-------------------+
| ID_Departamento | Nombre_Departamento| Ubicacion_Depto  |
+-----------------+-------------------+-------------------+
| D01             | Ventas            | Edificio A        |
| D02             | Marketing         | Edificio B        |
+-----------------+-------------------+-------------------+

Ahora, la información de los departamentos está en su propia tabla, eliminando la dependencia transitiva. Cada columna no clave en la tabla Empleados (Nombre_Emp, ID_Departamento) depende directamente de la clave primaria ID_Empleado.

Diferencia entre UNION y UNION ALL en SQL

En SQL, tanto UNION como UNION ALL son operadores utilizados para combinar los resultados de dos o más sentencias SELECT en un único conjunto de resultados. La distinción clave entre ellos radica en cómo manejan las filas duplicadas y su impacto en el rendimiento.

1. Manejo de Filas Duplicadas

• UNION: Este operador combina los conjuntos de resultados de las consultas SELECT y elimina automáticamente las filas duplicadas. Para lograr esto, el motor de la base de datos realiza una operación de clasificación y comparación sobre el conjunto de resultados combinado, lo cual consume recursos adicionales.
• UNION ALL: A diferencia de UNION, este operador simplemente concatena todos los conjuntos de resultados sin verificar ni eliminar filas duplicadas. Retiene cada fila de cada consulta SELECT, incluso si son idénticas. Debido a que no realiza la verificación y eliminación de duplicados, UNION ALL es generalmente más rápido y eficiente en términos de rendimiento.

2. Requisitos Comunes

Para utilizar UNION o UNION ALL, todas las sentencias SELECT deben cumplir las siguientes condiciones:

• Deben seleccionar el mismo número de columnas.
• Las columnas correspondientes en cada sentencia SELECT deben tener tipos de datos compatibles (no necesariamente idénticos, pero que la base de datos pueda convertir implícitamente).
• El orden de las columnas en cada sentencia SELECT es importante, ya que determina qué columnas se combinan.

Ejemplo Ilustrativo

Consideremos dos tablas, Ciudades_Europa y Ciudades_America, con los sigueintes datos:

Ciudades_Europa:

+-----------+---------------+
| id_ciudad | nombre_ciudad |
+-----------+---------------+
| 1         | París         |
| 2         | Londres       |
| 4         | Roma          |
+-----------+---------------+

Ciudades_America:

+-----------+---------------+
| id_ciudad | nombre_ciudad |
+-----------+---------------+
| 2         | Londres       |
| 3         | Nueva York    |
| 5         | Ciudad de México|
+-----------+---------------+

Uso de UNION:

SELECT id_ciudad, nombre_ciudad FROM Ciudades_Europa
UNION
SELECT id_ciudad, nombre_ciudad FROM Ciudades_America;

Resultado (filas duplicadas eliminadas):

+-----------+---------------+
| id_ciudad | nombre_ciudad |
+-----------+---------------+
| 1         | París         |
| 2         | Londres       |
| 3         | Nueva York    |
| 4         | Roma          |
| 5         | Ciudad de México|
+-----------+---------------+

Observe que la fila (2, 'Londres') aparece solo una vez en el resultado, a pesar de estar presente en ambas tablas originales.

Uso de UNION ALL:

SELECT id_ciudad, nombre_ciudad FROM Ciudades_Europa
UNION ALL
SELECT id_ciudad, nombre_ciudad FROM Ciudades_America;

Resultado (todas las filas, incluidas las duplicadas):

+-----------+---------------+
| id_ciudad | nombre_ciudad |
+-----------+---------------+
| 1         | París         |
| 2         | Londres       |
| 4         | Roma          |
| 2         | Londres       |
| 3         | Nueva York    |
| 5         | Ciudad de México|
+-----------+---------------+

Aquí, la fila (2, 'Londres') se incluye dos veces en el resultado, una por cada tabla de origen.

Conclusión

Elija UNION cuando necesite combinar conjuntos de resultados y esté seguro de que desea eliminar todas las filas duplicadas, aceptando una posible penalización de rendimiento. Use UNION ALL cuando sepa que no hay duplicados entre los conjuntos de resultados o si no le importa tener filas duplicadas en el resultado final, lo que le dará una mejor performance.