Saltar al contenido principal

Conceptos de Funciones

Estas son cláusulas y operadores fundamentales en SQL para filtrar y consultar datos en bases de datos:

WHERE​

Se usa para filtrar registros que cumplan una condición específica.

SELECT * FROM usuarios WHERE edad > 25;

AND​

Combina múltiples condiciones que deben cumplirse todas al mismo tiempo.

SELECT * FROM productos WHERE precio > 100 AND categoria = 'electrónicos';

OR​

Combina condiciones alternativas donde al menos una debe cumplirse.

SELECT * FROM empleados WHERE departamento = 'ventas' OR departamento = 'marketing';

LIKE​

Se usa para búsquedas con patrones usando comodines:

% representa cualquier secuencia de caracteres _ representa un solo carácter

SELECT * FROM clientes WHERE nombre LIKE 'Ana%';  -- Nombres que empiecen con "Ana"
SELECT * FROM productos WHERE codigo LIKE 'A_B';  -- Códigos como "A1B", "A2B", etc.

BETWEEN​

Filtra valores dentro de un rango (inclusive en ambos extremos).

SELECT * FROM ventas WHERE fecha BETWEEN '2024-01-01' AND '2024-12-31';
SELECT * FROM productos WHERE precio BETWEEN 50 AND 200;

Estos operadores se pueden combinar para crear consultas más complejas y precisas, permitiendo extraer exactamente los datos que necesitas de tu base de datos.

ORDER BY​

Es una cláusula en SQL que se utiliza para ordenar los resultados de una consulta según una o más columnas.
Por defecto, el orden es ascendente (ASC), pero también se puede especificar un orden descendente (DESC).

¿Cómo se usa?

Se coloca al final de una consulta SELECT, seguido del nombre de la columna por la cual se desea ordenar.

Sintaxis básica:

SELECT columnas
FROM tabla
ORDER BY columna [ASC | DESC];

Ejemplos de uso​

Ordenar por una columna (ascendente)​

SELECT * FROM productos
ORDER BY precio;

Ordenar por una columna (descendente)​

SELECT * FROM productos
ORDER BY precio DESC;

Ordenar por múltiples columnas​

SELECT * FROM empleados
ORDER BY departamento ASC, salario DESC;

Primero ordena por departamento en orden ascendente, y dentro de cada departamento, por salario en orden descendente.

Notas importantes​

  • Puedes ordenar por columnas que no estén en el SELECT.

  • También puedes usar el número de columna como referencia:

    SELECT nombre, edad, salario FROM empleados ORDER BY 3 DESC; -- Ordena por la tercera columna: salario

  • Es útil en conjunto con LIMIT para mostrar los primeros N resultados ordenados:

    SELECT * FROM productos
    ORDER BY fecha_agregado DESC
    LIMIT 5;

Usos comunes​

  • Mostrar los productos más baratos o caros.
  • Listar usuarios más antiguos o recientes.
  • Ordenar resultados alfabéticamente.
  • Priorizar datos según relevancia o puntuación.

Funciones de Agregación​

1. COUNT() – Contar filas​

Cuenta la cantidad de filas en una consulta, o la cantidad de valores no nulos en una columna específica.

SELECT COUNT(*) FROM empleados;
-- Devuelve el número total de filas en la tabla empleados.
SELECT COUNT(salario) FROM empleados;
-- Devuelve el número de filas donde salario NO es NULL.

2. SUM() – Sumar valores​

Suma los valores numéricos de una columna.

SELECT SUM(salario) FROM empleados;
-- Devuelve la suma de todos los salarios no nulos.

3. AVG() – Promedio​

Calcula el promedio de los valores numéricos en una columna, ignorando los valores NULL.

SELECT AVG(salario) FROM empleados;
-- Devuelve el promedio de los salarios.

4. MIN() – Valor mínimo​

Devuelve el valor mínimo de una columna.

SELECT MIN(salario) FROM empleados;
-- Devuelve el salario más bajo.

5. MAX() – Valor máximo​

Devuelve el valor máximo de una columna.

SELECT MAX(salario) FROM empleados;
-- Devuelve el salario más alto.

Uso con GROUP BY​

Las funciones de agregación se pueden aplicar a subconjuntos de datos usando GROUP BY.

