Bases de Datos SQL

Diseño de Bases de Datos: Fundamentos y Mejores Prácticas

José Elías Romero Guanipa

03 Sep 2025

Aprende diseño de bases de datos desde cero. Normalización, modelado ER, relaciones y mejores prácticas.

diseno bases datos normalizacion modelado er relaciones sql +1 más

¡Domina el diseño de bases de datos relacionales! En este tutorial completo te guiaré paso a paso para que aprendas los fundamentos del diseño de bases de datos, desde la normalización hasta las mejores prácticas para sistemas escalables.

Objetivo: Aprender los principios fundamentales del diseño de bases de datos incluyendo normalización, modelado de relaciones, selección de tipos de datos y estrategias de optimización para crear sistemas de datos robustos y eficientes.

Paso 1: ¿Por qué es importante el diseño de bases de datos?

El diseño de bases de datos implica:

🎯 Definir la estructura correcta de los datos
🔗 Establecer relaciones apropiadas entre entidades
⚡ Optimizar el rendimiento de las consultas
🛡️ Garantizar la integridad y consistencia de los datos
📈 Preparar el sistema para el crecimiento futuro

Paso 2: Proceso de diseño paso a paso

Fase 1: Requerimientos y análisis

-- Ejemplo: Sistema de blog
-- Entidades identificadas:
-- • Users (usuarios)
-- • Posts (artículos)
-- • Comments (comentarios)
-- • Categories (categorías)
-- • Tags (etiquetas)

Fase 2: Diseño conceptual (Modelo ER)

-- Entidades y sus atributos:
-- User (id, username, email, password, created_at)
-- Post (id, title, content, user_id, category_id, created_at)
-- Comment (id, content, user_id, post_id, created_at)
-- Category (id, name, description)
-- Tag (id, name)
-- Post_Tag (post_id, tag_id) -- Tabla de unión

Paso 3: Normalización de bases de datos

Primera Forma Normal (1NF)

-- ❌ Antes de 1NF (datos repetidos)
CREATE TABLE posts (
    id INT PRIMARY KEY,
    title VARCHAR(255),
    tags VARCHAR(255) -- "tech,programming,sql" <- problema!
);

-- ✅ Después de 1NF
CREATE TABLE posts (
    id INT PRIMARY KEY,
    title VARCHAR(255)
);

CREATE TABLE tags (
    id INT PRIMARY KEY,
    name VARCHAR(50)
);

CREATE TABLE post_tags (
    post_id INT,
    tag_id INT,
    PRIMARY KEY (post_id, tag_id)
);

Segunda Forma Normal (2NF)

-- ❌ Violación de 2NF
CREATE TABLE orders (
    order_id INT PRIMARY KEY,
    product_id INT,
    product_name VARCHAR(100), -- Depende parcialmente de la clave
    quantity INT,
    order_date DATE
);

-- ✅ Cumpliendo 2NF
CREATE TABLE orders (
    order_id INT PRIMARY KEY,
    product_id INT,
    quantity INT,
    order_date DATE
);

CREATE TABLE products (
    product_id INT PRIMARY KEY,
    product_name VARCHAR(100)
);

Tercera Forma Normal (3NF)

-- ❌ Violación de 3NF
CREATE TABLE employees (
    employee_id INT PRIMARY KEY,
    name VARCHAR(100),
    department VARCHAR(100),
    department_location VARCHAR(100) -- Depende transitivamente
);

-- ✅ Cumpliendo 3NF
CREATE TABLE employees (
    employee_id INT PRIMARY KEY,
    name VARCHAR(100),
    department_id INT
);

CREATE TABLE departments (
    department_id INT PRIMARY KEY,
    name VARCHAR(100),
    location VARCHAR(100)
);

Paso 4: Modelado de relaciones

Relaciones Uno a Muchos (1:N)

-- Usuario → Posts (1 usuario puede tener N posts)
CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) UNIQUE NOT NULL
);