SELECT departamento, AVG(salario)
FROM empleados
GROUP BY departamento;
-- Devuelve el promedio de salarios por departamento.

Consideraciones​

info
  • Las funciones de agregación ignoran los valores NULL.
  • Se pueden usar alias con AS para darle un nombre más legible a las columnas.
  • Al usarse con GROUP BY, el resultado contiene una fila por grupo.

EJERCICIOS DDL

Ejercicio 1: Sistema de Biblioteca​

Crear las siguientes tablas:​

1. Tabla AUTORES

CREATE TABLE autores (
    id_autor INT PRIMARY KEY AUTO_INCREMENT,
    nombre VARCHAR(100) NOT NULL,
    apellido VARCHAR(100) NOT NULL,
    nacionalidad VARCHAR(50),
    fecha_nacimiento DATE
);

2. Tabla LIBROS

CREATE TABLE libros (
    isbn VARCHAR(13) PRIMARY KEY,
    titulo VARCHAR(200) NOT NULL,
    id_autor INT,
    editorial VARCHAR(100),
    año_publicacion INT,
    numero_paginas INT,
    FOREIGN KEY (id_autor) REFERENCES autores(id_autor)
);

3. Tabla USUARIOS

CREATE TABLE usuarios (
    id_usuario INT PRIMARY KEY AUTO_INCREMENT,
    nombre VARCHAR(100) NOT NULL,
    email VARCHAR(150) UNIQUE NOT NULL,
    telefono VARCHAR(15),
    fecha_registro DATE DEFAULT CURRENT_DATE
);

4. Tabla PRESTAMOS

CREATE TABLE prestamos (
    id_prestamo INT PRIMARY KEY AUTO_INCREMENT,
    id_usuario INT,
    isbn VARCHAR(13),
    fecha_prestamo DATE NOT NULL,
    fecha_devolucion_esperada DATE NOT NULL,
    fecha_devolucion_real DATE,
    estado ENUM('activo', 'devuelto', 'vencido') DEFAULT 'activo',
    FOREIGN KEY (id_usuario) REFERENCES usuarios(id_usuario),
    FOREIGN KEY (isbn) REFERENCES libros(isbn)
);

Ejercicio 2: Sistema de Tienda Online​

Crear base de datos y tablas:​

1. Crear base de datos

CREATE DATABASE tienda_online;
USE tienda_online;

2. Tabla CATEGORIAS

CREATE TABLE categorias (
    id_categoria INT PRIMARY KEY AUTO_INCREMENT,
    nombre VARCHAR(100) NOT NULL UNIQUE,
    descripcion TEXT
);

3. Tabla PRODUCTOS

CREATE TABLE productos (
    id_producto INT PRIMARY KEY AUTO_INCREMENT,
    nombre VARCHAR(150) NOT NULL,
    descripcion TEXT,
    precio DECIMAL(10,2) NOT NULL CHECK (precio > 0),
    stock INT DEFAULT 0,
    id_categoria INT,
    fecha_creacion TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (id_categoria) REFERENCES categorias(id_categoria)
);

4. Tabla CLIENTES

CREATE TABLE clientes (
    id_cliente INT PRIMARY KEY AUTO_INCREMENT,
    nombre VARCHAR(100) NOT NULL,
    apellido VARCHAR(100) NOT NULL,
    email VARCHAR(150) UNIQUE NOT NULL,
    password VARCHAR(255) NOT NULL,
    direccion VARCHAR(255),
    ciudad VARCHAR(100),
    codigo_postal VARCHAR(10),
    telefono VARCHAR(15)
);

Ejercicio 3: Modificaciones con ALTER TABLE​

Modificar la tabla PRODUCTOS:​

1. Agregar nueva columna

ALTER TABLE productos 
ADD COLUMN marca VARCHAR(100);

2. Modificar tipo de dato

ALTER TABLE productos 
MODIFY COLUMN descripcion VARCHAR(500);

3. Agregar restricción

ALTER TABLE productos 
ADD CONSTRAINT chk_stock CHECK (stock >= 0);

4. Crear índice

CREATE INDEX idx_producto_nombre ON productos(nombre);

Modificar la tabla CLIENTES:​

1. Agregar columnas de auditoría