CREATE TABLE posts (
    id INT PRIMARY KEY AUTO_INCREMENT,
    title VARCHAR(255) NOT NULL,
    user_id INT NOT NULL,
    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
);

Relaciones Muchos a Muchos (N:M)

-- Posts ←→ Tags (N posts pueden tener M tags)
CREATE TABLE posts (
    id INT PRIMARY KEY AUTO_INCREMENT,
    title VARCHAR(255) NOT NULL
);

CREATE TABLE tags (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(50) UNIQUE NOT NULL
);

CREATE TABLE post_tags (
    post_id INT,
    tag_id INT,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (post_id, tag_id),
    FOREIGN KEY (post_id) REFERENCES posts(id) ON DELETE CASCADE,
    FOREIGN KEY (tag_id) REFERENCES tags(id) ON DELETE CASCADE
);

Relaciones Uno a Uno (1:1)

-- Usuario → Perfil (1 usuario tiene 1 perfil)
CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) UNIQUE NOT NULL
);

CREATE TABLE profiles (
    id INT PRIMARY KEY AUTO_INCREMENT,
    user_id INT UNIQUE NOT NULL, -- Clave única foránea
    bio TEXT,
    avatar_url VARCHAR(255),
    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
);

Paso 5: Elección de tipos de datos adecuados

Tipos numéricos

-- Enteros
id INT AUTO_INCREMENT PRIMARY KEY    -- -2^31 to 2^31-1
small_id SMALLINT                    -- -32768 to 32767
big_id BIGINT                        -- -2^63 to 2^63-1

-- Decimales
price DECIMAL(10, 2)                 -- Precisión exacta
rating FLOAT                         -- Precisión aproximada

Tipos de texto

username VARCHAR(50)                 -- Longitud variable (0-255)
description TEXT                     -- Texto largo (hasta 65KB)
content LONGTEXT                     -- Texto muy largo (hasta 4GB)

Tipos de fecha y hora

created_at TIMESTAMP                 -- 1970-2038, zona horaria
published_date DATE                  -- Solo fecha
event_time TIME                      -- Solo hora
birthday DATETIME                    -- Fecha y hora, mayor rango

Paso 6: Constraints e integridad de datos

Constraints básicos

CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) UNIQUE NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    age INT CHECK (age >= 0 AND age <= 150),
    status ENUM('active', 'inactive', 'banned') DEFAULT 'active',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Claves foráneas y integridad referencial

CREATE TABLE posts (
    id INT PRIMARY KEY,
    user_id INT NOT NULL,
    title VARCHAR(255) NOT NULL,
    -- Restricciones de integridad referencial
    FOREIGN KEY (user_id) 
        REFERENCES users(id)
        ON DELETE CASCADE    -- Elimina posts si se elimina usuario
        ON UPDATE CASCADE    -- Actualiza user_id si cambia id de usuario
);

-- Otras opciones:
-- ON DELETE SET NULL    -- Establece NULL si se elimina referencia
-- ON DELETE RESTRICT    -- Evita eliminación si hay referencias
-- ON DELETE NO ACTION   -- Similar a RESTRICT

Paso 7: Índices y optimización

Estrategia de indexación

-- Índices para búsquedas frecuentes
CREATE INDEX idx_users_email ON users(email);
CREATE INDEX idx_posts_created ON posts(created_at DESC);

-- Índices compuestos para consultas específicas
CREATE INDEX idx_users_name_status ON users(username, status);

-- Índices únicos para integridad
CREATE UNIQUE INDEX idx_unique_username ON users(username);

Consideraciones de rendimiento

-- ❌ Demasiados índices (ralentiza escrituras)
CREATE TABLE over_indexed_table (
    id INT PRIMARY KEY,
    col1 INT, INDEX idx1 (col1),
    col2 INT, INDEX idx2 (col2),
    col3 INT, INDEX idx3 (col3),
    col4 INT, INDEX idx4 (col4)
);