ALTER TABLE clientes 
ADD COLUMN fecha_registro TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
ADD COLUMN fecha_actualizacion TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP;

2. Cambiar nombre de columna

ALTER TABLE clientes 
CHANGE COLUMN password contraseña VARCHAR(255) NOT NULL;

Ejercicio 4: Sistema de Empleados​

Crear estructura completa:​

1. Tabla DEPARTAMENTOS

CREATE TABLE departamentos (
    id_departamento INT PRIMARY KEY AUTO_INCREMENT,
    nombre VARCHAR(100) NOT NULL UNIQUE,
    ubicacion VARCHAR(100),
    presupuesto DECIMAL(12,2)
);

2. Tabla CARGOS

CREATE TABLE cargos (
    id_cargo INT PRIMARY KEY AUTO_INCREMENT,
    titulo VARCHAR(100) NOT NULL,
    salario_min DECIMAL(10,2),
    salario_max DECIMAL(10,2),
    CONSTRAINT chk_salario CHECK (salario_max >= salario_min)
);

3. Tabla EMPLEADOS

CREATE TABLE empleados (
    id_empleado INT PRIMARY KEY AUTO_INCREMENT,
    numero_empleado VARCHAR(10) UNIQUE NOT NULL,
    nombre VARCHAR(100) NOT NULL,
    apellido VARCHAR(100) NOT NULL,
    email VARCHAR(150) UNIQUE,
    telefono VARCHAR(15),
    fecha_contratacion DATE NOT NULL,
    salario DECIMAL(10,2),
    id_cargo INT,
    id_departamento INT,
    id_supervisor INT,
    estado ENUM('activo', 'inactivo', 'vacaciones') DEFAULT 'activo',
    FOREIGN KEY (id_cargo) REFERENCES cargos(id_cargo),
    FOREIGN KEY (id_departamento) REFERENCES departamentos(id_departamento),
    FOREIGN KEY (id_supervisor) REFERENCES empleados(id_empleado)
);

Ejercicio 5: Operaciones de Eliminación​

Eliminar elementos de la estructura:​

1. Eliminar restricción

ALTER TABLE empleados 
DROP FOREIGN KEY empleados_ibfk_3;

2. Eliminar columna

ALTER TABLE empleados 
DROP COLUMN telefono;

3. Eliminar índice

DROP INDEX idx_producto_nombre ON productos;

4. Eliminar tabla

DROP TABLE prestamos;

5. Eliminar base de datos

DROP DATABASE tienda_online;

Ejercicio 6: Crear Vistas y Índices​

1. Crear vista de productos activos

CREATE VIEW productos_disponibles AS
SELECT p.nombre, p.precio, p.stock, c.nombre AS categoria
FROM productos p
JOIN categorias c ON p.id_categoria = c.id_categoria
WHERE p.stock > 0;

2. Crear índices compuestos

CREATE INDEX idx_empleado_depto_cargo 
ON empleados(id_departamento, id_cargo);

CREATE INDEX idx_prestamo_fechas 
ON prestamos(fecha_prestamo, fecha_devolucion_esperada);

Desafíos Adicionales​

1. Crear tabla con múltiples restricciones​

CREATE TABLE ventas (
    id_venta INT PRIMARY KEY AUTO_INCREMENT,
    numero_venta VARCHAR(20) UNIQUE NOT NULL,
    id_cliente INT NOT NULL,
    fecha_venta DATE NOT NULL,
    total DECIMAL(12,2) NOT NULL CHECK (total > 0),
    descuento DECIMAL(5,2) DEFAULT 0 CHECK (descuento >= 0 AND descuento <= 100),
    impuesto DECIMAL(12,2) GENERATED ALWAYS AS (total * 0.19) STORED,
    estado ENUM('pendiente', 'pagada', 'cancelada') DEFAULT 'pendiente',
    FOREIGN KEY (id_cliente) REFERENCES clientes(id_cliente) ON DELETE CASCADE
);

2. Crear tabla temporal​

CREATE TEMPORARY TABLE temp_reportes (
    id INT AUTO_INCREMENT PRIMARY KEY,
    descripcion VARCHAR(255),
    fecha_creacion TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

3. Crear tabla con particionamiento (MySQL)​

CREATE TABLE logs_sistema (
    id INT AUTO_INCREMENT,
    fecha DATE NOT NULL,
    mensaje TEXT,
    nivel ENUM('INFO', 'WARNING', 'ERROR'),
    PRIMARY KEY (id, fecha)
) PARTITION BY RANGE (YEAR(fecha)) (
    PARTITION p2023 VALUES LESS THAN (2024),
    PARTITION p2024 VALUES LESS THAN (2025),
    PARTITION p2025 VALUES LESS THAN (2026)
);

Práctica Recomendada​

  1. Ejecuta cada ejercicio paso a paso
  2. Verifica la estructura con DESCRIBE nombre_tabla;
  3. Practica las modificaciones en un entorno de prueba
  4. Documenta tus cambios para mantener un historial
  5. Usa comentarios en tu código SQL para mayor claridad

ORDER BY - EJERCICIOS

1. Ordena los usuarios por nombre alfabéticamente​

Tabla: users

idnameemail
1Carlacarla@mail.com
2Andrésandres@mail.com
3Brunobruno@mail.com

2. Ordena los productos por precio de mayor a menor​

Tabla: products

idnameprice
1Laptop1200
2Teclado100
3Monitor350

3. Ordena los usuarios por fecha de registro, del más antiguo al más reciente​

Tabla: users

idnameregistered_at
1Mario2023-08-01
2Lucía2023-05-15
3Diego2023-06-20

4. Ordena los productos por cantidad de stock, del que tiene más al que tiene menos​

Tabla: products

idnamestock
1Mouse60
2Laptop20
3Monitor45

5. Ordena los usuarios por edad, de menor a mayor​

Tabla: users

idnameage
1Laura22
2Pablo35
3Ana29

6. Ordena los productos primero por categoría (alfabéticamente) y luego por precio de menor a mayor​

Tabla: products

idnamecategoryprice
1SillaHogar80
2CelularTecnología600
3MesaHogar120

FUNCIONES DE AGREGACION - EJERCICIOS

Ejemplos de Práctica​

Supongamos la siguiente tabla empleados:

idnombredepartamentosalario
1AnaVentas2500
2JuanMarketing3200
3LauraVentas2800
4PedroMarketing3000
5AndrésVentasNULL

Ejemplos con soluciones y resultados esperados:​

  1. SELECT COUNT(*) FROM empleados; → 5

  2. SELECT COUNT(salario) FROM empleados; → 4

  3. SELECT SUM(salario) FROM empleados; → 11500

  4. SELECT AVG(salario) FROM empleados; → 2875

  5. SELECT MIN(salario) FROM empleados; → 2500

  6. SELECT MAX(salario) FROM empleados; → 3200

  7. SELECT COUNT(*) FROM empleados WHERE departamento = 'Ventas'; → 3

  8. SELECT AVG(salario) FROM empleados WHERE departamento = 'Marketing'; → 3100

  9. SELECT SUM(salario) FROM empleados WHERE salario > 2600; → 9000

  10. SELECT MIN(salario) FROM empleados WHERE departamento = 'Ventas'; → 2500

  11. SELECT MAX(salario) FROM empleados WHERE departamento = 'Ventas'; → 2800

  12. SELECT COUNT(*) FROM empleados WHERE salario IS NULL; → 1

  13. SELECT COUNT(*) FROM empleados WHERE salario IS NOT NULL; → 4

  14. SELECT departamento, COUNT(*) FROM empleados GROUP BY departamento; → Ventas: 3, Marketing: 2

  15. SELECT departamento, AVG(salario) FROM empleados GROUP BY departamento; → Ventas: 2650, Marketing: 3100

  16. SELECT departamento, MAX(salario) FROM empleados GROUP BY departamento; → Ventas: 2800, Marketing: 3200

  17. SELECT departamento, MIN(salario) FROM empleados GROUP BY departamento; → Ventas: 2500, Marketing: 3000

  18. SELECT departamento, SUM(salario) FROM empleados GROUP BY departamento; → Ventas: 5300, Marketing: 6200

  19. SELECT departamento FROM empleados GROUP BY departamento HAVING COUNT(*) > 2; → Ventas

  20. SELECT departamento FROM empleados GROUP BY departamento HAVING AVG(salario) > 2800; → Marketing