-- ✅ Índices estratégicos
CREATE TABLE optimized_table (
    id INT PRIMARY KEY,
    col1 INT, INDEX idx_search (col1, col2), -- Índice compuesto
    col2 INT,
    col3 INT, -- Sin índice (poco usado en búsquedas)
    col4 INT
);

Paso 8: Diseño para escalabilidad

Particionamiento de tablas

-- Particionamiento por rangos (PostgreSQL)
CREATE TABLE sales (
    sale_id SERIAL,
    sale_date DATE NOT NULL,
    amount DECIMAL(10,2)
) PARTITION BY RANGE (sale_date);

-- Crear particiones
CREATE TABLE sales_2023 PARTITION OF sales
FOR VALUES FROM ('2023-01-01') TO ('2024-01-01');

CREATE TABLE sales_2024 PARTITION OF sales
FOR VALUES FROM ('2024-01-01') TO ('2025-01-01');

Desnormalización controlada

-- ❌ Normalización extrema (muchos JOINs)
-- ✅ Desnormalización estratégica
CREATE TABLE posts (
    id INT PRIMARY KEY,
    title VARCHAR(255),
    author_name VARCHAR(100), -- Desnormalizado para evitar JOIN
    author_id INT,
    comment_count INT DEFAULT 0, -- Contador cacheado
    FOREIGN KEY (author_id) REFERENCES users(id)
);

Paso 9: Modelado de datos jerárquicos

Modelo Adjacency List

-- Para estructuras árbol (comentarios, categorías)
CREATE TABLE comments (
    id INT PRIMARY KEY,
    content TEXT,
    parent_id INT NULL,          -- Referencia al comentario padre
    post_id INT NOT NULL,
    FOREIGN KEY (parent_id) REFERENCES comments(id),
    FOREIGN KEY (post_id) REFERENCES posts(id)
);

Modelo Closure Table

-- Para consultas jerárquicas eficientes
CREATE TABLE categories (
    id INT PRIMARY KEY,
    name VARCHAR(100)
);

CREATE TABLE category_paths (
    ancestor_id INT,
    descendant_id INT,
    depth INT,
    PRIMARY KEY (ancestor_id, descendant_id),
    FOREIGN KEY (ancestor_id) REFERENCES categories(id),
    FOREIGN KEY (descendant_id) REFERENCES categories(id)
);

Paso 10: Herramientas de diseño

Diagramas ER con dbdiagram.io

// Sintaxis de dbdiagram.io
Table users {
  id int [pk, increment]
  username varchar [unique, not null]
  email varchar [unique, not null]
  created_at timestamp
}

Table posts {
  id int [pk, increment]
  title varchar [not null]
  user_id int [ref: > users.id]
  created_at timestamp
}

Table comments {
  id int [pk, increment]
  content text
  user_id int [ref: > users.id]
  post_id int [ref: > posts.id]
  parent_id int [ref: > comments.id, null]
}

SQL con migraciones

-- Ejemplo de migración estructurada
-- migrations/001_create_users_table.sql
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(50) UNIQUE NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- migrations/002_create_posts_table.sql
CREATE TABLE posts (
    id SERIAL PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    content TEXT NOT NULL,
    user_id INT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Paso 11: Patrones comunes de diseño

Soft Delete

CREATE TABLE products (
    id INT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    price DECIMAL(10,2) NOT NULL,
    is_deleted BOOLEAN DEFAULT FALSE,
    deleted_at TIMESTAMP NULL,
    deleted_by INT NULL REFERENCES users(id)
);

-- Consulta que excluye eliminados
SELECT * FROM products WHERE is_deleted = FALSE;

Audit Trail

CREATE TABLE audit_log (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    table_name VARCHAR(100) NOT NULL,
    record_id INT NOT NULL,
    action ENUM('INSERT', 'UPDATE', 'DELETE'),
    old_values JSON NULL,
    new_values JSON NULL,
    changed_by INT NOT NULL REFERENCES users(id),
    changed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Paso 12: Buenas prácticas y anti-patrones

✅ Buenas prácticas:

Usar nombres descriptivos y consistentes
Definir claves primarias apropiadas
Normalizar hasta 3NF, luego desnormalizar estratégicamente
Usar constraints para integridad de datos
Planear índices basados en patrones de consulta

❌ Anti-patrones:

Almacenamiento de EAV (Entity-Attribute-Value)
Tablas con decenas de columnas NULL
Índices en todas las columnas
Claves naturales que pueden cambiar
Ignorar la integridad referencial

Paso 13: Caso de estudio: Sistema de e-commerce

-- Esquema simplificado de e-commerce
CREATE TABLE customers (
    id SERIAL PRIMARY KEY,
    email VARCHAR(255) UNIQUE NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE products (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    price DECIMAL(10,2) NOT NULL CHECK (price >= 0),
    stock_quantity INT NOT NULL DEFAULT 0 CHECK (stock_quantity >= 0)
);

CREATE TABLE orders (
    id SERIAL PRIMARY KEY,
    customer_id INT NOT NULL REFERENCES customers(id),
    status VARCHAR(50) DEFAULT 'pending',
    total_amount DECIMAL(10,2) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE order_items (
    order_id INT REFERENCES orders(id) ON DELETE CASCADE,
    product_id INT REFERENCES products(id),
    quantity INT NOT NULL CHECK (quantity > 0),
    unit_price DECIMAL(10,2) NOT NULL,
    PRIMARY KEY (order_id, product_id)
);

Paso 14: Herramientas recomendadas

Diseño visual:

dbdiagram.io: Diagramas ER interactivos
Lucidchart: Herramientas de diagramación profesional
Draw.io: Alternativa gratuita y open source

Desarrollo:

ORM: Prisma, Sequelize, Django ORM
Migraciones: Flyway, Liquibase, Django Migrations
Monitoreo: pgAdmin, MySQL Workbench, DataGrip

Paso 15: Próximos pasos

Temas para profundizar:

Aprender sobre bases de datos NoSQL y cuándo usarlas
Profundizar en optimización de consultas complejas
Estudiar replicación y alta disponibilidad
Explorar data warehousing y diseño OLAP
Practicar con proyectos reales de diferentes dominios

Paso 16: Recursos y herramientas

Recursos para aprender más:

Database Design Notes: Universidad de Michigan
SQL Antipatterns: Bill Karwin
Designing Data-Intensive Applications: Martin Kleppmann
DB-Engines: Comparación de sistemas de bases de datos

Conclusión

¡Felicidades! Ahora tienes los fundamentos para diseñar bases de datos robustas y escalables. Practica estos conceptos en tus proyectos y construye sistemas de datos eficientes.

Para más tutoriales sobre bases de datos y desarrollo, visita nuestra sección de tutoriales.

¡Con estos conocimientos ya puedes diseñar bases de datos profesionales!

💡 Tip Importante

📝 Mejores Prácticas para Diseño de Bases de Datos

Para diseñar bases de datos efectivas y mantenibles, considera estos consejos esenciales:

Planifica antes de implementar: Dedica tiempo al análisis de requerimientos y diseño conceptual.

Normaliza apropiadamente: Normaliza hasta 3NF, pero desnormaliza cuando el rendimiento lo requiera.

Elige tipos de datos correctos: Selecciona tipos que representen exactamente los datos que necesitas.

Define constraints estrictos: Usa claves primarias, foráneas y checks para mantener la integridad.

Indexa estratégicamente: Crea índices basados en patrones de consulta reales, no en suposiciones.

Documenta tu diseño: Mantén diagramas ER y documentación actualizada del esquema.

Considera la escalabilidad: Diseña pensando en el crecimiento futuro de los datos.

Prueba el rendimiento: Valida que las consultas sean eficientes antes del despliegue.

📚 Documentación: Revisa las mejores prácticas de diseño de bases de datos en Database Design y libros como "SQL Antipatterns"

¡Estos consejos te ayudarán a crear bases de datos que soporten aplicaciones exitosas!